From b871e0605af1f28ffc6b23ca6c94226c4f568785 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Mon, 29 Dec 2025 22:45:50 +0100
Subject: [PATCH 01/26] chore: prepare release 0.6.3

---
 CHANGELOG.md                                              | 8 ++++++++
 CLAUDE.md                                                 | 2 +-
 cli/pom.xml                                               | 2 +-
 .../main/java/org/pragmatica/aether/cli/AetherCli.java    | 4 ++--
 cluster/pom.xml                                           | 2 +-
 common/pom.xml                                            | 2 +-
 example-slice/pom.xml                                     | 2 +-
 examples/order-demo/pom.xml                               | 2 +-
 examples/order-demo/run.sh                                | 2 +-
 forge/pom.xml                                             | 2 +-
 http-server/pom.xml                                       | 2 +-
 infra-services/artifact-repo/pom.xml                      | 2 +-
 infra-services/pom.xml                                    | 2 +-
 node/pom.xml                                              | 2 +-
 pom.xml                                                   | 2 +-
 script/aether-forge.sh                                    | 2 +-
 script/aether-node.sh                                     | 2 +-
 script/aether.sh                                          | 2 +-
 slice-annotations/pom.xml                                 | 2 +-
 slice-api/pom.xml                                         | 2 +-
 slice/pom.xml                                             | 2 +-
 21 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e94d81d0..d7005d07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.3] - 2025-12-29
+
+### Added
+
+### Changed
+
+### Fixed
+
 ## [0.6.2] - 2025-12-29
 
 ### Added
diff --git a/CLAUDE.md b/CLAUDE.md
index 5e077ad2..0e47ff53 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -2,7 +2,7 @@
 
 ## Project Overview
 
-**Pragmatica Aether Distributed Runtime** (v0.6.2) is an AI-driven distributed runtime environment for Java that enables predictive scaling,
+**Pragmatica Aether Distributed Runtime** (v0.6.3) is an AI-driven distributed runtime environment for Java that enables predictive scaling,
 intelligent orchestration, and seamless multi-cloud deployment without requiring changes to business logic.
 
 **See [docs/vision-and-goals.md](docs/vision-and-goals.md) for complete vision and design principles.**
diff --git a/cli/pom.xml b/cli/pom.xml
index 8705bb61..6b661385 100644
--- a/cli/pom.xml
+++ b/cli/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>cli</artifactId>
diff --git a/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java b/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
index 3d5f0097..67571184 100644
--- a/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
+++ b/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
@@ -41,7 +41,7 @@
  */
 @Command(name = "aether",
          mixinStandardHelpOptions = true,
-         version = "Aether 0.6.2",
+         version = "Aether 0.6.3",
          description = "Command-line interface for Aether cluster management",
          subcommands = {
                  AetherCli.StatusCommand.class,
@@ -88,7 +88,7 @@ public void run() {
     }
 
     private void runRepl(CommandLine cmd) {
-        System.out.println("Aether v0.6.2 - Connected to " + nodeAddress);
+        System.out.println("Aether v0.6.3 - Connected to " + nodeAddress);
         System.out.println("Type 'help' for available commands, 'exit' to quit.");
         System.out.println();
 
diff --git a/cluster/pom.xml b/cluster/pom.xml
index 955d8375..d153b020 100644
--- a/cluster/pom.xml
+++ b/cluster/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>cluster</artifactId>
diff --git a/common/pom.xml b/common/pom.xml
index d2736ef5..99bfb434 100644
--- a/common/pom.xml
+++ b/common/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>common</artifactId>
diff --git a/example-slice/pom.xml b/example-slice/pom.xml
index d4641262..54b6146d 100644
--- a/example-slice/pom.xml
+++ b/example-slice/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>example-slice</artifactId>
diff --git a/examples/order-demo/pom.xml b/examples/order-demo/pom.xml
index 1dfe96a4..60d2823d 100644
--- a/examples/order-demo/pom.xml
+++ b/examples/order-demo/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
         <relativePath>../../pom.xml</relativePath>
     </parent>
 
diff --git a/examples/order-demo/run.sh b/examples/order-demo/run.sh
index 2b9e52ee..92fbe3ab 100755
--- a/examples/order-demo/run.sh
+++ b/examples/order-demo/run.sh
@@ -31,4 +31,4 @@ export CLUSTER_SIZE=${CLUSTER_SIZE:-5}
 export LOAD_RATE=${LOAD_RATE:-1000}
 
 # Run with the shaded JAR
-java -jar "$ROOT_DIR/forge/target/forge-0.6.2-shaded.jar"
+java -jar "$ROOT_DIR/forge/target/forge-0.6.3-shaded.jar"
diff --git a/forge/pom.xml b/forge/pom.xml
index 8ffb2aa9..df1ffe2f 100644
--- a/forge/pom.xml
+++ b/forge/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>forge</artifactId>
diff --git a/http-server/pom.xml b/http-server/pom.xml
index 0f567940..4ae9c5ad 100644
--- a/http-server/pom.xml
+++ b/http-server/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>http-server</artifactId>
diff --git a/infra-services/artifact-repo/pom.xml b/infra-services/artifact-repo/pom.xml
index 618cf9bf..d1628e63 100644
--- a/infra-services/artifact-repo/pom.xml
+++ b/infra-services/artifact-repo/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>infra-services</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>artifact-repo</artifactId>
diff --git a/infra-services/pom.xml b/infra-services/pom.xml
index f35f14e5..589de867 100644
--- a/infra-services/pom.xml
+++ b/infra-services/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>infra-services</artifactId>
diff --git a/node/pom.xml b/node/pom.xml
index af47e1e0..5326e2be 100644
--- a/node/pom.xml
+++ b/node/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>node</artifactId>
diff --git a/pom.xml b/pom.xml
index 6393c2d2..65e4e1b8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>org.pragmatica-lite.aether</groupId>
     <artifactId>aether</artifactId>
-    <version>0.6.2</version>
+    <version>0.6.3</version>
     <packaging>pom</packaging>
     <name>Pragmatica Aether Distributed Runtime</name>
     <description>AI-driven distributed runtime environment for Java applications</description>
diff --git a/script/aether-forge.sh b/script/aether-forge.sh
index 4f50d788..3a89ce35 100755
--- a/script/aether-forge.sh
+++ b/script/aether-forge.sh
@@ -18,7 +18,7 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
 
-JAR_FILE="$PROJECT_DIR/forge/target/forge-0.6.2-SNAPSHOT.jar"
+JAR_FILE="$PROJECT_DIR/forge/target/forge-0.6.3-SNAPSHOT.jar"
 
 if [ ! -f "$JAR_FILE" ]; then
     echo "Forge JAR not found. Building..."
diff --git a/script/aether-node.sh b/script/aether-node.sh
index 2940a969..edfa288f 100755
--- a/script/aether-node.sh
+++ b/script/aether-node.sh
@@ -32,7 +32,7 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
 
-JAR_FILE="$PROJECT_DIR/node/target/node-0.6.2-SNAPSHOT.jar"
+JAR_FILE="$PROJECT_DIR/node/target/node-0.6.3-SNAPSHOT.jar"
 
 if [ ! -f "$JAR_FILE" ]; then
     echo "Node JAR not found. Building..."
diff --git a/script/aether.sh b/script/aether.sh
index 45185fd1..4125af0a 100755
--- a/script/aether.sh
+++ b/script/aether.sh
@@ -29,7 +29,7 @@
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
 
-JAR_FILE="$PROJECT_DIR/cli/target/cli-0.6.2-SNAPSHOT.jar"
+JAR_FILE="$PROJECT_DIR/cli/target/cli-0.6.3-SNAPSHOT.jar"
 
 if [ ! -f "$JAR_FILE" ]; then
     echo "CLI JAR not found. Building..."
diff --git a/slice-annotations/pom.xml b/slice-annotations/pom.xml
index 935d4ca8..5734b01d 100644
--- a/slice-annotations/pom.xml
+++ b/slice-annotations/pom.xml
@@ -7,7 +7,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>slice-annotations</artifactId>
diff --git a/slice-api/pom.xml b/slice-api/pom.xml
index febc1659..43053ce0 100644
--- a/slice-api/pom.xml
+++ b/slice-api/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>slice-api</artifactId>
diff --git a/slice/pom.xml b/slice/pom.xml
index 5f2d8f3b..16866919 100644
--- a/slice/pom.xml
+++ b/slice/pom.xml
@@ -6,7 +6,7 @@
     <parent>
         <groupId>org.pragmatica-lite.aether</groupId>
         <artifactId>aether</artifactId>
-        <version>0.6.2</version>
+        <version>0.6.3</version>
     </parent>
 
     <artifactId>slice</artifactId>

From 59c47eac7e3eb0c21c58cd543a0eca0115e9b65d Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Mon, 29 Dec 2025 23:47:46 +0100
Subject: [PATCH 02/26] build: add jbct-maven-plugin 0.3.12 (disabled)

---
 pom.xml | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/pom.xml b/pom.xml
index 65e4e1b8..584e9418 100644
--- a/pom.xml
+++ b/pom.xml
@@ -48,6 +48,7 @@
         <netty.version>4.2.0.Final</netty.version>
         <kryo.version>5.6.2</kryo.version>
         <fury-core.version>0.10.2</fury-core.version>
+        <jbct.version>0.3.12</jbct.version>
     </properties>
 
     <dependencyManagement>
@@ -235,6 +236,21 @@
                         </execution>
                     </executions>
                 </plugin>
+                <plugin>
+                    <groupId>org.pragmatica-lite</groupId>
+                    <artifactId>jbct-maven-plugin</artifactId>
+                    <version>${jbct.version}</version>
+                    <configuration>
+                        <skip>true</skip> <!-- TODO: enable after fixing enum formatting bug -->
+                    </configuration>
+                    <executions>
+                        <execution>
+                            <goals>
+                                <goal>format</goal>
+                            </goals>
+                        </execution>
+                    </executions>
+                </plugin>
                 <plugin>
                     <artifactId>maven-shade-plugin</artifactId>
                     <version>3.6.0</version>
@@ -266,6 +282,10 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-failsafe-plugin</artifactId>
             </plugin>
+            <plugin>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>jbct-maven-plugin</artifactId>
+            </plugin>
         </plugins>
     </build>
 </project>
\ No newline at end of file

From d549b9899e7df16e49986c7325794042749af415 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 00:48:19 +0100
Subject: [PATCH 03/26] feat: add production dashboard with real-time metrics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |   5 +
 .../pragmatica/aether/api/AlertManager.java   | 181 +++++++
 .../aether/api/DashboardMetricsPublisher.java | 261 +++++++++
 .../aether/api/DashboardWebSocketHandler.java |  86 +++
 .../aether/api/ManagementServer.java          |  88 ++-
 node/src/main/resources/dashboard/index.html  | 425 +++++++++++++++
 node/src/main/resources/dashboard/style.css   | 512 ++++++++++++++++++
 7 files changed, 1555 insertions(+), 3 deletions(-)
 create mode 100644 node/src/main/java/org/pragmatica/aether/api/AlertManager.java
 create mode 100644 node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
 create mode 100644 node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
 create mode 100644 node/src/main/resources/dashboard/index.html
 create mode 100644 node/src/main/resources/dashboard/style.css

diff --git a/CHANGELOG.md b/CHANGELOG.md
index d7005d07..8fc9339f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.6.3] - 2025-12-29
 
 ### Added
+- **Production dashboard** - Real-time cluster monitoring at `/dashboard` with Alpine.js and Chart.js
+- **WebSocket metrics streaming** - 1-second broadcast of cluster metrics via `/ws/dashboard`
+- **Alert management** - Configurable thresholds with in-memory alert tracking
+- **Dashboard tabs** - Metrics, Slices, History, and Alerts views
+- **New API endpoints** - `/slices/status`, `/invocation-metrics`, `/thresholds`, `/alerts`
 
 ### Changed
 
diff --git a/node/src/main/java/org/pragmatica/aether/api/AlertManager.java b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
new file mode 100644
index 00000000..8ea1e383
--- /dev/null
+++ b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
@@ -0,0 +1,181 @@
+package org.pragmatica.aether.api;
+
+import org.pragmatica.cluster.net.NodeId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Manages alert thresholds and tracks active alerts.
+ *
+ * <p>In-memory only - thresholds reset on node restart.
+ */
+public class AlertManager {
+
+    private static final Logger log = LoggerFactory.getLogger(AlertManager.class);
+    private static final int MAX_ALERT_HISTORY = 100;
+
+    private final Map<String, Threshold> thresholds = new ConcurrentHashMap<>();
+    private final Map<String, ActiveAlert> activeAlerts = new ConcurrentHashMap<>();
+    private final List<AlertHistoryEntry> alertHistory = new ArrayList<>();
+
+    public AlertManager() {
+        // Default thresholds
+        thresholds.put("cpu.usage", new Threshold(0.7, 0.9));
+        thresholds.put("heap.usage", new Threshold(0.7, 0.85));
+    }
+
+    /**
+     * Set threshold for a metric.
+     */
+    public void setThreshold(String metric, double warning, double critical) {
+        thresholds.put(metric, new Threshold(warning, critical));
+    }
+
+    /**
+     * Check if a metric value exceeds threshold and return alert JSON if triggered.
+     */
+    public String checkThreshold(String metric, NodeId nodeId, double value) {
+        var threshold = thresholds.get(metric);
+        if (threshold == null) {
+            return null;
+        }
+
+        var alertKey = metric + ":" + nodeId.id();
+        var existing = activeAlerts.get(alertKey);
+        var severity = threshold.severity(value);
+
+        if (severity == null) {
+            // Value is normal, clear any existing alert
+            if (existing != null) {
+                activeAlerts.remove(alertKey);
+                addToHistory(metric, nodeId, value, existing.severity, "RESOLVED");
+            }
+            return null;
+        }
+
+        // Check if this is a new alert or severity change
+        if (existing == null || !existing.severity.equals(severity)) {
+            var alert = new ActiveAlert(metric, nodeId, value, threshold.forSeverity(severity), severity, System.currentTimeMillis());
+            activeAlerts.put(alertKey, alert);
+            addToHistory(metric, nodeId, value, severity, "TRIGGERED");
+
+            // Return alert message to broadcast
+            return buildAlertMessage(alert);
+        }
+
+        return null; // No change
+    }
+
+    private String buildAlertMessage(ActiveAlert alert) {
+        return "{\"type\":\"ALERT\",\"timestamp\":" + System.currentTimeMillis() + ",\"data\":{" +
+                "\"metric\":\"" + alert.metric + "\"," +
+                "\"nodeId\":\"" + alert.nodeId.id() + "\"," +
+                "\"value\":" + alert.value + "," +
+                "\"threshold\":" + alert.threshold + "," +
+                "\"severity\":\"" + alert.severity + "\"}}";
+    }
+
+    private void addToHistory(String metric, NodeId nodeId, double value, String severity, String status) {
+        synchronized (alertHistory) {
+            alertHistory.add(new AlertHistoryEntry(
+                    System.currentTimeMillis(),
+                    metric,
+                    nodeId.id(),
+                    value,
+                    severity,
+                    status
+            ));
+            while (alertHistory.size() > MAX_ALERT_HISTORY) {
+                alertHistory.remove(0);
+            }
+        }
+    }
+
+    /**
+     * Get all thresholds as JSON.
+     */
+    public String thresholdsAsJson() {
+        var sb = new StringBuilder();
+        sb.append("{");
+        boolean first = true;
+        for (var entry : thresholds.entrySet()) {
+            if (!first) sb.append(",");
+            sb.append("\"").append(entry.getKey()).append("\":{");
+            sb.append("\"warning\":").append(entry.getValue().warning).append(",");
+            sb.append("\"critical\":").append(entry.getValue().critical);
+            sb.append("}");
+            first = false;
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+
+    /**
+     * Get active alerts as JSON.
+     */
+    public String activeAlertsAsJson() {
+        var sb = new StringBuilder();
+        sb.append("[");
+        boolean first = true;
+        for (var alert : activeAlerts.values()) {
+            if (!first) sb.append(",");
+            sb.append("{");
+            sb.append("\"metric\":\"").append(alert.metric).append("\",");
+            sb.append("\"nodeId\":\"").append(alert.nodeId.id()).append("\",");
+            sb.append("\"value\":").append(alert.value).append(",");
+            sb.append("\"threshold\":").append(alert.threshold).append(",");
+            sb.append("\"severity\":\"").append(alert.severity).append("\",");
+            sb.append("\"triggeredAt\":").append(alert.triggeredAt);
+            sb.append("}");
+            first = false;
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    /**
+     * Get alert history as JSON.
+     */
+    public String alertHistoryAsJson() {
+        var sb = new StringBuilder();
+        sb.append("[");
+        synchronized (alertHistory) {
+            boolean first = true;
+            for (var entry : alertHistory) {
+                if (!first) sb.append(",");
+                sb.append("{");
+                sb.append("\"timestamp\":").append(entry.timestamp).append(",");
+                sb.append("\"metric\":\"").append(entry.metric).append("\",");
+                sb.append("\"nodeId\":\"").append(entry.nodeId).append("\",");
+                sb.append("\"value\":").append(entry.value).append(",");
+                sb.append("\"severity\":\"").append(entry.severity).append("\",");
+                sb.append("\"status\":\"").append(entry.status).append("\"");
+                sb.append("}");
+                first = false;
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
+
+    private record Threshold(double warning, double critical) {
+        String severity(double value) {
+            if (value >= critical) return "CRITICAL";
+            if (value >= warning) return "WARNING";
+            return null;
+        }
+
+        double forSeverity(String severity) {
+            return "CRITICAL".equals(severity) ? critical : warning;
+        }
+    }
+
+    private record ActiveAlert(String metric, NodeId nodeId, double value, double threshold, String severity, long triggeredAt) {}
+
+    private record AlertHistoryEntry(long timestamp, String metric, String nodeId, double value, String severity, String status) {}
+}
diff --git a/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
new file mode 100644
index 00000000..d5984ef5
--- /dev/null
+++ b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
@@ -0,0 +1,261 @@
+package org.pragmatica.aether.api;
+
+import org.pragmatica.aether.node.AetherNode;
+import org.pragmatica.cluster.net.NodeId;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+/**
+ * Publishes dashboard metrics via WebSocket at regular intervals.
+ *
+ * <p>Aggregates metrics from various collectors and broadcasts to all connected clients.
+ */
+public class DashboardMetricsPublisher {
+
+    private static final Logger log = LoggerFactory.getLogger(DashboardMetricsPublisher.class);
+    private static final long BROADCAST_INTERVAL_MS = 1000;
+
+    private final Supplier<AetherNode> nodeSupplier;
+    private final AlertManager alertManager;
+    private final ScheduledExecutorService scheduler;
+    private volatile boolean running;
+
+    public DashboardMetricsPublisher(Supplier<AetherNode> nodeSupplier, AlertManager alertManager) {
+        this.nodeSupplier = nodeSupplier;
+        this.alertManager = alertManager;
+        this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
+            var thread = new Thread(r, "dashboard-publisher");
+            thread.setDaemon(true);
+            return thread;
+        });
+    }
+
+    public void start() {
+        if (running) return;
+        running = true;
+        scheduler.scheduleAtFixedRate(this::publishMetrics, BROADCAST_INTERVAL_MS, BROADCAST_INTERVAL_MS, TimeUnit.MILLISECONDS);
+        log.info("Dashboard metrics publisher started");
+    }
+
+    public void stop() {
+        running = false;
+        scheduler.shutdown();
+        log.info("Dashboard metrics publisher stopped");
+    }
+
+    private void publishMetrics() {
+        if (DashboardWebSocketHandler.connectedClients() == 0) {
+            return; // No clients connected, skip
+        }
+
+        try {
+            var message = buildMetricsUpdate();
+            DashboardWebSocketHandler.broadcast(message);
+
+            // Check thresholds and broadcast alerts
+            checkAndBroadcastAlerts();
+        } catch (Exception e) {
+            log.error("Error publishing metrics", e);
+        }
+    }
+
+    private void checkAndBroadcastAlerts() {
+        var node = nodeSupplier.get();
+        var allMetrics = node.metricsCollector().allMetrics();
+
+        for (var entry : allMetrics.entrySet()) {
+            var nodeId = entry.getKey();
+            var metrics = entry.getValue();
+
+            for (var metric : metrics.entrySet()) {
+                var alert = alertManager.checkThreshold(metric.getKey(), nodeId, metric.getValue());
+                if (alert != null) {
+                    DashboardWebSocketHandler.broadcast(alert);
+                }
+            }
+        }
+    }
+
+    /**
+     * Build initial state snapshot for newly connected clients.
+     */
+    public String buildInitialState() {
+        var node = nodeSupplier.get();
+        var sb = new StringBuilder();
+        sb.append("{\"type\":\"INITIAL_STATE\",\"timestamp\":").append(System.currentTimeMillis()).append(",\"data\":{");
+
+        // Nodes (first node in sorted list is typically the leader in Rabia)
+        sb.append("\"nodes\":[");
+        var allMetrics = node.metricsCollector().allMetrics();
+        var sortedNodes = allMetrics.keySet().stream()
+                .sorted((a, b) -> a.id().compareTo(b.id()))
+                .collect(Collectors.toList());
+        var leaderId = sortedNodes.isEmpty() ? "" : sortedNodes.get(0).id();
+        boolean firstNode = true;
+        for (var nodeId : sortedNodes) {
+            if (!firstNode) sb.append(",");
+            sb.append("{\"id\":\"").append(nodeId.id()).append("\",");
+            sb.append("\"isLeader\":").append(nodeId.id().equals(leaderId)).append("}");
+            firstNode = false;
+        }
+        sb.append("],");
+
+        // Slices
+        sb.append("\"slices\":[");
+        var slices = node.sliceStore().loaded();
+        boolean firstSlice = true;
+        for (var slice : slices) {
+            if (!firstSlice) sb.append(",");
+            sb.append("\"").append(slice.artifact().asString()).append("\"");
+            firstSlice = false;
+        }
+        sb.append("],");
+
+        // Thresholds
+        sb.append("\"thresholds\":").append(alertManager.thresholdsAsJson()).append(",");
+
+        // Current metrics snapshot
+        sb.append("\"metrics\":").append(buildMetricsData());
+
+        sb.append("}}");
+        return sb.toString();
+    }
+
+    /**
+     * Build periodic metrics update message.
+     */
+    private String buildMetricsUpdate() {
+        var sb = new StringBuilder();
+        sb.append("{\"type\":\"METRICS_UPDATE\",\"timestamp\":").append(System.currentTimeMillis());
+        sb.append(",\"data\":").append(buildMetricsData()).append("}");
+        return sb.toString();
+    }
+
+    private String buildMetricsData() {
+        var node = nodeSupplier.get();
+        var sb = new StringBuilder();
+        sb.append("{");
+
+        // Load metrics
+        sb.append("\"load\":{");
+        var allMetrics = node.metricsCollector().allMetrics();
+        boolean firstNode = true;
+        for (var entry : allMetrics.entrySet()) {
+            if (!firstNode) sb.append(",");
+            sb.append("\"").append(entry.getKey().id()).append("\":{");
+
+            boolean firstMetric = true;
+            for (var metric : entry.getValue().entrySet()) {
+                if (!firstMetric) sb.append(",");
+                sb.append("\"").append(metric.getKey()).append("\":").append(metric.getValue());
+                firstMetric = false;
+            }
+
+            sb.append("}");
+            firstNode = false;
+        }
+        sb.append("},");
+
+        // Invocation metrics (if available)
+        sb.append("\"invocations\":").append(buildInvocationMetrics());
+
+        sb.append("}");
+        return sb.toString();
+    }
+
+    private String buildInvocationMetrics() {
+        // TODO: expose invocationMetricsCollector via AetherNode interface
+        return "[]";
+    }
+
+    /**
+     * Handle threshold configuration from client.
+     */
+    public void handleSetThreshold(String message) {
+        // Parse: {"type":"SET_THRESHOLD","metric":"cpu.usage","warning":0.7,"critical":0.9}
+        var metricPattern = Pattern.compile("\"metric\"\\s*:\\s*\"([^\"]+)\"");
+        var warningPattern = Pattern.compile("\"warning\"\\s*:\\s*([\\d.]+)");
+        var criticalPattern = Pattern.compile("\"critical\"\\s*:\\s*([\\d.]+)");
+
+        var metricMatch = metricPattern.matcher(message);
+        var warningMatch = warningPattern.matcher(message);
+        var criticalMatch = criticalPattern.matcher(message);
+
+        if (metricMatch.find() && warningMatch.find() && criticalMatch.find()) {
+            var metric = metricMatch.group(1);
+            var warning = Double.parseDouble(warningMatch.group(1));
+            var critical = Double.parseDouble(criticalMatch.group(1));
+            alertManager.setThreshold(metric, warning, critical);
+            log.info("Updated threshold for {}: warning={}, critical={}", metric, warning, critical);
+        }
+    }
+
+    /**
+     * Build history response for GET_HISTORY request.
+     */
+    public String buildHistoryResponse(String message) {
+        // Parse: {"type":"GET_HISTORY","timeRange":"1h"}
+        var rangePattern = Pattern.compile("\"timeRange\"\\s*:\\s*\"([^\"]+)\"");
+        var rangeMatch = rangePattern.matcher(message);
+
+        var range = "1h";
+        if (rangeMatch.find()) {
+            range = rangeMatch.group(1);
+        }
+
+        var node = nodeSupplier.get();
+        var historicalData = node.metricsCollector().historicalMetrics();
+        var cutoff = System.currentTimeMillis() - parseTimeRange(range);
+
+        var sb = new StringBuilder();
+        sb.append("{\"type\":\"HISTORY\",\"timeRange\":\"").append(range).append("\",\"nodes\":{");
+
+        // Build node-centric history: {"nodes": {"node-1": [{"timestamp": ..., "metrics": {...}}, ...]}}
+        boolean firstNode = true;
+        for (var nodeEntry : historicalData.entrySet()) {
+            if (!firstNode) sb.append(",");
+            sb.append("\"").append(nodeEntry.getKey().id()).append("\":[");
+
+            boolean firstSnapshot = true;
+            for (var snapshot : nodeEntry.getValue()) {
+                if (snapshot.timestamp() < cutoff) continue;
+
+                if (!firstSnapshot) sb.append(",");
+                sb.append("{\"timestamp\":").append(snapshot.timestamp()).append(",\"metrics\":{");
+
+                boolean firstMetric = true;
+                for (var metric : snapshot.metrics().entrySet()) {
+                    if (!firstMetric) sb.append(",");
+                    sb.append("\"").append(metric.getKey()).append("\":").append(metric.getValue());
+                    firstMetric = false;
+                }
+
+                sb.append("}}");
+                firstSnapshot = false;
+            }
+
+            sb.append("]");
+            firstNode = false;
+        }
+
+        sb.append("}}");
+        return sb.toString();
+    }
+
+    private long parseTimeRange(String range) {
+        return switch (range) {
+            case "5m" -> 5 * 60 * 1000L;
+            case "15m" -> 15 * 60 * 1000L;
+            case "1h" -> 60 * 60 * 1000L;
+            case "2h" -> 2 * 60 * 60 * 1000L;
+            default -> 60 * 60 * 1000L;
+        };
+    }
+}
diff --git a/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java b/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
new file mode 100644
index 00000000..e359ce35
--- /dev/null
+++ b/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
@@ -0,0 +1,86 @@
+package org.pragmatica.aether.api;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.channel.group.ChannelGroup;
+import io.netty.channel.group.DefaultChannelGroup;
+import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
+import io.netty.handler.codec.http.websocketx.WebSocketFrame;
+import io.netty.util.concurrent.GlobalEventExecutor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * WebSocket handler for dashboard real-time updates.
+ *
+ * <p>Manages connected dashboard clients and broadcasts metrics updates.
+ */
+public class DashboardWebSocketHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
+
+    private static final Logger log = LoggerFactory.getLogger(DashboardWebSocketHandler.class);
+    private static final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
+
+    private final DashboardMetricsPublisher metricsPublisher;
+
+    public DashboardWebSocketHandler(DashboardMetricsPublisher metricsPublisher) {
+        this.metricsPublisher = metricsPublisher;
+    }
+
+    @Override
+    public void handlerAdded(ChannelHandlerContext ctx) {
+        channels.add(ctx.channel());
+        log.info("Dashboard client connected: {}", ctx.channel().remoteAddress());
+
+        // Send initial state snapshot
+        var initialState = metricsPublisher.buildInitialState();
+        ctx.writeAndFlush(new TextWebSocketFrame(initialState));
+    }
+
+    @Override
+    public void handlerRemoved(ChannelHandlerContext ctx) {
+        channels.remove(ctx.channel());
+        log.info("Dashboard client disconnected: {}", ctx.channel().remoteAddress());
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) {
+        if (frame instanceof TextWebSocketFrame textFrame) {
+            handleClientMessage(ctx, textFrame.text());
+        }
+    }
+
+    private void handleClientMessage(ChannelHandlerContext ctx, String message) {
+        log.debug("Received from dashboard client: {}", message);
+
+        // Parse client messages (subscribe, set threshold, get history)
+        if (message.contains("\"type\":\"SUBSCRIBE\"")) {
+            // Client subscribing to streams - currently all clients get all updates
+            log.debug("Client subscribed to streams");
+        } else if (message.contains("\"type\":\"SET_THRESHOLD\"")) {
+            metricsPublisher.handleSetThreshold(message);
+        } else if (message.contains("\"type\":\"GET_HISTORY\"")) {
+            var history = metricsPublisher.buildHistoryResponse(message);
+            ctx.writeAndFlush(new TextWebSocketFrame(history));
+        }
+    }
+
+    /**
+     * Broadcast a message to all connected dashboard clients.
+     */
+    public static void broadcast(String message) {
+        channels.writeAndFlush(new TextWebSocketFrame(message));
+    }
+
+    /**
+     * Get the number of connected dashboard clients.
+     */
+    public static int connectedClients() {
+        return channels.size();
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        log.error("WebSocket error for client {}", ctx.channel().remoteAddress(), cause);
+        ctx.close();
+    }
+}
diff --git a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
index 4ebda825..c9880bf5 100644
--- a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
+++ b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
@@ -20,6 +20,7 @@
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpServerCodec;
 import io.netty.handler.codec.http.HttpVersion;
+import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
 import io.netty.util.CharsetUtil;
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.node.AetherNode;
@@ -34,6 +35,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.function.Supplier;
 import java.util.regex.Pattern;
@@ -71,6 +74,8 @@ class ManagementServerImpl implements ManagementServer {
     private final Supplier<AetherNode> nodeSupplier;
     private final NioEventLoopGroup bossGroup;
     private final NioEventLoopGroup workerGroup;
+    private final AlertManager alertManager;
+    private final DashboardMetricsPublisher metricsPublisher;
     private Channel serverChannel;
 
     ManagementServerImpl(int port, Supplier<AetherNode> nodeSupplier) {
@@ -78,6 +83,8 @@ class ManagementServerImpl implements ManagementServer {
         this.nodeSupplier = nodeSupplier;
         this.bossGroup = new NioEventLoopGroup(1);
         this.workerGroup = new NioEventLoopGroup();
+        this.alertManager = new AlertManager();
+        this.metricsPublisher = new DashboardMetricsPublisher(nodeSupplier, alertManager);
     }
 
     @Override
@@ -92,14 +99,17 @@ protected void initChannel(SocketChannel ch) {
                             ChannelPipeline p = ch.pipeline();
                             p.addLast(new HttpServerCodec());
                             p.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
-                            p.addLast(new HttpRequestHandler(nodeSupplier));
+                            p.addLast(new WebSocketServerProtocolHandler("/ws/dashboard", null, true));
+                            p.addLast(new DashboardWebSocketHandler(metricsPublisher));
+                            p.addLast(new HttpRequestHandler(nodeSupplier, alertManager));
                         }
                     });
 
             bootstrap.bind(port).addListener(future -> {
                 if (future.isSuccess()) {
                     serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
-                    log.info("Management server started on port {}", port);
+                    metricsPublisher.start();
+                    log.info("Management server started on port {} (dashboard at /dashboard)", port);
                     promise.succeed(unit());
                 } else {
                     log.error("Failed to start management server on port {}", port, future.cause());
@@ -112,6 +122,7 @@ protected void initChannel(SocketChannel ch) {
     @Override
     public Promise<Unit> stop() {
         return Promise.promise(promise -> {
+            metricsPublisher.stop();
             if (serverChannel != null) {
                 serverChannel.close().addListener(f -> {
                     bossGroup.shutdownGracefully();
@@ -132,11 +143,16 @@ class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
 
     private static final Logger log = LoggerFactory.getLogger(HttpRequestHandler.class);
     private static final String CONTENT_TYPE_JSON = "application/json";
+    private static final String CONTENT_TYPE_HTML = "text/html; charset=UTF-8";
+    private static final String CONTENT_TYPE_CSS = "text/css; charset=UTF-8";
+    private static final String CONTENT_TYPE_JS = "application/javascript; charset=UTF-8";
 
     private final Supplier<AetherNode> nodeSupplier;
+    private final AlertManager alertManager;
 
-    HttpRequestHandler(Supplier<AetherNode> nodeSupplier) {
+    HttpRequestHandler(Supplier<AetherNode> nodeSupplier, AlertManager alertManager) {
         this.nodeSupplier = nodeSupplier;
+        this.alertManager = alertManager;
     }
 
     @Override
@@ -164,6 +180,16 @@ protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request)
     private void handleGet(ChannelHandlerContext ctx, String uri) {
         var node = nodeSupplier.get();
 
+        // Handle dashboard static files
+        if (uri.equals("/dashboard") || uri.equals("/dashboard/")) {
+            serveDashboardFile(ctx, "index.html", CONTENT_TYPE_HTML);
+            return;
+        }
+        if (uri.equals("/dashboard/style.css")) {
+            serveDashboardFile(ctx, "style.css", CONTENT_TYPE_CSS);
+            return;
+        }
+
         // Handle repository requests
         if (uri.startsWith("/repository/")) {
             handleRepositoryGet(ctx, node, uri);
@@ -174,7 +200,11 @@ private void handleGet(ChannelHandlerContext ctx, String uri) {
             case "/status" -> buildStatusResponse(node);
             case "/nodes" -> buildNodesResponse(node);
             case "/slices" -> buildSlicesResponse(node);
+            case "/slices/status" -> buildSlicesStatusResponse(node);
             case "/metrics" -> buildMetricsResponse(node);
+            case "/invocation-metrics" -> buildInvocationMetricsResponse(node);
+            case "/thresholds" -> alertManager.thresholdsAsJson();
+            case "/alerts" -> buildAlertsResponse();
             case "/health" -> "{\"status\":\"ok\"}";
             default -> null;
         };
@@ -186,6 +216,25 @@ private void handleGet(ChannelHandlerContext ctx, String uri) {
         }
     }
 
+    private void serveDashboardFile(ChannelHandlerContext ctx, String filename, String contentType) {
+        try (InputStream is = getClass().getResourceAsStream("/dashboard/" + filename)) {
+            if (is == null) {
+                sendError(ctx, HttpResponseStatus.NOT_FOUND);
+                return;
+            }
+            var content = new String(is.readAllBytes(), StandardCharsets.UTF_8);
+            var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
+            var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
+            response.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType);
+            response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, buf.readableBytes());
+            response.headers().set(HttpHeaderNames.CACHE_CONTROL, "no-cache");
+            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        } catch (Exception e) {
+            log.error("Error serving dashboard file: {}", filename, e);
+            sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
+        }
+    }
+
     private void handleRepositoryGet(ChannelHandlerContext ctx, AetherNode node, String uri) {
         node.mavenProtocolHandler().handleGet(uri)
             .onSuccess(response -> {
@@ -455,6 +504,39 @@ private String buildMetricsResponse(AetherNode node) {
         return sb.toString();
     }
 
+    private String buildSlicesStatusResponse(AetherNode node) {
+        var sb = new StringBuilder();
+        sb.append("{\"slices\":[");
+
+        var slices = node.sliceStore().loaded();
+        boolean first = true;
+        for (var slice : slices) {
+            if (!first) sb.append(",");
+            sb.append("{");
+            sb.append("\"artifact\":\"").append(slice.artifact().asString()).append("\",");
+            sb.append("\"state\":\"ACTIVE\","); // TODO: get actual state from kvstore
+            sb.append("\"instances\":[{");
+            sb.append("\"nodeId\":\"").append(node.self().id()).append("\",");
+            sb.append("\"state\":\"ACTIVE\",");
+            sb.append("\"health\":\"HEALTHY\"");
+            sb.append("}]");
+            sb.append("}");
+            first = false;
+        }
+
+        sb.append("]}");
+        return sb.toString();
+    }
+
+    private String buildInvocationMetricsResponse(AetherNode node) {
+        // TODO: expose invocationMetricsCollector via AetherNode interface
+        return "{\"snapshots\":[]}";
+    }
+
+    private String buildAlertsResponse() {
+        return "{\"active\":" + alertManager.activeAlertsAsJson() + ",\"history\":" + alertManager.alertHistoryAsJson() + "}";
+    }
+
     private void sendJson(ChannelHandlerContext ctx, String content) {
         var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
diff --git a/node/src/main/resources/dashboard/index.html b/node/src/main/resources/dashboard/index.html
new file mode 100644
index 00000000..1dcd8f39
--- /dev/null
+++ b/node/src/main/resources/dashboard/index.html
@@ -0,0 +1,425 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Aether Dashboard</title>
+    <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
+    <link rel="stylesheet" href="/dashboard/style.css">
+</head>
+<body x-data="dashboard()" x-init="init()">
+    <!-- Header -->
+    <header class="header">
+        <div class="header-left">
+            <h1>Aether Dashboard</h1>
+            <span class="connection-status" :class="{ connected: wsConnected, disconnected: !wsConnected }">
+                <span x-text="wsConnected ? 'Connected' : 'Disconnected'"></span>
+            </span>
+        </div>
+        <div class="header-right">
+            <span class="cluster-info">
+                <span class="node-count" x-text="nodes.length + ' node' + (nodes.length !== 1 ? 's' : '')"></span>
+                <span class="uptime" x-text="formatUptime(uptime)"></span>
+            </span>
+            <button class="nodes-toggle" @click="showNodes = !showNodes">
+                <span x-text="showNodes ? 'Hide Nodes' : 'Show Nodes'"></span>
+            </button>
+        </div>
+    </header>
+
+    <!-- Nodes Panel (collapsible) -->
+    <div class="nodes-panel" x-show="showNodes" x-transition>
+        <template x-for="node in nodes" :key="node.id">
+            <div class="node-badge" :class="{ leader: node.isLeader }">
+                <span class="node-id" x-text="node.id"></span>
+                <span x-show="node.isLeader" class="leader-badge">Leader</span>
+            </div>
+        </template>
+    </div>
+
+    <!-- Tab Navigation -->
+    <nav class="tabs">
+        <button class="tab" :class="{ active: tab === 'metrics' }" @click="tab = 'metrics'">Metrics</button>
+        <button class="tab" :class="{ active: tab === 'slices' }" @click="tab = 'slices'">Slices</button>
+        <button class="tab" :class="{ active: tab === 'history' }" @click="tab = 'history'; loadHistory()">History</button>
+        <button class="tab" :class="{ active: tab === 'alerts' }" @click="tab = 'alerts'">Alerts</button>
+    </nav>
+
+    <!-- Tab Content -->
+    <main class="content">
+        <!-- Metrics Tab -->
+        <div x-show="tab === 'metrics'" x-transition class="tab-content">
+            <div class="metrics-grid">
+                <!-- Per-node metrics cards -->
+                <template x-for="(nodeMetrics, nodeId) in metrics.load" :key="nodeId">
+                    <div class="metric-card">
+                        <h3 class="card-title" x-text="nodeId"></h3>
+                        <div class="metric-list">
+                            <template x-for="(value, name) in nodeMetrics" :key="name">
+                                <div class="metric-item">
+                                    <span class="metric-name" x-text="name"></span>
+                                    <span class="metric-value" :class="getMetricClass(name, value)"
+                                          x-text="formatMetricValue(name, value)"></span>
+                                </div>
+                            </template>
+                        </div>
+                    </div>
+                </template>
+            </div>
+
+            <!-- Invocation metrics -->
+            <div class="invocation-section" x-show="metrics.invocations && metrics.invocations.length > 0">
+                <h2>Invocation Metrics</h2>
+                <table class="invocation-table">
+                    <thead>
+                        <tr>
+                            <th>Method</th>
+                            <th>Count</th>
+                            <th>Success</th>
+                            <th>Avg Latency</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+                        <template x-for="inv in metrics.invocations" :key="inv.artifact + inv.method">
+                            <tr>
+                                <td x-text="inv.method"></td>
+                                <td x-text="inv.count"></td>
+                                <td x-text="inv.successCount"></td>
+                                <td x-text="formatNanos(inv.avgLatencyNs)"></td>
+                            </tr>
+                        </template>
+                    </tbody>
+                </table>
+            </div>
+        </div>
+
+        <!-- Slices Tab -->
+        <div x-show="tab === 'slices'" x-transition class="tab-content">
+            <div class="slices-grid">
+                <template x-for="slice in slices" :key="slice">
+                    <div class="slice-card">
+                        <h3 class="slice-artifact" x-text="slice"></h3>
+                        <div class="slice-state">
+                            <span class="state-label">State:</span>
+                            <span class="state-value">ACTIVE</span>
+                        </div>
+                    </div>
+                </template>
+                <div x-show="slices.length === 0" class="empty-state">
+                    No slices loaded
+                </div>
+            </div>
+        </div>
+
+        <!-- History Tab -->
+        <div x-show="tab === 'history'" x-transition class="tab-content">
+            <div class="history-controls">
+                <label>Time Range:</label>
+                <select x-model="historyRange" @change="loadHistory()">
+                    <option value="5m">5 minutes</option>
+                    <option value="15m">15 minutes</option>
+                    <option value="1h">1 hour</option>
+                    <option value="2h">2 hours</option>
+                </select>
+            </div>
+            <div class="chart-container">
+                <canvas id="historyChart"></canvas>
+            </div>
+        </div>
+
+        <!-- Alerts Tab -->
+        <div x-show="tab === 'alerts'" x-transition class="tab-content">
+            <!-- Threshold Configuration -->
+            <div class="thresholds-section">
+                <h2>Thresholds</h2>
+                <div class="threshold-grid">
+                    <template x-for="(threshold, metric) in thresholds" :key="metric">
+                        <div class="threshold-card">
+                            <h4 x-text="metric"></h4>
+                            <div class="threshold-inputs">
+                                <label>
+                                    Warning:
+                                    <input type="number" step="0.01" min="0" max="1"
+                                           :value="threshold.warning"
+                                           @change="updateThreshold(metric, $event.target.value, threshold.critical)">
+                                </label>
+                                <label>
+                                    Critical:
+                                    <input type="number" step="0.01" min="0" max="1"
+                                           :value="threshold.critical"
+                                           @change="updateThreshold(metric, threshold.warning, $event.target.value)">
+                                </label>
+                            </div>
+                        </div>
+                    </template>
+                </div>
+            </div>
+
+            <!-- Active Alerts -->
+            <div class="alerts-section">
+                <h2>Active Alerts</h2>
+                <div class="alerts-list">
+                    <template x-for="alert in activeAlerts" :key="alert.metric + alert.nodeId">
+                        <div class="alert-item" :class="alert.severity.toLowerCase()">
+                            <span class="alert-severity" x-text="alert.severity"></span>
+                            <span class="alert-metric" x-text="alert.metric"></span>
+                            <span class="alert-node" x-text="alert.nodeId"></span>
+                            <span class="alert-value" x-text="formatMetricValue(alert.metric, alert.value)"></span>
+                        </div>
+                    </template>
+                    <div x-show="activeAlerts.length === 0" class="empty-state">
+                        No active alerts
+                    </div>
+                </div>
+            </div>
+
+            <!-- Alert History -->
+            <div class="alert-history-section">
+                <h2>Alert History</h2>
+                <div class="alerts-list">
+                    <template x-for="entry in alertHistory" :key="entry.timestamp + entry.metric + entry.nodeId">
+                        <div class="alert-history-item" :class="entry.severity.toLowerCase()">
+                            <span class="alert-time" x-text="formatTime(entry.timestamp)"></span>
+                            <span class="alert-status" x-text="entry.status"></span>
+                            <span class="alert-metric" x-text="entry.metric"></span>
+                            <span class="alert-node" x-text="entry.nodeId"></span>
+                        </div>
+                    </template>
+                    <div x-show="alertHistory.length === 0" class="empty-state">
+                        No alert history
+                    </div>
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <script>
+        function dashboard() {
+            return {
+                // State
+                tab: 'metrics',
+                wsConnected: false,
+                showNodes: false,
+                nodes: [],
+                slices: [],
+                metrics: { load: {}, invocations: [] },
+                thresholds: {},
+                activeAlerts: [],
+                alertHistory: [],
+                historyRange: '1h',
+                historyData: {},
+                uptime: 0,
+                startTime: Date.now(),
+                ws: null,
+                reconnectTimer: null,
+                historyChart: null,
+
+                init() {
+                    this.connect();
+                    setInterval(() => {
+                        this.uptime = Math.floor((Date.now() - this.startTime) / 1000);
+                    }, 1000);
+                },
+
+                connect() {
+                    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+                    const wsUrl = `${protocol}//${window.location.host}/ws/dashboard`;
+
+                    this.ws = new WebSocket(wsUrl);
+
+                    this.ws.onopen = () => {
+                        this.wsConnected = true;
+                        if (this.reconnectTimer) {
+                            clearTimeout(this.reconnectTimer);
+                            this.reconnectTimer = null;
+                        }
+                    };
+
+                    this.ws.onclose = () => {
+                        this.wsConnected = false;
+                        this.scheduleReconnect();
+                    };
+
+                    this.ws.onerror = () => {
+                        this.wsConnected = false;
+                    };
+
+                    this.ws.onmessage = (event) => {
+                        this.handleMessage(JSON.parse(event.data));
+                    };
+                },
+
+                scheduleReconnect() {
+                    if (!this.reconnectTimer) {
+                        this.reconnectTimer = setTimeout(() => {
+                            this.reconnectTimer = null;
+                            this.connect();
+                        }, 3000);
+                    }
+                },
+
+                handleMessage(msg) {
+                    switch (msg.type) {
+                        case 'INITIAL_STATE':
+                            this.nodes = msg.data.nodes || [];
+                            this.slices = msg.data.slices || [];
+                            this.thresholds = msg.data.thresholds || {};
+                            this.metrics = msg.data.metrics || { load: {}, invocations: [] };
+                            break;
+                        case 'METRICS_UPDATE':
+                            this.metrics = msg.data || { load: {}, invocations: [] };
+                            break;
+                        case 'ALERT':
+                            this.handleAlert(msg.data);
+                            break;
+                        case 'HISTORY':
+                            this.historyData = msg.nodes || {};
+                            this.updateHistoryChart();
+                            break;
+                    }
+                },
+
+                handleAlert(alert) {
+                    // Update active alerts
+                    const key = alert.metric + ':' + alert.nodeId;
+                    const existing = this.activeAlerts.findIndex(a =>
+                        a.metric === alert.metric && a.nodeId === alert.nodeId);
+
+                    if (existing >= 0) {
+                        this.activeAlerts[existing] = alert;
+                    } else {
+                        this.activeAlerts.push(alert);
+                    }
+                },
+
+                loadHistory() {
+                    if (this.ws && this.wsConnected) {
+                        this.ws.send(JSON.stringify({
+                            type: 'GET_HISTORY',
+                            timeRange: this.historyRange
+                        }));
+                    }
+                },
+
+                updateThreshold(metric, warning, critical) {
+                    if (this.ws && this.wsConnected) {
+                        this.ws.send(JSON.stringify({
+                            type: 'SET_THRESHOLD',
+                            metric: metric,
+                            warning: parseFloat(warning),
+                            critical: parseFloat(critical)
+                        }));
+                        this.thresholds[metric] = {
+                            warning: parseFloat(warning),
+                            critical: parseFloat(critical)
+                        };
+                    }
+                },
+
+                updateHistoryChart() {
+                    const ctx = document.getElementById('historyChart');
+                    if (!ctx) return;
+
+                    const datasets = [];
+                    const colors = ['#4ade80', '#60a5fa', '#f472b6', '#facc15', '#a78bfa'];
+                    let colorIndex = 0;
+
+                    for (const [nodeId, snapshots] of Object.entries(this.historyData)) {
+                        const cpuData = snapshots.map(s => ({
+                            x: s.timestamp,
+                            y: s.metrics['cpu.usage'] || 0
+                        }));
+
+                        datasets.push({
+                            label: `${nodeId} CPU`,
+                            data: cpuData,
+                            borderColor: colors[colorIndex % colors.length],
+                            fill: false,
+                            tension: 0.1
+                        });
+                        colorIndex++;
+                    }
+
+                    if (this.historyChart) {
+                        this.historyChart.destroy();
+                    }
+
+                    this.historyChart = new Chart(ctx, {
+                        type: 'line',
+                        data: { datasets },
+                        options: {
+                            responsive: true,
+                            maintainAspectRatio: false,
+                            scales: {
+                                x: {
+                                    type: 'linear',
+                                    title: { display: true, text: 'Time' },
+                                    ticks: {
+                                        callback: (value) => new Date(value).toLocaleTimeString()
+                                    }
+                                },
+                                y: {
+                                    min: 0,
+                                    max: 1,
+                                    title: { display: true, text: 'CPU Usage' }
+                                }
+                            },
+                            plugins: {
+                                legend: { position: 'top' }
+                            }
+                        }
+                    });
+                },
+
+                // Formatting helpers
+                formatUptime(seconds) {
+                    const h = Math.floor(seconds / 3600);
+                    const m = Math.floor((seconds % 3600) / 60);
+                    const s = seconds % 60;
+                    return `${h}h ${m}m ${s}s`;
+                },
+
+                formatMetricValue(name, value) {
+                    if (name.includes('usage') || name.includes('percent')) {
+                        return (value * 100).toFixed(1) + '%';
+                    }
+                    if (name.includes('bytes') || name.includes('memory')) {
+                        return this.formatBytes(value);
+                    }
+                    if (typeof value === 'number') {
+                        return value.toFixed(2);
+                    }
+                    return value;
+                },
+
+                formatBytes(bytes) {
+                    if (bytes < 1024) return bytes + ' B';
+                    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
+                    if (bytes < 1024 * 1024 * 1024) return (bytes / (1024 * 1024)).toFixed(1) + ' MB';
+                    return (bytes / (1024 * 1024 * 1024)).toFixed(1) + ' GB';
+                },
+
+                formatNanos(ns) {
+                    if (ns < 1000) return ns + ' ns';
+                    if (ns < 1000000) return (ns / 1000).toFixed(1) + ' us';
+                    if (ns < 1000000000) return (ns / 1000000).toFixed(1) + ' ms';
+                    return (ns / 1000000000).toFixed(2) + ' s';
+                },
+
+                formatTime(timestamp) {
+                    return new Date(timestamp).toLocaleTimeString();
+                },
+
+                getMetricClass(name, value) {
+                    const threshold = this.thresholds[name];
+                    if (!threshold) return '';
+                    if (value >= threshold.critical) return 'critical';
+                    if (value >= threshold.warning) return 'warning';
+                    return 'normal';
+                }
+            };
+        }
+    </script>
+</body>
+</html>
diff --git a/node/src/main/resources/dashboard/style.css b/node/src/main/resources/dashboard/style.css
new file mode 100644
index 00000000..0bd25d0d
--- /dev/null
+++ b/node/src/main/resources/dashboard/style.css
@@ -0,0 +1,512 @@
+/* Aether Dashboard - Dark Theme */
+
+:root {
+    --bg-primary: #0f172a;
+    --bg-secondary: #1e293b;
+    --bg-tertiary: #334155;
+    --text-primary: #f1f5f9;
+    --text-secondary: #94a3b8;
+    --text-muted: #64748b;
+    --accent: #3b82f6;
+    --accent-hover: #2563eb;
+    --success: #22c55e;
+    --warning: #f59e0b;
+    --critical: #ef4444;
+    --border: #475569;
+    --shadow: rgba(0, 0, 0, 0.3);
+}
+
+* {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+    background-color: var(--bg-primary);
+    color: var(--text-primary);
+    line-height: 1.6;
+    min-height: 100vh;
+}
+
+/* Header */
+.header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1rem 2rem;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+    position: sticky;
+    top: 0;
+    z-index: 100;
+}
+
+.header-left {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+.header h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+}
+
+.connection-status {
+    padding: 0.25rem 0.75rem;
+    border-radius: 9999px;
+    font-size: 0.75rem;
+    font-weight: 500;
+}
+
+.connection-status.connected {
+    background-color: rgba(34, 197, 94, 0.2);
+    color: var(--success);
+}
+
+.connection-status.disconnected {
+    background-color: rgba(239, 68, 68, 0.2);
+    color: var(--critical);
+}
+
+.header-right {
+    display: flex;
+    align-items: center;
+    gap: 1.5rem;
+}
+
+.cluster-info {
+    display: flex;
+    gap: 1rem;
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.nodes-toggle {
+    padding: 0.5rem 1rem;
+    background-color: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    color: var(--text-primary);
+    cursor: pointer;
+    font-size: 0.875rem;
+    transition: background-color 0.15s;
+}
+
+.nodes-toggle:hover {
+    background-color: var(--accent);
+}
+
+/* Nodes Panel */
+.nodes-panel {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+    padding: 1rem 2rem;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+}
+
+.node-badge {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.375rem 0.75rem;
+    background-color: var(--bg-tertiary);
+    border-radius: 0.375rem;
+    font-size: 0.875rem;
+}
+
+.node-badge.leader {
+    background-color: rgba(59, 130, 246, 0.2);
+    border: 1px solid var(--accent);
+}
+
+.leader-badge {
+    padding: 0.125rem 0.375rem;
+    background-color: var(--accent);
+    border-radius: 0.25rem;
+    font-size: 0.625rem;
+    font-weight: 600;
+    text-transform: uppercase;
+}
+
+/* Tabs */
+.tabs {
+    display: flex;
+    gap: 0;
+    padding: 0 2rem;
+    background-color: var(--bg-secondary);
+    border-bottom: 1px solid var(--border);
+}
+
+.tab {
+    padding: 1rem 1.5rem;
+    background: none;
+    border: none;
+    border-bottom: 2px solid transparent;
+    color: var(--text-secondary);
+    cursor: pointer;
+    font-size: 0.875rem;
+    font-weight: 500;
+    transition: all 0.15s;
+}
+
+.tab:hover {
+    color: var(--text-primary);
+    background-color: var(--bg-tertiary);
+}
+
+.tab.active {
+    color: var(--accent);
+    border-bottom-color: var(--accent);
+}
+
+/* Content */
+.content {
+    padding: 2rem;
+    max-width: 1600px;
+    margin: 0 auto;
+}
+
+.tab-content {
+    animation: fadeIn 0.2s ease-out;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(4px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* Metrics Grid */
+.metrics-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1.5rem;
+}
+
+.metric-card {
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1.25rem;
+}
+
+.card-title {
+    font-size: 1rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+    margin-bottom: 1rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 1px solid var(--border);
+}
+
+.metric-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.metric-item {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 0.5rem 0;
+}
+
+.metric-name {
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.metric-value {
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    font-size: 0.875rem;
+    font-weight: 500;
+}
+
+.metric-value.normal {
+    color: var(--success);
+}
+
+.metric-value.warning {
+    color: var(--warning);
+}
+
+.metric-value.critical {
+    color: var(--critical);
+}
+
+/* Invocation Section */
+.invocation-section {
+    margin-top: 2rem;
+}
+
+.invocation-section h2 {
+    font-size: 1.25rem;
+    margin-bottom: 1rem;
+}
+
+.invocation-table {
+    width: 100%;
+    border-collapse: collapse;
+    background-color: var(--bg-secondary);
+    border-radius: 0.5rem;
+    overflow: hidden;
+}
+
+.invocation-table th,
+.invocation-table td {
+    padding: 0.75rem 1rem;
+    text-align: left;
+    border-bottom: 1px solid var(--border);
+}
+
+.invocation-table th {
+    background-color: var(--bg-tertiary);
+    color: var(--text-secondary);
+    font-size: 0.75rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+}
+
+.invocation-table td {
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    font-size: 0.875rem;
+}
+
+/* Slices Grid */
+.slices-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(350px, 1fr));
+    gap: 1.5rem;
+}
+
+.slice-card {
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1.25rem;
+}
+
+.slice-artifact {
+    font-size: 0.875rem;
+    font-family: 'SF Mono', 'Fira Code', monospace;
+    color: var(--accent);
+    margin-bottom: 1rem;
+    word-break: break-all;
+}
+
+.slice-state {
+    display: flex;
+    gap: 0.5rem;
+    font-size: 0.875rem;
+}
+
+.state-label {
+    color: var(--text-secondary);
+}
+
+.state-value {
+    color: var(--success);
+    font-weight: 500;
+}
+
+/* History Tab */
+.history-controls {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 1.5rem;
+}
+
+.history-controls label {
+    color: var(--text-secondary);
+    font-size: 0.875rem;
+}
+
+.history-controls select {
+    padding: 0.5rem 1rem;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    color: var(--text-primary);
+    font-size: 0.875rem;
+}
+
+.chart-container {
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1.5rem;
+    height: 400px;
+}
+
+/* Alerts Tab */
+.thresholds-section,
+.alerts-section,
+.alert-history-section {
+    margin-bottom: 2rem;
+}
+
+.thresholds-section h2,
+.alerts-section h2,
+.alert-history-section h2 {
+    font-size: 1.25rem;
+    margin-bottom: 1rem;
+}
+
+.threshold-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
+    gap: 1rem;
+}
+
+.threshold-card {
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.5rem;
+    padding: 1rem;
+}
+
+.threshold-card h4 {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    margin-bottom: 0.75rem;
+}
+
+.threshold-inputs {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.threshold-inputs label {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    font-size: 0.75rem;
+    color: var(--text-muted);
+}
+
+.threshold-inputs input {
+    width: 80px;
+    padding: 0.375rem 0.5rem;
+    background-color: var(--bg-tertiary);
+    border: 1px solid var(--border);
+    border-radius: 0.25rem;
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    text-align: right;
+}
+
+.alerts-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.alert-item,
+.alert-history-item {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    padding: 0.75rem 1rem;
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border);
+    border-radius: 0.375rem;
+    font-size: 0.875rem;
+}
+
+.alert-item.warning,
+.alert-history-item.warning {
+    border-left: 3px solid var(--warning);
+}
+
+.alert-item.critical,
+.alert-history-item.critical {
+    border-left: 3px solid var(--critical);
+}
+
+.alert-severity {
+    padding: 0.125rem 0.5rem;
+    border-radius: 0.25rem;
+    font-size: 0.75rem;
+    font-weight: 600;
+    text-transform: uppercase;
+}
+
+.warning .alert-severity {
+    background-color: rgba(245, 158, 11, 0.2);
+    color: var(--warning);
+}
+
+.critical .alert-severity {
+    background-color: rgba(239, 68, 68, 0.2);
+    color: var(--critical);
+}
+
+.alert-metric,
+.alert-node {
+    color: var(--text-secondary);
+}
+
+.alert-value {
+    margin-left: auto;
+    font-family: 'SF Mono', 'Fira Code', monospace;
+}
+
+.alert-time {
+    color: var(--text-muted);
+    font-size: 0.75rem;
+}
+
+.alert-status {
+    font-weight: 500;
+}
+
+/* Empty State */
+.empty-state {
+    padding: 3rem;
+    text-align: center;
+    color: var(--text-muted);
+    background-color: var(--bg-secondary);
+    border: 1px dashed var(--border);
+    border-radius: 0.5rem;
+}
+
+/* Responsive */
+@media (max-width: 768px) {
+    .header {
+        flex-direction: column;
+        gap: 1rem;
+    }
+
+    .header-right {
+        width: 100%;
+        justify-content: space-between;
+    }
+
+    .content {
+        padding: 1rem;
+    }
+
+    .metrics-grid,
+    .slices-grid,
+    .threshold-grid {
+        grid-template-columns: 1fr;
+    }
+
+    .tabs {
+        padding: 0 1rem;
+        overflow-x: auto;
+    }
+
+    .tab {
+        padding: 0.75rem 1rem;
+        white-space: nowrap;
+    }
+}

From 659d140b7aa8f99feef10b15ffdf17725fd874db Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 07:20:43 +0100
Subject: [PATCH 04/26] refactor: simplify Forge dashboard - remove D3
 topology, compact design

---
 forge/src/main/resources/static/dashboard.js | 690 +++-----------
 forge/src/main/resources/static/index.html   | 203 ++--
 forge/src/main/resources/static/style.css    | 941 ++++++-------------
 pom.xml                                      |   4 +-
 4 files changed, 494 insertions(+), 1344 deletions(-)

diff --git a/forge/src/main/resources/static/dashboard.js b/forge/src/main/resources/static/dashboard.js
index 7bbbbb4b..63dff591 100644
--- a/forge/src/main/resources/static/dashboard.js
+++ b/forge/src/main/resources/static/dashboard.js
@@ -1,4 +1,4 @@
-// Aether Resilience Demo - Dashboard Controller
+// Aether Forge - Dashboard Controller (Simplified)
 
 const API_BASE = '';
 const REFRESH_INTERVAL = 500;
@@ -10,321 +10,86 @@ let successChart = null;
 let throughputChart = null;
 let successHistory = [];
 let throughputHistory = [];
-const MAX_HISTORY = 60; // 30 seconds at 500ms intervals
-let showNodeMetrics = false;  // Toggle for per-node JVM metrics
-let nodeMetricsData = [];     // Cached node metrics
-let entryPointMetrics = [];   // Cached entry point metrics
-
-// D3 Topology
-let svg, simulation;
-let width, height;
-let previousNodeIds = [];
-let simulationNodes = [];  // Persistent node data for D3
-let simulationLinks = [];  // Persistent link data for D3
-
-// Initialize on load
+const MAX_HISTORY = 60;
+let nodeMetricsData = [];
+let entryPointMetrics = [];
+
+// Initialize
 document.addEventListener('DOMContentLoaded', () => {
-    initTopology();
     initCharts();
     initControls();
     startPolling();
 });
 
-// ===============================
-// Topology Visualization (D3.js)
-// ===============================
-
-function initTopology() {
-    const container = document.getElementById('cluster-viz');
-    width = container.clientWidth;
-    height = container.clientHeight || 300;
-
-    svg = d3.select('#topology-svg')
-        .attr('width', width)
-        .attr('height', height);
-
-    // Define arrow marker for links
-    svg.append('defs').append('marker')
-        .attr('id', 'arrowhead')
-        .attr('viewBox', '-0 -5 10 10')
-        .attr('refX', 25)
-        .attr('refY', 0)
-        .attr('orient', 'auto')
-        .attr('markerWidth', 6)
-        .attr('markerHeight', 6)
-        .append('path')
-        .attr('d', 'M0,-5L10,0L0,5')
-        .attr('fill', '#2a2a3a');
-
-    simulation = d3.forceSimulation()
-        .force('link', d3.forceLink().id(d => d.id).distance(100))
-        .force('charge', d3.forceManyBody().strength(-300))
-        .force('center', d3.forceCenter(width / 2, height / 2))
-        .force('collision', d3.forceCollide().radius(40));
-
-    // Set tick handler once (not on every poll)
-    simulation.on('tick', () => {
-        svg.selectAll('.link')
-            .attr('x1', d => d.source.x)
-            .attr('y1', d => d.source.y)
-            .attr('x2', d => d.target.x)
-            .attr('y2', d => d.target.y);
-
-        svg.selectAll('.node')
-            .attr('transform', d => `translate(${d.x},${d.y})`);
-    });
-}
-
-function updateTopology(clusterData) {
-    if (!clusterData || !clusterData.nodes) return;
-
-    const currentNodeIds = clusterData.nodes.map(n => n.id).sort();
-    const currentNodeIdSet = new Set(currentNodeIds);
-    const previousNodeIdSet = new Set(previousNodeIds);
-
-    // Check if topology changed
-    const topologyChanged = currentNodeIds.join(',') !== previousNodeIds.join(',');
-
-    if (topologyChanged) {
-        // Remove nodes that no longer exist
-        simulationNodes = simulationNodes.filter(n => currentNodeIdSet.has(n.id));
-
-        // Add new nodes with initial positions
-        clusterData.nodes.forEach(n => {
-            if (!previousNodeIdSet.has(n.id)) {
-                simulationNodes.push({
-                    id: n.id,
-                    isLeader: n.isLeader,
-                    state: n.state,
-                    x: width / 2 + (Math.random() - 0.5) * 100,
-                    y: height / 2 + (Math.random() - 0.5) * 100
-                });
-            }
-        });
-
-        // Rebuild links (full mesh)
-        simulationLinks = [];
-        for (let i = 0; i < simulationNodes.length; i++) {
-            for (let j = i + 1; j < simulationNodes.length; j++) {
-                simulationLinks.push({
-                    source: simulationNodes[i],
-                    target: simulationNodes[j]
-                });
-            }
-        }
-
-        previousNodeIds = currentNodeIds;
-    }
-
-    // Update leader status on existing nodes
-    clusterData.nodes.forEach(n => {
-        const existing = simulationNodes.find(sn => sn.id === n.id);
-        if (existing) {
-            existing.isLeader = n.isLeader;
-            existing.state = n.state;
-        }
-    });
-
-    // Update links in SVG
-    const link = svg.selectAll('.link')
-        .data(simulationLinks, d => `${d.source.id}-${d.target.id}`);
-
-    link.exit().remove();
-
-    link.enter()
-        .append('line')
-        .attr('class', 'link')
-        .attr('x1', d => d.source.x)
-        .attr('y1', d => d.source.y)
-        .attr('x2', d => d.target.x)
-        .attr('y2', d => d.target.y);
-
-    // Update nodes in SVG
-    const node = svg.selectAll('.node')
-        .data(simulationNodes, d => d.id);
-
-    node.exit()
-        .transition()
-        .duration(300)
-        .style('opacity', 0)
-        .remove();
-
-    const nodeEnter = node.enter()
-        .append('g')
-        .attr('class', 'node')
-        .attr('transform', d => `translate(${d.x},${d.y})`)
-        .call(d3.drag()
-            .on('start', dragStarted)
-            .on('drag', dragged)
-            .on('end', dragEnded));
-
-    nodeEnter.append('circle')
-        .attr('r', 0)
-        .transition()
-        .duration(500)
-        .attr('r', 25);
-
-    nodeEnter.append('text')
-        .attr('dy', 4)
-        .text(d => d.id.replace('node-', 'N'));
-
-    // Update node styles
-    svg.selectAll('.node')
-        .classed('leader', d => d.isLeader)
-        .classed('healthy', d => !d.isLeader);
-
-    // Update simulation if topology changed
-    if (topologyChanged) {
-        simulation.nodes(simulationNodes);
-        simulation.force('link').links(simulationLinks);
-        simulation.alpha(0.5).restart();
-    }
-}
-
-function dragStarted(event, d) {
-    if (!event.active) simulation.alphaTarget(0.3).restart();
-    d.fx = d.x;
-    d.fy = d.y;
-}
-
-function dragged(event, d) {
-    d.fx = event.x;
-    d.fy = event.y;
-}
-
-function dragEnded(event, d) {
-    if (!event.active) simulation.alphaTarget(0);
-    d.fx = null;
-    d.fy = null;
-}
-
 // ===============================
 // Charts (Chart.js)
 // ===============================
 
 function initCharts() {
-    // Success Rate Chart
-    const successCtx = document.getElementById('success-chart').getContext('2d');
-    successChart = new Chart(successCtx, {
+    const chartOptions = {
+        responsive: true,
+        maintainAspectRatio: false,
+        plugins: { legend: { display: false } },
+        scales: {
+            x: { display: false },
+            y: {
+                min: 0,
+                grid: { color: '#252530' },
+                ticks: { color: '#888898', font: { size: 9 } }
+            }
+        },
+        animation: { duration: 0 }
+    };
+
+    successChart = new Chart(document.getElementById('success-chart'), {
         type: 'line',
         data: {
             labels: [],
             datasets: [{
-                label: 'Success Rate',
                 data: [],
                 borderColor: '#22c55e',
                 backgroundColor: 'rgba(34, 197, 94, 0.1)',
                 fill: true,
-                tension: 0.4,
-                pointRadius: 0
+                tension: 0.3,
+                pointRadius: 0,
+                borderWidth: 1.5
             }]
         },
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: { display: false }
-            },
-            scales: {
-                x: {
-                    display: false
-                },
-                y: {
-                    min: 0,
-                    max: 100,
-                    grid: {
-                        color: '#2a2a3a'
-                    },
-                    ticks: {
-                        color: '#a0a0b0',
-                        callback: v => v + '%'
-                    }
-                }
-            },
-            animation: {
-                duration: 0
-            }
-        }
+        options: { ...chartOptions, scales: { ...chartOptions.scales, y: { ...chartOptions.scales.y, max: 100, ticks: { ...chartOptions.scales.y.ticks, callback: v => v + '%' } } } }
     });
 
-    // Throughput Chart
-    const throughputCtx = document.getElementById('throughput-chart').getContext('2d');
-    throughputChart = new Chart(throughputCtx, {
+    throughputChart = new Chart(document.getElementById('throughput-chart'), {
         type: 'line',
         data: {
             labels: [],
             datasets: [{
-                label: 'Throughput',
                 data: [],
                 borderColor: '#06b6d4',
                 backgroundColor: 'rgba(6, 182, 212, 0.1)',
                 fill: true,
-                tension: 0.4,
-                pointRadius: 0
+                tension: 0.3,
+                pointRadius: 0,
+                borderWidth: 1.5
             }]
         },
-        options: {
-            responsive: true,
-            maintainAspectRatio: false,
-            plugins: {
-                legend: { display: false }
-            },
-            scales: {
-                x: {
-                    display: false
-                },
-                y: {
-                    min: 0,
-                    grid: {
-                        color: '#2a2a3a'
-                    },
-                    ticks: {
-                        color: '#a0a0b0'
-                    }
-                }
-            },
-            animation: {
-                duration: 0
-            }
-        }
+        options: chartOptions
     });
 }
 
 function updateCharts(metrics) {
-    const now = new Date().toLocaleTimeString();
-
-    // Update success history
     successHistory.push(metrics.successRate);
-    if (successHistory.length > MAX_HISTORY) {
-        successHistory.shift();
-    }
+    if (successHistory.length > MAX_HISTORY) successHistory.shift();
 
-    // Update throughput history
     throughputHistory.push(metrics.requestsPerSecond);
-    if (throughputHistory.length > MAX_HISTORY) {
-        throughputHistory.shift();
-    }
+    if (throughputHistory.length > MAX_HISTORY) throughputHistory.shift();
 
-    // Update success chart
     successChart.data.labels = successHistory.map(() => '');
     successChart.data.datasets[0].data = successHistory;
 
-    // Color based on success rate
-    const currentRate = metrics.successRate;
-    if (currentRate >= 99) {
-        successChart.data.datasets[0].borderColor = '#22c55e';
-        successChart.data.datasets[0].backgroundColor = 'rgba(34, 197, 94, 0.1)';
-    } else if (currentRate >= 95) {
-        successChart.data.datasets[0].borderColor = '#f59e0b';
-        successChart.data.datasets[0].backgroundColor = 'rgba(245, 158, 11, 0.1)';
-    } else {
-        successChart.data.datasets[0].borderColor = '#ef4444';
-        successChart.data.datasets[0].backgroundColor = 'rgba(239, 68, 68, 0.1)';
-    }
-
+    const rate = metrics.successRate;
+    successChart.data.datasets[0].borderColor = rate >= 99 ? '#22c55e' : rate >= 95 ? '#f59e0b' : '#ef4444';
     successChart.update('none');
 
-    // Update throughput chart
     throughputChart.data.labels = throughputHistory.map(() => '');
     throughputChart.data.datasets[0].data = throughputHistory;
     throughputChart.update('none');
@@ -335,108 +100,62 @@ function updateCharts(metrics) {
 // ===============================
 
 function initControls() {
-    // Kill Node button
-    document.getElementById('btn-kill-node').addEventListener('click', () => {
-        showNodeModal(false);
-    });
-
-    // Kill Leader button
+    document.getElementById('btn-kill-node').addEventListener('click', () => showNodeModal(false));
     document.getElementById('btn-kill-leader').addEventListener('click', async () => {
         const status = await fetchStatus();
-        if (status && status.cluster.leaderId !== 'none') {
-            await killNode(status.cluster.leaderId);
-        }
-    });
-
-    // Rolling Restart button
-    document.getElementById('btn-rolling-restart').addEventListener('click', async () => {
-        await apiPost('/api/rolling-restart');
-    });
-
-    // Add Node button
-    document.getElementById('btn-add-node').addEventListener('click', async () => {
-        await apiPost('/api/add-node');
+        if (status?.cluster.leaderId !== 'none') await killNode(status.cluster.leaderId);
     });
+    document.getElementById('btn-rolling-restart').addEventListener('click', () => apiPost('/api/rolling-restart'));
+    document.getElementById('btn-add-node').addEventListener('click', () => apiPost('/api/add-node'));
 
-    // Load control buttons
     document.getElementById('btn-load-1k').addEventListener('click', () => setLoad(1000));
     document.getElementById('btn-load-5k').addEventListener('click', () => setLoad(5000));
     document.getElementById('btn-load-10k').addEventListener('click', () => setLoad(10000));
     document.getElementById('btn-load-25k').addEventListener('click', () => setLoad(25000));
     document.getElementById('btn-load-50k').addEventListener('click', () => setLoad(50000));
     document.getElementById('btn-load-100k').addEventListener('click', () => setLoad(100000));
-    document.getElementById('btn-ramp').addEventListener('click', () => rampToNextStep());
+    document.getElementById('btn-ramp').addEventListener('click', rampToNextStep);
 
-    // Load slider
     const slider = document.getElementById('load-slider');
-    const loadValue = document.getElementById('load-value');
-    slider.addEventListener('input', () => {
-        loadValue.textContent = `${slider.value} req/sec`;
-    });
-    slider.addEventListener('change', () => {
-        setLoad(parseInt(slider.value));
-    });
+    slider.addEventListener('input', () => document.getElementById('load-value').textContent = formatLoadRate(slider.value));
+    slider.addEventListener('change', () => setLoad(parseInt(slider.value)));
 
-    // Reset button
     document.getElementById('btn-reset').addEventListener('click', async () => {
         await apiPost('/api/reset-metrics');
         successHistory = [];
         throughputHistory = [];
     });
 
-    // Load generator toggle
-    document.getElementById('load-generator-toggle').addEventListener('change', async (e) => {
-        await apiPost('/api/simulator/config/enabled', { enabled: e.target.checked });
-    });
+    document.getElementById('load-generator-toggle').addEventListener('change', e =>
+        apiPost('/api/simulator/config/enabled', { enabled: e.target.checked }));
 
-    // Rate multiplier
-    document.getElementById('btn-apply-multiplier').addEventListener('click', async () => {
+    document.getElementById('btn-apply-multiplier').addEventListener('click', () => {
         const multiplier = parseFloat(document.getElementById('rate-multiplier').value);
-        if (!isNaN(multiplier) && multiplier > 0) {
-            await apiPost('/api/simulator/config/multiplier', { multiplier: multiplier });
-        }
+        if (!isNaN(multiplier) && multiplier > 0) apiPost('/api/simulator/config/multiplier', { multiplier });
     });
 
-    // Modal cancel
     document.getElementById('modal-cancel').addEventListener('click', hideNodeModal);
-
-    // Toggle node metrics display
-    document.getElementById('btn-toggle-metrics').addEventListener('click', () => {
-        showNodeMetrics = !showNodeMetrics;
-        const btn = document.getElementById('btn-toggle-metrics');
-        btn.textContent = showNodeMetrics ? 'Hide JVM' : 'Show JVM';
-        updateNodeMetricsDisplay();
-    });
 }
 
 function showNodeModal(includeLeader) {
-    const modal = document.getElementById('node-modal');
     const nodeList = document.getElementById('node-list');
     nodeList.innerHTML = '';
-
     nodes.forEach(node => {
         if (!includeLeader && node.isLeader) return;
-
         const btn = document.createElement('button');
         btn.className = `btn ${node.isLeader ? 'btn-warning' : 'btn-danger'}`;
         btn.textContent = `${node.id}${node.isLeader ? ' (Leader)' : ''}`;
-        btn.addEventListener('click', async () => {
-            hideNodeModal();
-            await killNode(node.id);
-        });
+        btn.addEventListener('click', async () => { hideNodeModal(); await killNode(node.id); });
         nodeList.appendChild(btn);
     });
-
-    modal.classList.remove('hidden');
+    document.getElementById('node-modal').classList.remove('hidden');
 }
 
 function hideNodeModal() {
     document.getElementById('node-modal').classList.add('hidden');
 }
 
-async function killNode(nodeId) {
-    await apiPost(`/api/kill/${nodeId}`);
-}
+async function killNode(nodeId) { await apiPost(`/api/kill/${nodeId}`); }
 
 async function setLoad(rate) {
     await apiPost(`/api/load/set/${rate}`);
@@ -445,30 +164,16 @@ async function setLoad(rate) {
 }
 
 function formatLoadRate(rate) {
-    if (rate >= 1000) {
-        return `${(rate / 1000).toFixed(rate % 1000 === 0 ? 0 : 1)}K req/sec`;
-    }
-    return `${rate} req/sec`;
+    return rate >= 1000 ? `${(rate / 1000).toFixed(rate % 1000 === 0 ? 0 : 1)}K` : `${rate}`;
 }
 
-// Load step levels for ramp function
 const LOAD_STEPS = [1000, 5000, 10000, 25000, 50000, 100000];
 
 async function rampToNextStep() {
     const status = await fetchStatus();
     if (!status) return;
-
-    const currentRate = status.load.currentRate;
-    // Find next step above current rate
-    const nextStep = LOAD_STEPS.find(step => step > currentRate) || LOAD_STEPS[LOAD_STEPS.length - 1];
-
-    if (nextStep > currentRate) {
-        await apiPost('/api/load/ramp', { targetRate: nextStep, durationMs: 10000 });
-    }
-}
-
-async function rampLoad(targetRate, durationMs) {
-    await apiPost('/api/load/ramp', { targetRate, durationMs });
+    const nextStep = LOAD_STEPS.find(step => step > status.load.currentRate) || LOAD_STEPS[LOAD_STEPS.length - 1];
+    if (nextStep > status.load.currentRate) await apiPost('/api/load/ramp', { targetRate: nextStep, durationMs: 10000 });
 }
 
 // ===============================
@@ -478,23 +183,15 @@ async function rampLoad(targetRate, durationMs) {
 async function fetchStatus() {
     try {
         const response = await fetch(`${API_BASE}/api/status`);
-        if (!response.ok) throw new Error('Status fetch failed');
-        return await response.json();
-    } catch (e) {
-        console.error('Error fetching status:', e);
-        return null;
-    }
+        return response.ok ? await response.json() : null;
+    } catch { return null; }
 }
 
 async function fetchEvents() {
     try {
         const response = await fetch(`${API_BASE}/api/events`);
-        if (!response.ok) throw new Error('Events fetch failed');
-        return await response.json();
-    } catch (e) {
-        console.error('Error fetching events:', e);
-        return [];
-    }
+        return response.ok ? await response.json() : [];
+    } catch { return []; }
 }
 
 async function apiPost(endpoint, body = {}) {
@@ -505,131 +202,63 @@ async function apiPost(endpoint, body = {}) {
             body: JSON.stringify(body)
         });
         return await response.json();
-    } catch (e) {
-        console.error('API error:', e);
-        return null;
-    }
+    } catch { return null; }
 }
 
 async function fetchNodeMetrics() {
     try {
         const response = await fetch(`${API_BASE}/api/node-metrics`);
-        if (!response.ok) throw new Error('Node metrics fetch failed');
-        nodeMetricsData = await response.json();
-        updateNodeMetricsDisplay();
-    } catch (e) {
-        console.error('Error fetching node metrics:', e);
-    }
+        if (response.ok) nodeMetricsData = await response.json();
+    } catch {}
 }
 
 async function fetchEntryPointMetrics() {
     try {
         const response = await fetch(`${API_BASE}/api/simulator/metrics`);
-        if (!response.ok) throw new Error('Entry point metrics fetch failed');
-        const data = await response.json();
-        entryPointMetrics = data.entryPoints || [];
-        updateEntryPointsTable();
-    } catch (e) {
-        console.error('Error fetching entry point metrics:', e);
-    }
+        if (response.ok) {
+            const data = await response.json();
+            entryPointMetrics = data.entryPoints || [];
+            updateEntryPointsTable();
+        }
+    } catch {}
 }
 
 function updateEntryPointsTable() {
     const tbody = document.getElementById('entrypoints-body');
-    if (!tbody) return;
-
-    if (!entryPointMetrics || entryPointMetrics.length === 0) {
-        tbody.innerHTML = '<tr><td colspan="7" class="placeholder">No entry points</td></tr>';
+    if (!entryPointMetrics?.length) {
+        tbody.innerHTML = '<tr><td colspan="6" class="placeholder">No entry points</td></tr>';
         return;
     }
 
-    // Sort by name
-    const sorted = [...entryPointMetrics].sort((a, b) => a.name.localeCompare(b.name));
-
-    let html = '';
-    sorted.forEach(ep => {
-        const successClass = ep.successRate >= 99 ? 'success' : (ep.successRate >= 95 ? 'warning' : 'danger');
-        html += `
-            <tr>
-                <td class="ep-name">${escapeHtml(ep.name)}</td>
-                <td class="ep-rate">
-                    <input type="number" value="${ep.rate}" min="0" max="100000" step="100"
-                           data-entrypoint="${escapeHtml(ep.name)}"
-                           class="rate-input"
-                           onchange="updateEntryPointRate(this)">
-                </td>
-                <td class="ep-total">${formatNumber(ep.totalCalls)}</td>
-                <td class="ep-success ${successClass}">${ep.successRate.toFixed(1)}%</td>
-                <td class="ep-latency">${ep.avgLatencyMs.toFixed(1)}</td>
-                <td class="ep-p99">${ep.p99LatencyMs.toFixed(0)}</td>
-                <td class="ep-rps">${ep.requestsPerSecond.toFixed(0)}</td>
-            </tr>
-        `;
-    });
-
-    tbody.innerHTML = html;
+    tbody.innerHTML = [...entryPointMetrics].sort((a, b) => a.name.localeCompare(b.name)).map(ep => {
+        const successClass = ep.successRate >= 99 ? 'success' : ep.successRate >= 95 ? 'warning' : 'danger';
+        return `<tr>
+            <td class="ep-name">${escapeHtml(ep.name)}</td>
+            <td><input type="number" value="${ep.rate}" min="0" max="100000" step="100" data-entrypoint="${escapeHtml(ep.name)}" class="rate-input" onchange="updateEntryPointRate(this)"></td>
+            <td>${formatNumber(ep.totalCalls)}</td>
+            <td class="ep-success ${successClass}">${ep.successRate.toFixed(1)}%</td>
+            <td>${ep.avgLatencyMs.toFixed(1)}ms</td>
+            <td>${ep.p99LatencyMs.toFixed(0)}ms</td>
+        </tr>`;
+    }).join('');
 }
 
 async function updateEntryPointRate(input) {
-    const entryPoint = input.dataset.entrypoint;
     const rate = parseInt(input.value) || 0;
-
     try {
-        const response = await fetch(`${API_BASE}/api/simulator/rate/${entryPoint}`, {
+        await fetch(`${API_BASE}/api/simulator/rate/${input.dataset.entrypoint}`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ rate })
         });
-        if (!response.ok) throw new Error('Failed to update rate');
-        console.log(`Updated ${entryPoint} rate to ${rate}`);
-    } catch (e) {
-        console.error('Error updating entry point rate:', e);
+    } catch {
         input.classList.add('error');
-        setTimeout(() => input.classList.remove('error'), 2000);
+        setTimeout(() => input.classList.remove('error'), 1000);
     }
 }
 
 function formatNumber(num) {
-    if (num >= 1000000) {
-        return (num / 1000000).toFixed(1) + 'M';
-    } else if (num >= 1000) {
-        return (num / 1000).toFixed(1) + 'K';
-    }
-    return num.toString();
-}
-
-function updateNodeMetricsDisplay() {
-    if (!showNodeMetrics) {
-        // Remove all metrics labels
-        svg.selectAll('.node-metrics').remove();
-        return;
-    }
-
-    // Update metrics labels for each node
-    svg.selectAll('.node').each(function(d) {
-        const nodeGroup = d3.select(this);
-        const metrics = nodeMetricsData.find(m => m.nodeId === d.id);
-
-        // Remove existing metrics label
-        nodeGroup.select('.node-metrics').remove();
-
-        if (metrics) {
-            const label = `CPU: ${(metrics.cpuUsage * 100).toFixed(0)}%\nHeap: ${metrics.heapUsedMb}/${metrics.heapMaxMb}MB`;
-            nodeGroup.append('text')
-                .attr('class', 'node-metrics')
-                .attr('dy', 45)
-                .attr('text-anchor', 'middle')
-                .style('font-size', '10px')
-                .style('fill', '#a0a0b0')
-                .selectAll('tspan')
-                .data(label.split('\n'))
-                .enter()
-                .append('tspan')
-                .attr('x', 0)
-                .attr('dy', (_, i) => i === 0 ? 0 : 12)
-                .text(t => t);
-        }
-    });
+    return num >= 1000000 ? (num / 1000000).toFixed(1) + 'M' : num >= 1000 ? (num / 1000).toFixed(1) + 'K' : num.toString();
 }
 
 function startPolling() {
@@ -641,68 +270,43 @@ async function poll() {
     const status = await fetchStatus();
     if (!status) return;
 
-    // Update nodes state
     nodes = status.cluster.nodes;
-
-    // Update topology
-    updateTopology(status.cluster);
-
-    // Update metrics display
     updateMetricsDisplay(status.metrics);
-
-    // Update charts
     updateCharts(status.metrics);
-
-    // Update load display
     updateLoadDisplay(status.load);
 
-    // Update header stats
     document.getElementById('uptime').textContent = formatUptime(status.uptimeSeconds);
     document.getElementById('node-count').textContent = status.cluster.nodeCount;
+    document.getElementById('slice-count').textContent = status.sliceCount || 0;
 
-    // Fetch and update events
     const newEvents = await fetchEvents();
     updateTimeline(newEvents);
 
-    // Fetch node metrics and update node list
     await fetchNodeMetrics();
     updateNodesList(status.cluster.nodes, status.sliceCount);
 
-    // Fetch entry point metrics
     await fetchEntryPointMetrics();
 }
 
 function updateMetricsDisplay(metrics) {
-    document.getElementById('requests-per-sec').textContent =
-        Math.round(metrics.requestsPerSecond).toLocaleString();
-
-    const successRateEl = document.getElementById('success-rate');
-    successRateEl.textContent = `${metrics.successRate.toFixed(1)}%`;
-
-    // Color code success rate
-    const card = successRateEl.closest('.metric-card');
-    if (metrics.successRate >= 99) {
-        card.style.borderColor = '#22c55e';
-        successRateEl.style.color = '#22c55e';
-    } else if (metrics.successRate >= 95) {
-        card.style.borderColor = '#f59e0b';
-        successRateEl.style.color = '#f59e0b';
-    } else {
-        card.style.borderColor = '#ef4444';
-        successRateEl.style.color = '#ef4444';
-    }
+    document.getElementById('requests-per-sec').textContent = Math.round(metrics.requestsPerSecond).toLocaleString();
 
-    document.getElementById('avg-latency').textContent =
-        `${metrics.avgLatencyMs.toFixed(1)}ms`;
+    const successEl = document.getElementById('success-rate');
+    successEl.textContent = `${metrics.successRate.toFixed(1)}%`;
+
+    const card = successEl.closest('.metric-card');
+    const color = metrics.successRate >= 99 ? '#22c55e' : metrics.successRate >= 95 ? '#f59e0b' : '#ef4444';
+    card.style.borderColor = color;
+    successEl.style.color = color;
+
+    document.getElementById('avg-latency').textContent = `${metrics.avgLatencyMs.toFixed(1)}ms`;
 }
 
 function updateLoadDisplay(load) {
     const slider = document.getElementById('load-slider');
-    const loadValue = document.getElementById('load-value');
-
     if (document.activeElement !== slider) {
         slider.value = load.currentRate;
-        loadValue.textContent = formatLoadRate(load.currentRate);
+        document.getElementById('load-value').textContent = formatLoadRate(load.currentRate);
     }
 }
 
@@ -714,44 +318,24 @@ function escapeHtml(text) {
 
 function updateTimeline(newEvents) {
     const timeline = document.getElementById('timeline');
-
-    // Handle reset case
     if (newEvents.length < events.length) {
         timeline.innerHTML = '';
         events = [];
     }
 
-    // Check for new events
     if (newEvents.length > events.length) {
-        const added = newEvents.slice(events.length);
-        added.forEach(event => {
+        newEvents.slice(events.length).forEach(event => {
             const div = document.createElement('div');
             div.className = 'timeline-event';
-
-            const timeSpan = document.createElement('span');
-            timeSpan.className = 'event-time';
-            timeSpan.textContent = formatEventTime(event.timestamp);
-
-            const typeSpan = document.createElement('span');
-            typeSpan.className = 'event-type ' + escapeHtml(event.type);
-            typeSpan.textContent = event.type;
-
-            const msgSpan = document.createElement('span');
-            msgSpan.className = 'event-message';
-            msgSpan.textContent = event.message;
-
-            div.appendChild(timeSpan);
-            div.appendChild(typeSpan);
-            div.appendChild(msgSpan);
+            div.innerHTML = `
+                <span class="event-time">${formatEventTime(event.timestamp)}</span>
+                <span class="event-type ${escapeHtml(event.type)}">${event.type}</span>
+                <span class="event-message">${escapeHtml(event.message)}</span>
+            `;
             timeline.insertBefore(div, timeline.firstChild);
         });
-
-        // Keep only last 20 events in DOM
-        while (timeline.children.length > 20) {
-            timeline.removeChild(timeline.lastChild);
-        }
+        while (timeline.children.length > 15) timeline.removeChild(timeline.lastChild);
     }
-
     events = newEvents;
 }
 
@@ -762,65 +346,31 @@ function formatUptime(seconds) {
 }
 
 function formatEventTime(isoString) {
-    const date = new Date(isoString);
-    return date.toLocaleTimeString();
+    return new Date(isoString).toLocaleTimeString('en-US', { hour12: false, hour: '2-digit', minute: '2-digit', second: '2-digit' });
 }
 
 function updateNodesList(clusterNodes, sliceCount) {
     const container = document.getElementById('nodes-list');
-    if (!clusterNodes || clusterNodes.length === 0) {
+    if (!clusterNodes?.length) {
         container.innerHTML = '<div class="node-item placeholder">No nodes available</div>';
         return;
     }
 
-    // Update slice count badge
-    sliceCount = sliceCount || 0;
-    document.getElementById('slice-count').textContent = `${sliceCount} slice${sliceCount !== 1 ? 's' : ''}`;
-
-    // Sort nodes: leader first, then by id
-    const sortedNodes = [...clusterNodes].sort((a, b) => {
-        if (a.isLeader && !b.isLeader) return -1;
-        if (!a.isLeader && b.isLeader) return 1;
-        return a.id.localeCompare(b.id);
-    });
-
-    // Slice names for display
-    const sliceNames = sliceCount > 0 ? [
-        'inventory-service',
-        'pricing-service',
-        'place-order',
-        'get-order-status',
-        'cancel-order'
-    ] : [];
-
-    let html = '';
-    sortedNodes.forEach(node => {
-        const metrics = nodeMetricsData.find(m => m.nodeId === node.id);
-        const cpuPercent = metrics ? (metrics.cpuUsage * 100).toFixed(0) : '?';
-        const heapUsed = metrics ? metrics.heapUsedMb : '?';
-        const heapMax = metrics ? metrics.heapMaxMb : '?';
-
-        const sliceList = sliceCount > 0
-            ? sliceNames.map(s => `<span class="slice-tag">${s}</span>`).join('')
-            : '<span class="no-slices">No slices deployed</span>';
-
-        html += `
-            <div class="node-item ${node.isLeader ? 'leader' : ''}">
-                <div class="node-header">
-                    <span class="node-id">${node.id}</span>
-                    ${node.isLeader ? '<span class="leader-badge">LEADER</span>' : ''}
-                    <span class="node-port">:${node.port}</span>
-                </div>
-                <div class="node-stats">
-                    <span class="node-stat">CPU: ${cpuPercent}%</span>
-                    <span class="node-stat">Heap: ${heapUsed}/${heapMax}MB</span>
-                </div>
-                <div class="node-slices">
-                    ${sliceList}
-                </div>
-            </div>
-        `;
-    });
-
-    container.innerHTML = html;
+    const sliceNames = sliceCount > 0 ? ['inventory', 'pricing', 'place-order', 'get-status', 'cancel'] : [];
+
+    container.innerHTML = [...clusterNodes]
+        .sort((a, b) => a.isLeader ? -1 : b.isLeader ? 1 : a.id.localeCompare(b.id))
+        .map(node => {
+            const metrics = nodeMetricsData.find(m => m.nodeId === node.id);
+            const cpu = metrics ? (metrics.cpuUsage * 100).toFixed(0) : '?';
+            const heap = metrics ? `${metrics.heapUsedMb}/${metrics.heapMaxMb}` : '?/?';
+            const slices = sliceNames.map(s => `<span class="slice-tag">${s}</span>`).join('');
+
+            return `<div class="node-item ${node.isLeader ? 'leader' : ''}">
+                <span class="node-id">${node.id}</span>
+                ${node.isLeader ? '<span class="leader-badge">LEADER</span>' : ''}
+                <span class="node-stats"><span>CPU ${cpu}%</span><span>Heap ${heap}MB</span></span>
+                <span class="node-slices">${slices}</span>
+            </div>`;
+        }).join('');
 }
diff --git a/forge/src/main/resources/static/index.html b/forge/src/main/resources/static/index.html
index 0be41783..8c35e6da 100644
--- a/forge/src/main/resources/static/index.html
+++ b/forge/src/main/resources/static/index.html
@@ -5,7 +5,6 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>Aether Forge</title>
     <link rel="stylesheet" href="style.css">
-    <script src="https://d3js.org/d3.v7.min.js"></script>
     <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
 </head>
 <body>
@@ -14,157 +13,129 @@
         <header class="header">
             <h1>AETHER FORGE</h1>
             <div class="header-stats">
-                <span class="stat">
-                    <span class="stat-label">Uptime:</span>
-                    <span id="uptime" class="stat-value">0:00</span>
-                </span>
-                <span class="stat">
-                    <span class="stat-label">Nodes:</span>
-                    <span id="node-count" class="stat-value">0</span>
-                </span>
+                <span class="stat"><span class="stat-label">Uptime:</span><span id="uptime" class="stat-value">0:00</span></span>
+                <span class="stat"><span class="stat-label">Nodes:</span><span id="node-count" class="stat-value">0</span></span>
+                <span class="stat"><span class="stat-label">Slices:</span><span id="slice-count" class="stat-value">0</span></span>
             </div>
         </header>
 
-        <!-- Main Content -->
-        <div class="main-content">
-            <!-- Left Panel: Cluster Topology -->
-            <div class="panel cluster-panel">
-                <h2>Cluster Topology</h2>
-                <div id="cluster-viz">
-                    <svg id="topology-svg"></svg>
-                </div>
-                <div id="cluster-legend">
-                    <span class="legend-item"><span class="node-dot leader"></span> Leader</span>
-                    <span class="legend-item"><span class="node-dot healthy"></span> Healthy</span>
-                    <span class="legend-item"><span class="node-dot dead"></span> Dead</span>
-                    <button id="btn-toggle-metrics" class="btn btn-secondary btn-small">Show JVM</button>
+        <!-- Main Grid -->
+        <div class="main-grid">
+            <!-- Left Column -->
+            <div class="left-column">
+                <!-- Nodes Panel -->
+                <div class="panel">
+                    <h2>Cluster Nodes</h2>
+                    <div id="nodes-list" class="nodes-list">
+                        <div class="node-item placeholder">Waiting for cluster...</div>
+                    </div>
                 </div>
-            </div>
 
-            <!-- Right Panel: Metrics -->
-            <div class="panel metrics-panel">
-                <h2>Real-Time Metrics</h2>
-
-                <!-- Key Metrics Display -->
-                <div class="metrics-grid">
-                    <div class="metric-card">
-                        <div class="metric-value" id="requests-per-sec">0</div>
-                        <div class="metric-label">Requests/sec</div>
-                    </div>
-                    <div class="metric-card success">
-                        <div class="metric-value" id="success-rate">100%</div>
-                        <div class="metric-label">Success Rate</div>
+                <!-- Metrics Panel -->
+                <div class="panel">
+                    <h2>Metrics</h2>
+                    <div class="metrics-row">
+                        <div class="metric-card">
+                            <div class="metric-value" id="requests-per-sec">0</div>
+                            <div class="metric-label">req/s</div>
+                        </div>
+                        <div class="metric-card success">
+                            <div class="metric-value" id="success-rate">100%</div>
+                            <div class="metric-label">success</div>
+                        </div>
+                        <div class="metric-card">
+                            <div class="metric-value" id="avg-latency">0ms</div>
+                            <div class="metric-label">latency</div>
+                        </div>
                     </div>
-                    <div class="metric-card">
-                        <div class="metric-value" id="avg-latency">0ms</div>
-                        <div class="metric-label">Avg Latency</div>
+                    <div class="chart-row">
+                        <div class="chart-container"><canvas id="success-chart"></canvas></div>
+                        <div class="chart-container"><canvas id="throughput-chart"></canvas></div>
                     </div>
                 </div>
-
-                <!-- Success Rate Chart -->
-                <div class="chart-container">
-                    <canvas id="success-chart"></canvas>
-                </div>
-
-                <!-- Throughput Chart -->
-                <div class="chart-container small">
-                    <canvas id="throughput-chart"></canvas>
-                </div>
             </div>
-        </div>
 
-        <!-- Event Timeline -->
-        <div class="panel timeline-panel">
-            <h2>Event Timeline</h2>
-            <div id="timeline" class="timeline">
-                <div class="timeline-event">
-                    <span class="event-time">--:--:--</span>
-                    <span class="event-type">READY</span>
-                    <span class="event-message">Waiting for cluster...</span>
+            <!-- Right Column -->
+            <div class="right-column">
+                <!-- Entry Points Panel -->
+                <div class="panel">
+                    <h2>Entry Points</h2>
+                    <div class="entrypoints-table">
+                        <table>
+                            <thead>
+                                <tr>
+                                    <th>Entry Point</th>
+                                    <th>Rate</th>
+                                    <th>Total</th>
+                                    <th>Success</th>
+                                    <th>Avg</th>
+                                    <th>P99</th>
+                                </tr>
+                            </thead>
+                            <tbody id="entrypoints-body">
+                                <tr><td colspan="6" class="placeholder">Loading...</td></tr>
+                            </tbody>
+                        </table>
+                    </div>
                 </div>
-            </div>
-        </div>
-
-        <!-- Node Details Panel -->
-        <div class="panel nodes-panel">
-            <h2>Node Details <span id="slice-count" class="slice-badge">0 slices</span></h2>
-            <div id="nodes-list" class="nodes-list">
-                <div class="node-item placeholder">Waiting for cluster...</div>
-            </div>
-        </div>
 
-        <!-- Entry Point Metrics Panel -->
-        <div class="panel entrypoints-panel">
-            <h2>Entry Point Metrics</h2>
-            <div id="entrypoints-table" class="entrypoints-table">
-                <table>
-                    <thead>
-                        <tr>
-                            <th>Entry Point</th>
-                            <th>Rate (req/s)</th>
-                            <th>Total</th>
-                            <th>Success %</th>
-                            <th>Avg (ms)</th>
-                            <th>P99 (ms)</th>
-                            <th>RPS</th>
-                        </tr>
-                    </thead>
-                    <tbody id="entrypoints-body">
-                        <tr><td colspan="7" class="placeholder">Loading...</td></tr>
-                    </tbody>
-                </table>
+                <!-- Timeline Panel -->
+                <div class="panel">
+                    <h2>Events</h2>
+                    <div id="timeline" class="timeline">
+                        <div class="timeline-event">
+                            <span class="event-time">--:--</span>
+                            <span class="event-type">READY</span>
+                            <span class="event-message">Waiting...</span>
+                        </div>
+                    </div>
+                </div>
             </div>
         </div>
 
         <!-- Control Panel -->
-        <div class="panel control-panel">
+        <div class="control-panel">
             <div class="control-group">
-                <h3>Chaos Operations</h3>
+                <h3>Chaos</h3>
                 <div class="button-row">
-                    <button id="btn-kill-node" class="btn btn-danger">KILL NODE</button>
-                    <button id="btn-kill-leader" class="btn btn-danger btn-large">KILL LEADER</button>
-                    <button id="btn-rolling-restart" class="btn btn-warning">ROLLING RESTART</button>
-                    <button id="btn-add-node" class="btn btn-success">+ ADD NODE</button>
+                    <button id="btn-kill-node" class="btn btn-danger">Kill Node</button>
+                    <button id="btn-kill-leader" class="btn btn-danger">Kill Leader</button>
+                    <button id="btn-rolling-restart" class="btn btn-warning">Rolling Restart</button>
+                    <button id="btn-add-node" class="btn btn-success">+ Node</button>
                 </div>
             </div>
 
             <div class="control-group">
-                <h3>Load Control</h3>
+                <h3>Load</h3>
                 <div class="load-control">
                     <input type="range" id="load-slider" min="100" max="100000" value="1000" step="100">
-                    <span id="load-value">1000 req/sec</span>
+                    <span id="load-value">1K</span>
                 </div>
                 <div class="button-row">
-                    <button id="btn-load-1k" class="btn btn-primary">1K</button>
-                    <button id="btn-load-5k" class="btn btn-primary">5K</button>
-                    <button id="btn-load-10k" class="btn btn-primary">10K</button>
-                    <button id="btn-load-25k" class="btn btn-primary">25K</button>
-                    <button id="btn-load-50k" class="btn btn-primary">50K</button>
-                    <button id="btn-load-100k" class="btn btn-primary">100K</button>
-                    <button id="btn-ramp" class="btn btn-info">RAMP</button>
+                    <button id="btn-load-1k" class="btn btn-primary btn-small">1K</button>
+                    <button id="btn-load-5k" class="btn btn-primary btn-small">5K</button>
+                    <button id="btn-load-10k" class="btn btn-primary btn-small">10K</button>
+                    <button id="btn-load-25k" class="btn btn-primary btn-small">25K</button>
+                    <button id="btn-load-50k" class="btn btn-primary btn-small">50K</button>
+                    <button id="btn-load-100k" class="btn btn-primary btn-small">100K</button>
+                    <button id="btn-ramp" class="btn btn-info btn-small">Ramp</button>
                 </div>
             </div>
 
             <div class="control-group">
-                <h3>Simulator Config</h3>
-                <div class="config-control">
+                <h3>Config</h3>
+                <div class="config-row">
                     <label class="toggle-label">
                         <input type="checkbox" id="load-generator-toggle" checked>
                         <span class="toggle-slider"></span>
-                        Load Generator
+                        Generator
                     </label>
                     <div class="multiplier-control">
-                        <label for="rate-multiplier">Rate Multiplier:</label>
+                        <span>x</span>
                         <input type="number" id="rate-multiplier" min="0.1" max="10" step="0.1" value="1.0">
-                        <button id="btn-apply-multiplier" class="btn btn-small btn-primary">Apply</button>
+                        <button id="btn-apply-multiplier" class="btn btn-small btn-secondary">Apply</button>
                     </div>
-                </div>
-            </div>
-
-            <div class="control-group">
-                <h3>Quick Actions</h3>
-                <div class="button-row">
-                    <button id="btn-reset" class="btn btn-secondary">RESET METRICS</button>
+                    <button id="btn-reset" class="btn btn-secondary btn-small">Reset</button>
                 </div>
             </div>
         </div>
@@ -173,7 +144,7 @@ <h3>Quick Actions</h3>
     <!-- Node Selection Modal -->
     <div id="node-modal" class="modal hidden">
         <div class="modal-content">
-            <h3>Select Node to Kill</h3>
+            <h3>Select Node</h3>
             <div id="node-list" class="node-list"></div>
             <button id="modal-cancel" class="btn btn-secondary">Cancel</button>
         </div>
diff --git a/forge/src/main/resources/static/style.css b/forge/src/main/resources/static/style.css
index dc3d993a..0900cf11 100644
--- a/forge/src/main/resources/static/style.css
+++ b/forge/src/main/resources/static/style.css
@@ -1,54 +1,39 @@
-/* Aether Resilience Demo - Dark Theme */
+/* Aether Forge - Compact Dark Theme */
 
 :root {
     --bg-primary: #0a0a0f;
     --bg-secondary: #12121a;
     --bg-card: #1a1a24;
-    --bg-card-hover: #22222e;
-
-    --text-primary: #ffffff;
-    --text-secondary: #a0a0b0;
-    --text-muted: #606070;
-
+    --text-primary: #e0e0e8;
+    --text-secondary: #888898;
+    --text-muted: #505060;
     --accent-blue: #3b82f6;
     --accent-green: #22c55e;
     --accent-yellow: #f59e0b;
     --accent-red: #ef4444;
-    --accent-purple: #8b5cf6;
     --accent-cyan: #06b6d4;
-
-    --glow-blue: 0 0 20px rgba(59, 130, 246, 0.5);
-    --glow-green: 0 0 20px rgba(34, 197, 94, 0.5);
-    --glow-red: 0 0 20px rgba(239, 68, 68, 0.5);
-
-    --border-color: #2a2a3a;
-    --border-radius: 8px;
-
-    --font-mono: 'JetBrains Mono', 'Fira Code', monospace;
-    --font-sans: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+    --border-color: #252530;
+    --font-mono: 'SF Mono', 'Fira Code', monospace;
+    --font-sans: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
 }
 
-* {
-    margin: 0;
-    padding: 0;
-    box-sizing: border-box;
-}
+* { margin: 0; padding: 0; box-sizing: border-box; }
 
 body {
     font-family: var(--font-sans);
+    font-size: 12px;
     background: var(--bg-primary);
     color: var(--text-primary);
-    min-height: 100vh;
-    line-height: 1.5;
+    line-height: 1.4;
 }
 
 .container {
-    max-width: 1600px;
+    max-width: 1400px;
     margin: 0 auto;
-    padding: 20px;
+    padding: 12px;
     display: flex;
     flex-direction: column;
-    gap: 20px;
+    gap: 12px;
     min-height: 100vh;
 }
 
@@ -57,794 +42,412 @@ body {
     display: flex;
     justify-content: space-between;
     align-items: center;
-    padding: 15px 30px;
-    background: linear-gradient(135deg, var(--bg-secondary), var(--bg-card));
-    border-radius: var(--border-radius);
+    padding: 8px 16px;
+    background: var(--bg-card);
+    border-radius: 6px;
     border: 1px solid var(--border-color);
 }
 
 .header h1 {
-    font-size: 1.5rem;
-    font-weight: 700;
-    letter-spacing: 2px;
-    background: linear-gradient(90deg, var(--accent-cyan), var(--accent-blue));
-    -webkit-background-clip: text;
-    -webkit-text-fill-color: transparent;
-    background-clip: text;
+    font-size: 14px;
+    font-weight: 600;
+    letter-spacing: 1px;
+    color: var(--accent-cyan);
 }
 
 .header-stats {
     display: flex;
-    gap: 30px;
+    gap: 20px;
 }
 
 .stat {
     display: flex;
-    gap: 8px;
+    gap: 6px;
     align-items: center;
 }
 
 .stat-label {
-    color: var(--text-secondary);
-    font-size: 0.9rem;
+    color: var(--text-muted);
+    font-size: 11px;
 }
 
 .stat-value {
     font-family: var(--font-mono);
-    font-size: 1.1rem;
+    font-size: 12px;
     color: var(--accent-cyan);
 }
 
-/* Main Content Grid */
-.main-content {
+/* Main Grid */
+.main-grid {
     display: grid;
     grid-template-columns: 1fr 1fr;
-    gap: 20px;
+    gap: 12px;
     flex: 1;
 }
 
+.left-column, .right-column {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+}
+
 /* Panels */
 .panel {
     background: var(--bg-card);
-    border-radius: var(--border-radius);
+    border-radius: 6px;
     border: 1px solid var(--border-color);
-    padding: 20px;
+    padding: 10px;
 }
 
 .panel h2 {
-    font-size: 1rem;
+    font-size: 11px;
     font-weight: 600;
     color: var(--text-secondary);
     text-transform: uppercase;
-    letter-spacing: 1px;
-    margin-bottom: 15px;
-    padding-bottom: 10px;
+    letter-spacing: 0.5px;
+    margin-bottom: 8px;
+    padding-bottom: 6px;
     border-bottom: 1px solid var(--border-color);
 }
 
-/* Cluster Visualization */
-.cluster-panel {
+/* Nodes List */
+.nodes-list {
     display: flex;
     flex-direction: column;
+    gap: 6px;
+    max-height: 200px;
+    overflow-y: auto;
 }
 
-#cluster-viz {
-    flex: 1;
-    min-height: 300px;
-    background: var(--bg-secondary);
-    border-radius: var(--border-radius);
-    overflow: hidden;
-}
-
-#topology-svg {
-    width: 100%;
-    height: 100%;
-}
-
-#cluster-legend {
-    display: flex;
-    gap: 20px;
-    margin-top: 15px;
-    justify-content: center;
-}
-
-.legend-item {
+.node-item {
     display: flex;
     align-items: center;
-    gap: 8px;
-    font-size: 0.85rem;
-    color: var(--text-secondary);
-}
-
-.node-dot {
-    width: 12px;
-    height: 12px;
-    border-radius: 50%;
-}
-
-.node-dot.leader {
-    background: var(--accent-yellow);
-    box-shadow: var(--glow-green);
-}
-
-.node-dot.healthy {
-    background: var(--accent-green);
-}
-
-.node-dot.dead {
-    background: var(--text-muted);
+    gap: 10px;
+    padding: 6px 8px;
+    background: var(--bg-secondary);
+    border-radius: 4px;
+    border-left: 2px solid var(--accent-green);
+    font-size: 11px;
 }
 
-/* SVG Node Styles */
-.node circle {
-    stroke-width: 2px;
-    transition: all 0.3s ease;
+.node-item.leader {
+    border-left-color: var(--accent-yellow);
+    background: linear-gradient(90deg, rgba(245, 158, 11, 0.08), var(--bg-secondary));
 }
 
-.node.leader circle {
-    fill: var(--accent-yellow);
-    stroke: var(--accent-green);
-    filter: drop-shadow(0 0 10px rgba(34, 197, 94, 0.6));
+.node-item.placeholder {
+    border-left-color: var(--text-muted);
+    color: var(--text-muted);
+    font-style: italic;
 }
 
-.node.healthy circle {
-    fill: var(--accent-green);
-    stroke: var(--accent-cyan);
-    filter: drop-shadow(0 0 8px rgba(34, 197, 94, 0.4));
+.node-id {
+    font-family: var(--font-mono);
+    font-weight: 500;
+    min-width: 80px;
 }
 
-.node.joining circle {
-    fill: var(--accent-blue);
-    stroke: var(--accent-cyan);
-    opacity: 0.7;
-    animation: pulse 1s ease-in-out infinite;
+.leader-badge {
+    font-size: 9px;
+    background: var(--accent-yellow);
+    color: var(--bg-primary);
+    padding: 1px 4px;
+    border-radius: 2px;
+    font-weight: 600;
 }
 
-.node text {
-    fill: var(--text-primary);
+.node-stats {
+    display: flex;
+    gap: 12px;
+    color: var(--text-secondary);
     font-family: var(--font-mono);
-    font-size: 12px;
-    text-anchor: middle;
-    dominant-baseline: middle;
+    font-size: 10px;
 }
 
-.link {
-    stroke: var(--border-color);
-    stroke-width: 2px;
-    opacity: 0.6;
+.node-slices {
+    display: flex;
+    gap: 4px;
+    flex-wrap: wrap;
+    margin-left: auto;
 }
 
-@keyframes pulse {
-    0%, 100% { opacity: 0.7; transform: scale(1); }
-    50% { opacity: 1; transform: scale(1.1); }
+.slice-tag {
+    font-size: 9px;
+    color: var(--accent-green);
+    padding: 1px 4px;
+    border: 1px solid var(--accent-green);
+    border-radius: 2px;
+    opacity: 0.8;
 }
 
-/* Metrics Panel */
-.metrics-grid {
+/* Metrics */
+.metrics-row {
     display: grid;
     grid-template-columns: repeat(3, 1fr);
-    gap: 15px;
-    margin-bottom: 20px;
+    gap: 8px;
+    margin-bottom: 10px;
 }
 
 .metric-card {
     background: var(--bg-secondary);
-    padding: 20px;
-    border-radius: var(--border-radius);
+    padding: 10px;
+    border-radius: 4px;
     text-align: center;
     border: 1px solid var(--border-color);
-    transition: all 0.3s ease;
-}
-
-.metric-card:hover {
-    border-color: var(--accent-blue);
-    box-shadow: var(--glow-blue);
-}
-
-.metric-card.success .metric-value {
-    color: var(--accent-green);
 }
 
-.metric-card.success {
-    border-color: var(--accent-green);
-}
+.metric-card.success { border-color: var(--accent-green); }
+.metric-card.success .metric-value { color: var(--accent-green); }
 
 .metric-value {
     font-family: var(--font-mono);
-    font-size: 2rem;
-    font-weight: 700;
+    font-size: 18px;
+    font-weight: 600;
     color: var(--accent-cyan);
-    margin-bottom: 5px;
 }
 
 .metric-label {
-    font-size: 0.85rem;
-    color: var(--text-secondary);
+    font-size: 9px;
+    color: var(--text-muted);
     text-transform: uppercase;
-    letter-spacing: 1px;
+    letter-spacing: 0.5px;
+    margin-top: 2px;
 }
 
 /* Charts */
-.chart-container {
-    height: 200px;
-    margin-bottom: 15px;
-    background: var(--bg-secondary);
-    border-radius: var(--border-radius);
-    padding: 10px;
-}
-
-.chart-container.small {
-    height: 120px;
-}
-
-/* Timeline Panel */
-.timeline-panel {
-    max-height: 200px;
-}
-
-.timeline {
-    max-height: 150px;
-    overflow-y: auto;
-    display: flex;
-    flex-direction: column;
+.chart-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
     gap: 8px;
 }
 
-.timeline-event {
-    display: flex;
-    gap: 15px;
-    padding: 8px 12px;
+.chart-container {
+    height: 80px;
     background: var(--bg-secondary);
-    border-radius: var(--border-radius);
-    font-size: 0.9rem;
-    animation: slideIn 0.3s ease;
-}
-
-@keyframes slideIn {
-    from { opacity: 0; transform: translateX(-20px); }
-    to { opacity: 1; transform: translateX(0); }
-}
-
-.event-time {
-    font-family: var(--font-mono);
-    color: var(--text-muted);
-    min-width: 80px;
-}
-
-.event-type {
-    font-weight: 600;
-    min-width: 140px;
-    padding: 2px 8px;
     border-radius: 4px;
-    font-size: 0.8rem;
-    text-align: center;
+    padding: 6px;
 }
 
-.event-type.CLUSTER_STARTED,
-.event-type.NODE_JOINED,
-.event-type.ROLLING_RESTART_COMPLETE {
-    background: rgba(34, 197, 94, 0.2);
-    color: var(--accent-green);
-}
-
-.event-type.KILL_NODE,
-.event-type.NODE_KILLED,
-.event-type.CRASH_NODE,
-.event-type.NODE_CRASHED {
-    background: rgba(239, 68, 68, 0.2);
-    color: var(--accent-red);
-}
-
-.event-type.ROLLING_RESTART,
-.event-type.LOAD_SET,
-.event-type.LOAD_RAMP {
-    background: rgba(245, 158, 11, 0.2);
-    color: var(--accent-yellow);
+/* Entry Points Table */
+.entrypoints-table {
+    overflow: auto;
+    max-height: 180px;
 }
 
-.event-type.ADD_NODE {
-    background: rgba(59, 130, 246, 0.2);
-    color: var(--accent-blue);
+.entrypoints-table table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 11px;
 }
 
-.event-message {
-    color: var(--text-secondary);
-    flex: 1;
+.entrypoints-table th,
+.entrypoints-table td {
+    padding: 5px 8px;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
 }
 
-/* Nodes Panel */
-.nodes-panel {
-    max-height: 250px;
+.entrypoints-table th {
+    background: var(--bg-secondary);
+    color: var(--text-muted);
+    font-weight: 500;
+    font-size: 10px;
+    text-transform: uppercase;
+    position: sticky;
+    top: 0;
 }
 
-.nodes-panel h2 {
-    display: flex;
-    align-items: center;
-    gap: 10px;
+.entrypoints-table tbody tr:hover {
+    background: rgba(255,255,255,0.02);
 }
 
-.slice-badge {
-    font-size: 0.75rem;
-    background: var(--bg-secondary);
-    color: var(--text-muted);
-    padding: 3px 8px;
-    border-radius: 10px;
-    font-weight: normal;
+.ep-name {
+    font-family: var(--font-mono);
+    color: var(--accent-cyan);
 }
 
-.nodes-list {
-    display: grid;
-    grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
-    gap: 10px;
-    max-height: 180px;
-    overflow-y: auto;
+.rate-input {
+    width: 60px;
+    padding: 2px 4px;
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: 3px;
+    color: var(--text-primary);
+    font-family: var(--font-mono);
+    font-size: 11px;
 }
 
-.node-item {
-    background: var(--bg-secondary);
-    border-radius: var(--border-radius);
-    padding: 10px 12px;
-    border-left: 3px solid var(--accent-green);
+.rate-input:focus {
+    outline: none;
+    border-color: var(--accent-cyan);
 }
 
-.node-item.leader {
-    border-left-color: var(--accent-yellow);
-    background: linear-gradient(135deg, rgba(245, 158, 11, 0.1), var(--bg-secondary));
-}
+.ep-success.success { color: var(--accent-green); }
+.ep-success.warning { color: var(--accent-yellow); }
+.ep-success.danger { color: var(--accent-red); }
 
-.node-item.placeholder {
-    border-left-color: var(--text-muted);
+.placeholder {
+    text-align: center;
     color: var(--text-muted);
     font-style: italic;
+    padding: 12px;
 }
 
-.node-header {
+/* Timeline */
+.timeline {
+    max-height: 150px;
+    overflow-y: auto;
     display: flex;
-    align-items: center;
-    gap: 8px;
-    margin-bottom: 6px;
-}
-
-.node-id {
-    font-family: var(--font-mono);
-    font-weight: 600;
-    color: var(--text-primary);
+    flex-direction: column;
+    gap: 4px;
 }
 
-.leader-badge {
-    font-size: 0.65rem;
-    background: var(--accent-yellow);
-    color: var(--bg-primary);
-    padding: 2px 6px;
+.timeline-event {
+    display: flex;
+    gap: 8px;
+    padding: 4px 6px;
+    background: var(--bg-secondary);
     border-radius: 3px;
-    font-weight: 700;
+    font-size: 11px;
 }
 
-.node-port {
+.event-time {
     font-family: var(--font-mono);
-    font-size: 0.8rem;
     color: var(--text-muted);
+    font-size: 10px;
+    min-width: 50px;
 }
 
-.node-stats {
-    display: flex;
-    gap: 12px;
-    font-size: 0.8rem;
-    color: var(--text-secondary);
-    margin-bottom: 6px;
-}
-
-.node-stat {
-    font-family: var(--font-mono);
-}
-
-.node-slices {
-    font-size: 0.75rem;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 4px;
+.event-type {
+    font-weight: 500;
+    padding: 1px 6px;
+    border-radius: 2px;
+    font-size: 9px;
+    min-width: 100px;
+    text-align: center;
 }
 
-.slice-tag {
-    background: var(--bg-secondary);
-    color: var(--accent-green);
-    padding: 2px 6px;
-    border-radius: 3px;
-    font-size: 0.7rem;
-    border: 1px solid var(--accent-green);
-}
+.event-type.CLUSTER_STARTED, .event-type.NODE_JOINED { background: rgba(34, 197, 94, 0.15); color: var(--accent-green); }
+.event-type.KILL_NODE, .event-type.NODE_KILLED, .event-type.NODE_CRASHED { background: rgba(239, 68, 68, 0.15); color: var(--accent-red); }
+.event-type.ROLLING_RESTART, .event-type.LOAD_SET { background: rgba(245, 158, 11, 0.15); color: var(--accent-yellow); }
+.event-type.ADD_NODE { background: rgba(59, 130, 246, 0.15); color: var(--accent-blue); }
+.event-type.RATE_SET { background: rgba(6, 182, 212, 0.15); color: var(--accent-cyan); }
 
-.no-slices {
-    color: var(--text-muted);
-    font-style: italic;
+.event-message {
+    color: var(--text-secondary);
+    flex: 1;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
 }
 
 /* Control Panel */
 .control-panel {
     display: grid;
-    grid-template-columns: 2fr 1.5fr 1fr;
-    gap: 30px;
+    grid-template-columns: auto 1fr auto;
+    gap: 20px;
+    padding: 10px 12px;
+    background: var(--bg-card);
+    border-radius: 6px;
+    border: 1px solid var(--border-color);
+    align-items: start;
 }
 
 .control-group h3 {
-    font-size: 0.9rem;
-    color: var(--text-secondary);
-    margin-bottom: 12px;
+    font-size: 10px;
+    color: var(--text-muted);
     text-transform: uppercase;
-    letter-spacing: 1px;
+    letter-spacing: 0.5px;
+    margin-bottom: 6px;
 }
 
 .button-row {
     display: flex;
-    gap: 10px;
+    gap: 6px;
     flex-wrap: wrap;
 }
 
 /* Buttons */
 .btn {
-    padding: 12px 24px;
+    padding: 6px 12px;
     border: none;
-    border-radius: var(--border-radius);
-    font-family: var(--font-sans);
-    font-size: 0.9rem;
-    font-weight: 600;
+    border-radius: 4px;
+    font-size: 11px;
+    font-weight: 500;
     cursor: pointer;
-    transition: all 0.2s ease;
-    text-transform: uppercase;
-    letter-spacing: 1px;
+    transition: all 0.15s;
 }
 
-.btn:hover {
-    transform: translateY(-2px);
-}
-
-.btn:active {
-    transform: translateY(0);
-}
+.btn:hover { filter: brightness(1.1); }
+.btn:active { transform: scale(0.98); }
 
-.btn-danger {
-    background: linear-gradient(135deg, #dc2626, #b91c1c);
-    color: white;
-    box-shadow: 0 4px 15px rgba(239, 68, 68, 0.3);
-}
+.btn-small { padding: 4px 8px; font-size: 10px; }
 
-.btn-danger:hover {
-    box-shadow: 0 6px 20px rgba(239, 68, 68, 0.5);
-}
-
-.btn-danger.btn-large {
-    padding: 15px 30px;
-    font-size: 1rem;
-}
-
-.btn-warning {
-    background: linear-gradient(135deg, #f59e0b, #d97706);
-    color: white;
-    box-shadow: 0 4px 15px rgba(245, 158, 11, 0.3);
-}
-
-.btn-warning:hover {
-    box-shadow: 0 6px 20px rgba(245, 158, 11, 0.5);
-}
-
-.btn-success {
-    background: linear-gradient(135deg, #22c55e, #16a34a);
-    color: white;
-    box-shadow: 0 4px 15px rgba(34, 197, 94, 0.3);
-}
-
-.btn-success:hover {
-    box-shadow: 0 6px 20px rgba(34, 197, 94, 0.5);
-}
-
-.btn-primary {
-    background: linear-gradient(135deg, #3b82f6, #2563eb);
-    color: white;
-    box-shadow: 0 4px 15px rgba(59, 130, 246, 0.3);
-}
-
-.btn-primary:hover {
-    box-shadow: 0 6px 20px rgba(59, 130, 246, 0.5);
-}
-
-.btn-info {
-    background: linear-gradient(135deg, #06b6d4, #0891b2);
-    color: white;
-    box-shadow: 0 4px 15px rgba(6, 182, 212, 0.3);
-}
-
-.btn-info:hover {
-    box-shadow: 0 6px 20px rgba(6, 182, 212, 0.5);
-}
-
-.btn-secondary {
-    background: var(--bg-secondary);
-    color: var(--text-secondary);
-    border: 1px solid var(--border-color);
-}
-
-.btn-secondary:hover {
-    background: var(--bg-card-hover);
-    color: var(--text-primary);
-}
-
-.btn-small {
-    padding: 6px 12px;
-    font-size: 0.75rem;
-}
+.btn-danger { background: var(--accent-red); color: white; }
+.btn-warning { background: var(--accent-yellow); color: black; }
+.btn-success { background: var(--accent-green); color: white; }
+.btn-primary { background: var(--accent-blue); color: white; }
+.btn-info { background: var(--accent-cyan); color: black; }
+.btn-secondary { background: var(--bg-secondary); color: var(--text-secondary); border: 1px solid var(--border-color); }
 
 /* Load Control */
 .load-control {
     display: flex;
     align-items: center;
-    gap: 15px;
-    margin-bottom: 15px;
+    gap: 8px;
+    margin-bottom: 6px;
 }
 
 #load-slider {
     flex: 1;
-    height: 8px;
+    height: 4px;
     -webkit-appearance: none;
-    appearance: none;
     background: var(--bg-secondary);
-    border-radius: 4px;
-    outline: none;
+    border-radius: 2px;
+    max-width: 200px;
 }
 
 #load-slider::-webkit-slider-thumb {
     -webkit-appearance: none;
-    appearance: none;
-    width: 20px;
-    height: 20px;
+    width: 12px;
+    height: 12px;
     background: var(--accent-cyan);
     border-radius: 50%;
     cursor: pointer;
-    box-shadow: var(--glow-blue);
 }
 
 #load-value {
     font-family: var(--font-mono);
+    font-size: 11px;
     color: var(--accent-cyan);
-    min-width: 120px;
-    text-align: right;
+    min-width: 40px;
 }
 
-/* Modal */
-.modal {
-    position: fixed;
-    top: 0;
-    left: 0;
-    width: 100%;
-    height: 100%;
-    background: rgba(0, 0, 0, 0.8);
+/* Config */
+.config-row {
     display: flex;
-    justify-content: center;
     align-items: center;
-    z-index: 1000;
-}
-
-.modal.hidden {
-    display: none;
-}
-
-.modal-content {
-    background: var(--bg-card);
-    padding: 30px;
-    border-radius: var(--border-radius);
-    border: 1px solid var(--border-color);
-    min-width: 300px;
-}
-
-.modal-content h3 {
-    margin-bottom: 20px;
-    color: var(--text-primary);
-}
-
-.node-list {
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-    margin-bottom: 20px;
-}
-
-.node-list .btn {
-    width: 100%;
-    text-align: left;
-}
-
-/* Scrollbar */
-::-webkit-scrollbar {
-    width: 8px;
-}
-
-::-webkit-scrollbar-track {
-    background: var(--bg-secondary);
-    border-radius: 4px;
-}
-
-::-webkit-scrollbar-thumb {
-    background: var(--border-color);
-    border-radius: 4px;
-}
-
-::-webkit-scrollbar-thumb:hover {
-    background: var(--text-muted);
-}
-
-/* Responsive */
-@media (max-width: 1200px) {
-    .main-content {
-        grid-template-columns: 1fr;
-    }
-
-    .control-panel {
-        grid-template-columns: 1fr;
-    }
-}
-
-/* Animation for critical events */
-@keyframes alertPulse {
-    0%, 100% { box-shadow: 0 0 0 0 rgba(239, 68, 68, 0.4); }
-    50% { box-shadow: 0 0 0 10px rgba(239, 68, 68, 0); }
-}
-
-.alert-pulse {
-    animation: alertPulse 1s ease infinite;
-}
-
-/* Entry Points Panel */
-.entrypoints-panel {
-    max-height: 300px;
-}
-
-.entrypoints-table {
-    overflow-x: auto;
-    max-height: 230px;
-    overflow-y: auto;
-}
-
-.entrypoints-table table {
-    width: 100%;
-    border-collapse: collapse;
-    font-size: 0.85rem;
-}
-
-.entrypoints-table th,
-.entrypoints-table td {
-    padding: 8px 12px;
-    text-align: left;
-    border-bottom: 1px solid var(--border-color);
-}
-
-.entrypoints-table th {
-    background: var(--bg-secondary);
-    color: var(--text-secondary);
-    font-weight: 600;
-    text-transform: uppercase;
-    font-size: 0.75rem;
-    letter-spacing: 0.5px;
-    position: sticky;
-    top: 0;
-    z-index: 1;
-}
-
-.entrypoints-table tbody tr:hover {
-    background: var(--bg-card-hover);
-}
-
-.ep-name {
-    font-family: var(--font-mono);
-    font-weight: 500;
-    color: var(--accent-cyan);
-}
-
-.ep-rate {
-    min-width: 100px;
-}
-
-.rate-input {
-    width: 80px;
-    padding: 4px 8px;
-    background: var(--bg-secondary);
-    border: 1px solid var(--border-color);
-    border-radius: 4px;
-    color: var(--text-primary);
-    font-family: var(--font-mono);
-    font-size: 0.85rem;
-}
-
-.rate-input:focus {
-    outline: none;
-    border-color: var(--accent-cyan);
-    box-shadow: 0 0 5px rgba(6, 182, 212, 0.3);
-}
-
-.rate-input.error {
-    border-color: var(--accent-red);
-    animation: shake 0.3s ease;
-}
-
-@keyframes shake {
-    0%, 100% { transform: translateX(0); }
-    25% { transform: translateX(-5px); }
-    75% { transform: translateX(5px); }
-}
-
-.ep-total,
-.ep-latency,
-.ep-p99,
-.ep-rps {
-    font-family: var(--font-mono);
-    color: var(--text-secondary);
-    text-align: right;
-}
-
-.ep-success {
-    font-family: var(--font-mono);
-    font-weight: 600;
-    text-align: right;
-}
-
-.ep-success.success {
-    color: var(--accent-green);
-}
-
-.ep-success.warning {
-    color: var(--accent-yellow);
-}
-
-.ep-success.danger {
-    color: var(--accent-red);
-}
-
-.entrypoints-table .placeholder {
-    text-align: center;
-    color: var(--text-muted);
-    font-style: italic;
-    padding: 20px;
-}
-
-/* Event type styles for rate changes */
-.event-type.RATE_SET {
-    background: rgba(6, 182, 212, 0.2);
-    color: var(--accent-cyan);
-}
-
-.event-type.CONFIG_UPDATE,
-.event-type.MULTIPLIER_SET,
-.event-type.LOAD_GENERATOR {
-    background: rgba(139, 92, 246, 0.2);
-    color: var(--accent-purple);
-}
-
-/* Simulator Config Control */
-.config-control {
-    display: flex;
-    flex-direction: column;
-    gap: 15px;
+    gap: 12px;
 }
 
 .toggle-label {
     display: flex;
     align-items: center;
-    gap: 12px;
+    gap: 6px;
     cursor: pointer;
+    font-size: 11px;
     color: var(--text-secondary);
-    font-size: 0.9rem;
 }
 
-.toggle-label input[type="checkbox"] {
-    display: none;
-}
+.toggle-label input { display: none; }
 
 .toggle-slider {
-    position: relative;
-    width: 48px;
-    height: 24px;
+    width: 28px;
+    height: 14px;
     background: var(--bg-secondary);
-    border-radius: 12px;
-    transition: all 0.3s ease;
-    border: 1px solid var(--border-color);
+    border-radius: 7px;
+    position: relative;
+    transition: 0.2s;
 }
 
 .toggle-slider::before {
@@ -852,53 +455,79 @@ body {
     position: absolute;
     top: 2px;
     left: 2px;
-    width: 18px;
-    height: 18px;
+    width: 10px;
+    height: 10px;
     background: var(--text-muted);
     border-radius: 50%;
-    transition: all 0.3s ease;
-}
-
-.toggle-label input:checked + .toggle-slider {
-    background: var(--accent-green);
-    border-color: var(--accent-green);
+    transition: 0.2s;
 }
 
-.toggle-label input:checked + .toggle-slider::before {
-    left: 26px;
-    background: white;
-}
+.toggle-label input:checked + .toggle-slider { background: var(--accent-green); }
+.toggle-label input:checked + .toggle-slider::before { left: 16px; background: white; }
 
 .multiplier-control {
     display: flex;
     align-items: center;
-    gap: 10px;
-}
-
-.multiplier-control label {
-    color: var(--text-secondary);
-    font-size: 0.85rem;
+    gap: 4px;
+    font-size: 11px;
+    color: var(--text-muted);
 }
 
 #rate-multiplier {
-    width: 70px;
-    padding: 6px 10px;
+    width: 50px;
+    padding: 3px 6px;
     background: var(--bg-secondary);
     border: 1px solid var(--border-color);
-    border-radius: 4px;
+    border-radius: 3px;
     color: var(--text-primary);
     font-family: var(--font-mono);
-    font-size: 0.9rem;
+    font-size: 11px;
     text-align: center;
 }
 
-#rate-multiplier:focus {
-    outline: none;
-    border-color: var(--accent-cyan);
-    box-shadow: 0 0 5px rgba(6, 182, 212, 0.3);
+/* Modal */
+.modal {
+    position: fixed;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.7);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 1000;
 }
 
-/* Adjust control panel grid for new column */
-.control-panel {
-    grid-template-columns: 2fr 1.5fr 1fr 1fr;
+.modal.hidden { display: none; }
+
+.modal-content {
+    background: var(--bg-card);
+    padding: 16px;
+    border-radius: 6px;
+    border: 1px solid var(--border-color);
+    min-width: 200px;
+}
+
+.modal-content h3 {
+    font-size: 12px;
+    margin-bottom: 12px;
+}
+
+.node-list {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+    margin-bottom: 12px;
+}
+
+.node-list .btn { width: 100%; text-align: left; }
+
+/* Scrollbar */
+::-webkit-scrollbar { width: 6px; height: 6px; }
+::-webkit-scrollbar-track { background: var(--bg-secondary); }
+::-webkit-scrollbar-thumb { background: var(--border-color); border-radius: 3px; }
+::-webkit-scrollbar-thumb:hover { background: var(--text-muted); }
+
+/* Responsive */
+@media (max-width: 1000px) {
+    .main-grid { grid-template-columns: 1fr; }
+    .control-panel { grid-template-columns: 1fr; gap: 12px; }
 }
diff --git a/pom.xml b/pom.xml
index 584e9418..9caf32ec 100644
--- a/pom.xml
+++ b/pom.xml
@@ -48,7 +48,7 @@
         <netty.version>4.2.0.Final</netty.version>
         <kryo.version>5.6.2</kryo.version>
         <fury-core.version>0.10.2</fury-core.version>
-        <jbct.version>0.3.12</jbct.version>
+        <jbct.version>0.4.0</jbct.version>
     </properties>
 
     <dependencyManagement>
@@ -241,7 +241,7 @@
                     <artifactId>jbct-maven-plugin</artifactId>
                     <version>${jbct.version}</version>
                     <configuration>
-                        <skip>true</skip> <!-- TODO: enable after fixing enum formatting bug -->
+                        <skip>true</skip> <!-- TODO: parse errors on FrameworkClassLoader.java and SharedDependencyLoader.java -->
                     </configuration>
                     <executions>
                         <execution>

From ab6510b1b88f60eb909368c48c62ab03579ab10c Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 13:46:01 +0100
Subject: [PATCH 05/26] build: bump Netty to 4.2.9.Final

---
 pom.xml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/pom.xml b/pom.xml
index 9caf32ec..f244a939 100644
--- a/pom.xml
+++ b/pom.xml
@@ -45,10 +45,10 @@
         <pragmatica.version>0.9.0</pragmatica.version>
         <awaitility.version>4.2.1</awaitility.version>
         <tinylog.version>2.7.0</tinylog.version>
-        <netty.version>4.2.0.Final</netty.version>
+        <netty.version>4.2.9.Final</netty.version>
         <kryo.version>5.6.2</kryo.version>
         <fury-core.version>0.10.2</fury-core.version>
-        <jbct.version>0.4.0</jbct.version>
+        <jbct.version>0.4.2</jbct.version>
     </properties>
 
     <dependencyManagement>
@@ -240,9 +240,6 @@
                     <groupId>org.pragmatica-lite</groupId>
                     <artifactId>jbct-maven-plugin</artifactId>
                     <version>${jbct.version}</version>
-                    <configuration>
-                        <skip>true</skip> <!-- TODO: parse errors on FrameworkClassLoader.java and SharedDependencyLoader.java -->
-                    </configuration>
                     <executions>
                         <execution>
                             <goals>

From 4f957b6ee118d258d3d2f7682ea5308b9998d3b4 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 13:47:58 +0100
Subject: [PATCH 06/26] refactor: use MultiThreadIoEventLoopGroup in
 http-server

---
 .../http/server/impl/NettyHttpServer.java     | 159 +++++++++---------
 1 file changed, 76 insertions(+), 83 deletions(-)

diff --git a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java b/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
index c134e954..7e4554f4 100644
--- a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
+++ b/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
@@ -1,30 +1,32 @@
 package org.pragmatica.http.server.impl;
 
+import org.pragmatica.http.server.HttpServer;
+import org.pragmatica.http.server.HttpServerConfig;
+import org.pragmatica.http.server.HttpServerError;
+import org.pragmatica.http.server.RequestContext;
+import org.pragmatica.http.server.ResponseWriter;
+import org.pragmatica.lang.Option;
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Result;
+import org.pragmatica.lang.Unit;
+
+import java.util.function.BiConsumer;
+
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelOption;
 import io.netty.channel.EventLoopGroup;
-import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.http.HttpObjectAggregator;
 import io.netty.handler.codec.http.HttpServerCodec;
 import io.netty.handler.ssl.SslContext;
-import org.pragmatica.http.server.HttpServer;
-import org.pragmatica.http.server.HttpServerConfig;
-import org.pragmatica.http.server.HttpServerError;
-import org.pragmatica.http.server.RequestContext;
-import org.pragmatica.http.server.ResponseWriter;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.function.BiConsumer;
-
 import static org.pragmatica.lang.Unit.unit;
 
 /**
@@ -41,11 +43,9 @@ public final class NettyHttpServer implements HttpServer {
     private EventLoopGroup workerGroup;
     private Channel serverChannel;
 
-    private NettyHttpServer(
-            HttpServerConfig config,
-            BiConsumer<RequestContext, ResponseWriter> handler,
-            Option<SslContext> sslContext
-    ) {
+    private NettyHttpServer(HttpServerConfig config,
+                            BiConsumer<RequestContext, ResponseWriter> handler,
+                            Option<SslContext> sslContext) {
         this.config = config;
         this.handler = handler;
         this.sslContext = sslContext;
@@ -58,83 +58,76 @@ private NettyHttpServer(
      * @param handler request handler
      * @return server instance or error
      */
-    public static Promise<HttpServer> create(
-            HttpServerConfig config,
-            BiConsumer<RequestContext, ResponseWriter> handler
-    ) {
+    public static Promise<HttpServer> create(HttpServerConfig config,
+                                             BiConsumer<RequestContext, ResponseWriter> handler) {
         Result<Option<SslContext>> sslResult = config.tls()
-                .map(TlsContextFactory::create)
-                .map(result -> result.map(Option::some))
-                .fold(
-                        () -> Result.success(Option.empty()),
-                        result -> result
-                );
-
-        return sslResult
-                .map(ssl -> (HttpServer) new NettyHttpServer(config, handler, ssl))
-                .async();
+                                                     .map(TlsContextFactory::create)
+                                                     .map(result -> result.map(Option::some))
+                                                     .fold(() -> Result.success(Option.empty()),
+                                                           result -> result);
+        return sslResult.map(ssl -> (HttpServer) new NettyHttpServer(config, handler, ssl))
+                        .async();
     }
 
     @Override
     public Promise<Unit> start() {
         return Promise.promise(promise -> {
-            bossGroup = new NioEventLoopGroup(1);
-            workerGroup = new NioEventLoopGroup();
-
-            try {
-                var bootstrap = new ServerBootstrap()
-                        .group(bossGroup, workerGroup)
-                        .channel(NioServerSocketChannel.class)
-                        .childHandler(new ChannelInitializer<SocketChannel>() {
-                            @Override
-                            protected void initChannel(SocketChannel ch) {
-                                var pipeline = ch.pipeline();
-
-                                sslContext.onPresent(ssl -> pipeline.addLast(ssl.newHandler(ch.alloc())));
-
-                                pipeline.addLast(new HttpServerCodec());
-                                pipeline.addLast(new HttpObjectAggregator(config.maxContentLength()));
-                                pipeline.addLast(new HttpRequestHandler(handler));
-                            }
-                        })
-                        .option(ChannelOption.SO_BACKLOG, 128)
-                        .childOption(ChannelOption.SO_KEEPALIVE, true);
-
-                var channelFuture = bootstrap.bind(config.port());
-
-                channelFuture.addListener(future -> {
-                    if (future.isSuccess()) {
-                        serverChannel = channelFuture.channel();
-                        var protocol = sslContext.isPresent() ? "HTTPS" : "HTTP";
-                        LOG.info("{} server started on port {}", protocol, config.port());
-                        promise.succeed(unit());
-                    } else {
-                        cleanup();
-                        promise.fail(new HttpServerError.BindFailed(config.port(), future.cause()));
-                    }
-                });
-            } catch (Exception e) {
-                cleanup();
-                promise.fail(new HttpServerError.BindFailed(config.port(), e));
-            }
-        });
+                                   bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+                                   workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+                                   try{
+                                   var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
+                                                   .channel(NioServerSocketChannel.class)
+                                                   .childHandler(new ChannelInitializer<SocketChannel>() {
+            @Override
+            protected void initChannel(SocketChannel ch) {
+                                                                     var pipeline = ch.pipeline();
+                                                                     sslContext.onPresent(ssl -> pipeline.addLast(ssl.newHandler(ch.alloc())));
+                                                                     pipeline.addLast(new HttpServerCodec());
+                                                                     pipeline.addLast(new HttpObjectAggregator(config.maxContentLength()));
+                                                                     pipeline.addLast(new HttpRequestHandler(handler));
+                                                                 }
+        })
+                                                   .option(ChannelOption.SO_BACKLOG, 128)
+                                                   .childOption(ChannelOption.SO_KEEPALIVE, true);
+                                   var channelFuture = bootstrap.bind(config.port());
+                                   channelFuture.addListener(future -> {
+                                                                 if (future.isSuccess()) {
+                                                                 serverChannel = channelFuture.channel();
+                                                                 var protocol = sslContext.isPresent()
+                                                                                ? "HTTPS"
+                                                                                : "HTTP";
+                                                                 LOG.info("{} server started on port {}",
+                                                                          protocol,
+                                                                          config.port());
+                                                                 promise.succeed(unit());
+                                                             }else {
+                                                                 cleanup();
+                                                                 promise.fail(new HttpServerError.BindFailed(config.port(),
+                                                                                                             future.cause()));
+                                                             }
+                                                             });
+                               } catch (Exception e) {
+                                   cleanup();
+                                   promise.fail(new HttpServerError.BindFailed(config.port(), e));
+                               }
+                               });
     }
 
     @Override
     public Promise<Unit> stop() {
         return Promise.promise(promise -> {
-            LOG.info("Stopping HTTP server on port {}", config.port());
-
-            if (serverChannel != null) {
-                serverChannel.close().addListener(future -> {
-                    cleanup();
-                    promise.succeed(unit());
-                });
-            } else {
-                cleanup();
-                promise.succeed(unit());
-            }
-        });
+                                   LOG.info("Stopping HTTP server on port {}", config.port());
+                                   if (serverChannel != null) {
+                                   serverChannel.close()
+                                                .addListener(future -> {
+                                   cleanup();
+                                   promise.succeed(unit());
+                               });
+                               }else {
+                                   cleanup();
+                                   promise.succeed(unit());
+                               }
+                               });
     }
 
     @Override

From 289f7ac6795744b99441e498ac446b2eb695bbf3 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 13:53:20 +0100
Subject: [PATCH 07/26] refactor: use MultiThreadIoEventLoopGroup in node and
 forge

---
 .../pragmatica/aether/forge/ForgeServer.java  | 135 +++--
 .../aether/api/ManagementServer.java          | 524 ++++++++++--------
 .../pragmatica/aether/http/HttpRouter.java    | 231 ++++----
 3 files changed, 479 insertions(+), 411 deletions(-)

diff --git a/forge/src/main/java/org/pragmatica/aether/forge/ForgeServer.java b/forge/src/main/java/org/pragmatica/aether/forge/ForgeServer.java
index 4e75c2b1..8f12ce32 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/ForgeServer.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/ForgeServer.java
@@ -1,22 +1,24 @@
 package org.pragmatica.aether.forge;
 
+import org.pragmatica.lang.io.TimeSpan;
+
+import java.awt.*;
+import java.net.URI;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.*;
-import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.http.*;
 import io.netty.handler.stream.ChunkedWriteHandler;
-import org.pragmatica.lang.io.TimeSpan;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.awt.*;
-import java.net.URI;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.TimeUnit;
-
 /**
  * Main entry point for Aether Forge.
  * Starts a cluster, load generator, and web dashboard on a single JVM.
@@ -27,8 +29,9 @@ public final class ForgeServer {
     private static final int DEFAULT_PORT = 8888;
     private static final int DEFAULT_CLUSTER_SIZE = 5;
     private static final int DEFAULT_LOAD_RATE = 1000;
-    private static final int MAX_CONTENT_LENGTH = 65536; // 64KB
+    private static final int MAX_CONTENT_LENGTH = 65536;
 
+    // 64KB
     private final int port;
     private final int clusterSize;
     private final int loadRate;
@@ -55,7 +58,6 @@ public static void main(String[] args) {
         var port = getEnvInt("FORGE_PORT", DEFAULT_PORT);
         var clusterSize = getEnvInt("CLUSTER_SIZE", DEFAULT_CLUSTER_SIZE);
         var loadRate = getEnvInt("LOAD_RATE", DEFAULT_LOAD_RATE);
-
         log.info("=".repeat(60));
         log.info("    AETHER FORGE");
         log.info("=".repeat(60));
@@ -63,16 +65,14 @@ public static void main(String[] args) {
         log.info("  Cluster size: {} nodes", clusterSize);
         log.info("  Initial load: {} req/sec", loadRate);
         log.info("=".repeat(60));
-
         var server = new ForgeServer(port, clusterSize, loadRate);
-
         // Handle shutdown gracefully
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            log.info("Shutting down...");
-            server.stop();
-        }));
-
-        try {
+        Runtime.getRuntime()
+               .addShutdownHook(new Thread(() -> {
+                   log.info("Shutting down...");
+                   server.stop();
+               }));
+        try{
             server.start();
         } catch (Exception e) {
             log.error("Failed to start Forge server", e);
@@ -82,7 +82,6 @@ public static void main(String[] args) {
 
     public void start() throws Exception {
         log.info("Starting Forge server...");
-
         // Initialize components
         metrics = ForgeMetrics.forgeMetrics();
         cluster = ForgeCluster.forgeCluster(clusterSize);
@@ -90,106 +89,97 @@ public void start() throws Exception {
         sliceInvoker = LocalSliceInvoker.localSliceInvoker();
         apiHandler = ForgeApiHandler.forgeApiHandler(cluster, loadGenerator, metrics, sliceInvoker);
         staticHandler = StaticFileHandler.staticFileHandler();
-
         log.info("Forge running in standalone mode (no slices loaded)");
-
         // Start the cluster
         log.info("Starting {} node cluster...", clusterSize);
         cluster.start()
-               .await(TimeSpan.timeSpan(60).seconds())
+               .await(TimeSpan.timeSpan(60)
+                              .seconds())
                .onFailure(cause -> {
-                   log.error("Failed to start cluster: {}", cause.message());
-                   throw new RuntimeException("Cluster start failed: " + cause.message());
-               });
-
+                              log.error("Failed to start cluster: {}",
+                                        cause.message());
+                              throw new RuntimeException("Cluster start failed: " + cause.message());
+                          });
         // Wait for cluster to stabilize
         Thread.sleep(2000);
-
         // Start metrics collection
         metricsScheduler = Executors.newSingleThreadScheduledExecutor();
         metricsScheduler.scheduleAtFixedRate(metrics::snapshot, 500, 500, TimeUnit.MILLISECONDS);
-
         // Start load generator
         log.info("Starting load generator at {} req/sec", loadRate);
         loadGenerator.start(loadRate);
-
         // Add initial event
         apiHandler.addEvent("CLUSTER_STARTED", "Forge cluster started with " + clusterSize + " nodes");
-
         // Start HTTP server
         startHttpServer();
-
         // Open browser
         openBrowser("http://localhost:" + port);
-
         log.info("Forge server running. Press Ctrl+C to stop.");
-
         // Keep main thread alive
-        Thread.currentThread().join();
+        Thread.currentThread()
+              .join();
     }
 
     public void stop() {
         log.info("Stopping Forge server...");
-
         if (loadGenerator != null) {
             loadGenerator.stop();
         }
-
         if (metricsScheduler != null) {
             metricsScheduler.shutdownNow();
         }
-
         if (serverChannel != null) {
-            serverChannel.close().syncUninterruptibly();
+            serverChannel.close()
+                         .syncUninterruptibly();
         }
-
         if (workerGroup != null) {
             workerGroup.shutdownGracefully();
         }
-
         if (bossGroup != null) {
             bossGroup.shutdownGracefully();
         }
-
         if (cluster != null) {
             cluster.stop()
-                   .await(TimeSpan.timeSpan(30).seconds())
-                   .onFailure(cause -> log.warn("Error stopping cluster: {}", cause.message()));
+                   .await(TimeSpan.timeSpan(30)
+                                  .seconds())
+                   .onFailure(cause -> log.warn("Error stopping cluster: {}",
+                                                cause.message()));
         }
-
         log.info("Forge server stopped.");
     }
 
     private void startHttpServer() throws InterruptedException {
-        bossGroup = new NioEventLoopGroup(1);
-        workerGroup = new NioEventLoopGroup();
-
+        bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+        workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
         var bootstrap = new ServerBootstrap();
         bootstrap.group(bossGroup, workerGroup)
                  .channel(NioServerSocketChannel.class)
                  .childHandler(new ChannelInitializer<SocketChannel>() {
-                     @Override
-                     protected void initChannel(SocketChannel ch) {
-                         var pipeline = ch.pipeline();
-                         pipeline.addLast(new HttpServerCodec());
-                         pipeline.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
-                         pipeline.addLast(new ChunkedWriteHandler());
-                         pipeline.addLast(new ForgeHttpHandler(apiHandler, staticHandler));
-                     }
-                 })
+            @Override
+            protected void initChannel(SocketChannel ch) {
+                                   var pipeline = ch.pipeline();
+                                   pipeline.addLast(new HttpServerCodec());
+                                   pipeline.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
+                                   pipeline.addLast(new ChunkedWriteHandler());
+                                   pipeline.addLast(new ForgeHttpHandler(apiHandler, staticHandler));
+                               }
+        })
                  .option(ChannelOption.SO_BACKLOG, 128)
                  .childOption(ChannelOption.SO_KEEPALIVE, true);
-
-        serverChannel = bootstrap.bind(port).sync().channel();
+        serverChannel = bootstrap.bind(port)
+                                 .sync()
+                                 .channel();
         log.info("HTTP server started on port {}", port);
     }
 
     private void openBrowser(String url) {
-        try {
-            if (Desktop.isDesktopSupported() && Desktop.getDesktop().isSupported(Desktop.Action.BROWSE)) {
-                Desktop.getDesktop().browse(new URI(url));
+        try{
+            if (Desktop.isDesktopSupported() && Desktop.getDesktop()
+                                                       .isSupported(Desktop.Action.BROWSE)) {
+                Desktop.getDesktop()
+                       .browse(new URI(url));
                 log.info("Opened browser to {}", url);
-            } else {
+            }else {
                 log.info("Could not open browser automatically. Please navigate to: {}", url);
             }
         } catch (Exception e) {
@@ -200,7 +190,7 @@ private void openBrowser(String url) {
     private static int getEnvInt(String name, int defaultValue) {
         var value = System.getenv(name);
         if (value != null) {
-            try {
+            try{
                 return Integer.parseInt(value);
             } catch (NumberFormatException e) {
                 log.warn("Invalid {} value: {}, using default: {}", name, value, defaultValue);
@@ -225,28 +215,31 @@ private static class ForgeHttpHandler extends SimpleChannelInboundHandler<FullHt
         @Override
         protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
             var path = request.uri();
-
             // Handle CORS preflight
             if (request.method() == HttpMethod.OPTIONS) {
                 handleCors(ctx);
                 return;
             }
-
             // Route to appropriate handler
             if (path.startsWith("/api/")) {
                 apiHandler.channelRead(ctx, request.retain());
-            } else {
+            }else {
                 staticHandler.channelRead(ctx, request.retain());
             }
         }
 
         private void handleCors(ChannelHandlerContext ctx) {
             var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
-            response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
-            response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, OPTIONS");
-            response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type");
-            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, 0);
-            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+            response.headers()
+                    .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
+            response.headers()
+                    .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, OPTIONS");
+            response.headers()
+                    .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type");
+            response.headers()
+                    .set(HttpHeaderNames.CONTENT_LENGTH, 0);
+            ctx.writeAndFlush(response)
+               .addListener(ChannelFutureListener.CLOSE);
         }
 
         @Override
diff --git a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
index c9880bf5..d690ed0d 100644
--- a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
+++ b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
@@ -1,5 +1,22 @@
 package org.pragmatica.aether.api;
 
+import org.pragmatica.aether.artifact.Artifact;
+import org.pragmatica.aether.node.AetherNode;
+import org.pragmatica.aether.slice.blueprint.BlueprintParser;
+import org.pragmatica.aether.slice.kvstore.AetherKey;
+import org.pragmatica.aether.slice.kvstore.AetherValue;
+import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.cluster.state.kvstore.KVCommand;
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.lang.utils.Causes;
+
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.Channel;
@@ -8,7 +25,8 @@
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.http.DefaultFullHttpResponse;
@@ -22,25 +40,9 @@
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
 import io.netty.util.CharsetUtil;
-import org.pragmatica.aether.artifact.Artifact;
-import org.pragmatica.aether.node.AetherNode;
-import org.pragmatica.aether.slice.blueprint.BlueprintParser;
-import org.pragmatica.aether.slice.kvstore.AetherKey;
-import org.pragmatica.aether.slice.kvstore.AetherValue;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.state.kvstore.KVCommand;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.utils.Causes;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.InputStream;
-import java.nio.charset.StandardCharsets;
-import java.util.List;
-import java.util.function.Supplier;
-import java.util.regex.Pattern;
-
 import static org.pragmatica.lang.Unit.unit;
 
 /**
@@ -55,7 +57,6 @@
  * </ul>
  */
 public interface ManagementServer {
-
     Promise<Unit> start();
 
     Promise<Unit> stop();
@@ -66,14 +67,14 @@ static ManagementServer managementServer(int port, Supplier<AetherNode> nodeSupp
 }
 
 class ManagementServerImpl implements ManagementServer {
-
     private static final Logger log = LoggerFactory.getLogger(ManagementServerImpl.class);
-    private static final int MAX_CONTENT_LENGTH = 64 * 1024 * 1024; // 64MB for artifact uploads
+    private static final int MAX_CONTENT_LENGTH = 64 * 1024 * 1024;
 
+    // 64MB for artifact uploads
     private final int port;
     private final Supplier<AetherNode> nodeSupplier;
-    private final NioEventLoopGroup bossGroup;
-    private final NioEventLoopGroup workerGroup;
+    private final MultiThreadIoEventLoopGroup bossGroup;
+    private final MultiThreadIoEventLoopGroup workerGroup;
     private final AlertManager alertManager;
     private final DashboardMetricsPublisher metricsPublisher;
     private Channel serverChannel;
@@ -81,8 +82,8 @@ class ManagementServerImpl implements ManagementServer {
     ManagementServerImpl(int port, Supplier<AetherNode> nodeSupplier) {
         this.port = port;
         this.nodeSupplier = nodeSupplier;
-        this.bossGroup = new NioEventLoopGroup(1);
-        this.workerGroup = new NioEventLoopGroup();
+        this.bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+        this.workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
         this.alertManager = new AlertManager();
         this.metricsPublisher = new DashboardMetricsPublisher(nodeSupplier, alertManager);
     }
@@ -90,57 +91,62 @@ class ManagementServerImpl implements ManagementServer {
     @Override
     public Promise<Unit> start() {
         return Promise.promise(promise -> {
-            var bootstrap = new ServerBootstrap()
-                    .group(bossGroup, workerGroup)
-                    .channel(NioServerSocketChannel.class)
-                    .childHandler(new ChannelInitializer<SocketChannel>() {
-                        @Override
-                        protected void initChannel(SocketChannel ch) {
-                            ChannelPipeline p = ch.pipeline();
-                            p.addLast(new HttpServerCodec());
-                            p.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
-                            p.addLast(new WebSocketServerProtocolHandler("/ws/dashboard", null, true));
-                            p.addLast(new DashboardWebSocketHandler(metricsPublisher));
-                            p.addLast(new HttpRequestHandler(nodeSupplier, alertManager));
-                        }
-                    });
-
-            bootstrap.bind(port).addListener(future -> {
-                if (future.isSuccess()) {
-                    serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
-                    metricsPublisher.start();
-                    log.info("Management server started on port {} (dashboard at /dashboard)", port);
-                    promise.succeed(unit());
-                } else {
-                    log.error("Failed to start management server on port {}", port, future.cause());
-                    promise.fail(Causes.fromThrowable(future.cause()));
-                }
-            });
+                                   var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
+                                                   .channel(NioServerSocketChannel.class)
+                                                   .childHandler(new ChannelInitializer<SocketChannel>() {
+            @Override
+            protected void initChannel(SocketChannel ch) {
+                                                                     ChannelPipeline p = ch.pipeline();
+                                                                     p.addLast(new HttpServerCodec());
+                                                                     p.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
+                                                                     p.addLast(new WebSocketServerProtocolHandler("/ws/dashboard",
+                                                                                                                  null,
+                                                                                                                  true));
+                                                                     p.addLast(new DashboardWebSocketHandler(metricsPublisher));
+                                                                     p.addLast(new HttpRequestHandler(nodeSupplier,
+                                                                                                      alertManager));
+                                                                 }
         });
+                                   bootstrap.bind(port)
+                                            .addListener(future -> {
+                                                             if (future.isSuccess()) {
+                                                             serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
+                                                             metricsPublisher.start();
+                                                             log.info("Management server started on port {} (dashboard at /dashboard)",
+                                                                      port);
+                                                             promise.succeed(unit());
+                                                         }else {
+                                                             log.error("Failed to start management server on port {}",
+                                                                       port,
+                                                                       future.cause());
+                                                             promise.fail(Causes.fromThrowable(future.cause()));
+                                                         }
+                                                         });
+                               });
     }
 
     @Override
     public Promise<Unit> stop() {
         return Promise.promise(promise -> {
-            metricsPublisher.stop();
-            if (serverChannel != null) {
-                serverChannel.close().addListener(f -> {
-                    bossGroup.shutdownGracefully();
-                    workerGroup.shutdownGracefully();
-                    log.info("Management server stopped");
-                    promise.succeed(unit());
-                });
-            } else {
-                bossGroup.shutdownGracefully();
-                workerGroup.shutdownGracefully();
-                promise.succeed(unit());
-            }
-        });
+                                   metricsPublisher.stop();
+                                   if (serverChannel != null) {
+                                   serverChannel.close()
+                                                .addListener(f -> {
+                                                                 bossGroup.shutdownGracefully();
+                                                                 workerGroup.shutdownGracefully();
+                                                                 log.info("Management server stopped");
+                                                                 promise.succeed(unit());
+                                                             });
+                               }else {
+                                   bossGroup.shutdownGracefully();
+                                   workerGroup.shutdownGracefully();
+                                   promise.succeed(unit());
+                               }
+                               });
     }
 }
 
 class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
-
     private static final Logger log = LoggerFactory.getLogger(HttpRequestHandler.class);
     private static final String CONTENT_TYPE_JSON = "application/json";
     private static final String CONTENT_TYPE_HTML = "text/html; charset=UTF-8";
@@ -157,29 +163,26 @@ class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
 
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
-        if (!request.decoderResult().isSuccess()) {
+        if (!request.decoderResult()
+                    .isSuccess()) {
             sendError(ctx, HttpResponseStatus.BAD_REQUEST);
             return;
         }
-
         var method = request.method();
         var uri = request.uri();
-
         log.debug("Received {} {}", method, uri);
-
         if (method == HttpMethod.GET) {
             handleGet(ctx, uri);
-        } else if (method == HttpMethod.POST || method == HttpMethod.PUT) {
+        }else if (method == HttpMethod.POST || method == HttpMethod.PUT) {
             // Handle both POST and PUT for repository uploads (Maven uses PUT)
             handlePost(ctx, uri, request);
-        } else {
+        }else {
             sendError(ctx, HttpResponseStatus.METHOD_NOT_ALLOWED);
         }
     }
 
     private void handleGet(ChannelHandlerContext ctx, String uri) {
         var node = nodeSupplier.get();
-
         // Handle dashboard static files
         if (uri.equals("/dashboard") || uri.equals("/dashboard/")) {
             serveDashboardFile(ctx, "index.html", CONTENT_TYPE_HTML);
@@ -189,35 +192,33 @@ private void handleGet(ChannelHandlerContext ctx, String uri) {
             serveDashboardFile(ctx, "style.css", CONTENT_TYPE_CSS);
             return;
         }
-
         // Handle repository requests
         if (uri.startsWith("/repository/")) {
             handleRepositoryGet(ctx, node, uri);
             return;
         }
-
         var response = switch (uri) {
-            case "/status" -> buildStatusResponse(node);
-            case "/nodes" -> buildNodesResponse(node);
-            case "/slices" -> buildSlicesResponse(node);
-            case "/slices/status" -> buildSlicesStatusResponse(node);
-            case "/metrics" -> buildMetricsResponse(node);
-            case "/invocation-metrics" -> buildInvocationMetricsResponse(node);
-            case "/thresholds" -> alertManager.thresholdsAsJson();
-            case "/alerts" -> buildAlertsResponse();
-            case "/health" -> "{\"status\":\"ok\"}";
+            case"/status" -> buildStatusResponse(node);
+            case"/nodes" -> buildNodesResponse(node);
+            case"/slices" -> buildSlicesResponse(node);
+            case"/slices/status" -> buildSlicesStatusResponse(node);
+            case"/metrics" -> buildMetricsResponse(node);
+            case"/invocation-metrics" -> buildInvocationMetricsResponse(node);
+            case"/thresholds" -> alertManager.thresholdsAsJson();
+            case"/alerts" -> buildAlertsResponse();
+            case"/health" -> "{\"status\":\"ok\"}";
             default -> null;
         };
-
         if (response != null) {
             sendJson(ctx, response);
-        } else {
+        }else {
             sendError(ctx, HttpResponseStatus.NOT_FOUND);
         }
     }
 
     private void serveDashboardFile(ChannelHandlerContext ctx, String filename, String contentType) {
-        try (InputStream is = getClass().getResourceAsStream("/dashboard/" + filename)) {
+        try (InputStream is = getClass()
+                              .getResourceAsStream("/dashboard/" + filename)) {
             if (is == null) {
                 sendError(ctx, HttpResponseStatus.NOT_FOUND);
                 return;
@@ -225,10 +226,15 @@ private void serveDashboardFile(ChannelHandlerContext ctx, String filename, Stri
             var content = new String(is.readAllBytes(), StandardCharsets.UTF_8);
             var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
             var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
-            response.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType);
-            response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, buf.readableBytes());
-            response.headers().set(HttpHeaderNames.CACHE_CONTROL, "no-cache");
-            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+            response.headers()
+                    .set(HttpHeaderNames.CONTENT_TYPE, contentType);
+            response.headers()
+                    .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                            buf.readableBytes());
+            response.headers()
+                    .set(HttpHeaderNames.CACHE_CONTROL, "no-cache");
+            ctx.writeAndFlush(response)
+               .addListener(ChannelFutureListener.CLOSE);
         } catch (Exception e) {
             log.error("Error serving dashboard file: {}", filename, e);
             sendError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR);
@@ -236,36 +242,43 @@ private void serveDashboardFile(ChannelHandlerContext ctx, String filename, Stri
     }
 
     private void handleRepositoryGet(ChannelHandlerContext ctx, AetherNode node, String uri) {
-        node.mavenProtocolHandler().handleGet(uri)
+        node.mavenProtocolHandler()
+            .handleGet(uri)
             .onSuccess(response -> {
-                var httpStatus = HttpResponseStatus.valueOf(response.statusCode());
-                var httpResponse = new DefaultFullHttpResponse(
-                        HttpVersion.HTTP_1_1, httpStatus,
-                        Unpooled.wrappedBuffer(response.content())
-                );
-                httpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE, response.contentType());
-                httpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().length);
-                ctx.writeAndFlush(httpResponse).addListener(ChannelFutureListener.CLOSE);
-            })
-            .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
+                           var httpStatus = HttpResponseStatus.valueOf(response.statusCode());
+                           var httpResponse = new DefaultFullHttpResponse(
+        HttpVersion.HTTP_1_1,
+        httpStatus,
+        Unpooled.wrappedBuffer(response.content()));
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_TYPE,
+                                            response.contentType());
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_LENGTH,
+                                            response.content().length);
+                           ctx.writeAndFlush(httpResponse)
+                              .addListener(ChannelFutureListener.CLOSE);
+                       })
+            .onFailure(cause -> sendJsonError(ctx,
+                                              HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                              cause.message()));
     }
 
     private void handlePost(ChannelHandlerContext ctx, String uri, FullHttpRequest request) {
         var node = nodeSupplier.get();
-
         // Handle repository PUT requests (binary content)
         if (uri.startsWith("/repository/")) {
             handleRepositoryPut(ctx, node, uri, request);
             return;
         }
-
         // For other endpoints, read as string
-        var body = request.content().toString(CharsetUtil.UTF_8);
+        var body = request.content()
+                          .toString(CharsetUtil.UTF_8);
         switch (uri) {
-            case "/deploy" -> handleDeploy(ctx, node, body);
-            case "/scale" -> handleScale(ctx, node, body);
-            case "/undeploy" -> handleUndeploy(ctx, node, body);
-            case "/blueprint" -> handleBlueprint(ctx, node, body);
+            case"/deploy" -> handleDeploy(ctx, node, body);
+            case"/scale" -> handleScale(ctx, node, body);
+            case"/undeploy" -> handleUndeploy(ctx, node, body);
+            case"/blueprint" -> handleBlueprint(ctx, node, body);
             default -> sendError(ctx, HttpResponseStatus.NOT_FOUND);
         }
     }
@@ -275,19 +288,26 @@ private void handleRepositoryPut(ChannelHandlerContext ctx, AetherNode node, Str
         var byteBuf = request.content();
         var content = new byte[byteBuf.readableBytes()];
         byteBuf.readBytes(content);
-
-        node.mavenProtocolHandler().handlePut(uri, content)
+        node.mavenProtocolHandler()
+            .handlePut(uri, content)
             .onSuccess(response -> {
-                var httpStatus = HttpResponseStatus.valueOf(response.statusCode());
-                var httpResponse = new DefaultFullHttpResponse(
-                        HttpVersion.HTTP_1_1, httpStatus,
-                        Unpooled.wrappedBuffer(response.content())
-                );
-                httpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE, response.contentType());
-                httpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().length);
-                ctx.writeAndFlush(httpResponse).addListener(ChannelFutureListener.CLOSE);
-            })
-            .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
+                           var httpStatus = HttpResponseStatus.valueOf(response.statusCode());
+                           var httpResponse = new DefaultFullHttpResponse(
+        HttpVersion.HTTP_1_1,
+        httpStatus,
+        Unpooled.wrappedBuffer(response.content()));
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_TYPE,
+                                            response.contentType());
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_LENGTH,
+                                            response.content().length);
+                           ctx.writeAndFlush(httpResponse)
+                              .addListener(ChannelFutureListener.CLOSE);
+                       })
+            .onFailure(cause -> sendJsonError(ctx,
+                                              HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                              cause.message()));
     }
 
     // Simple JSON parsing helpers
@@ -298,142 +318,163 @@ private void handleDeploy(ChannelHandlerContext ctx, AetherNode node, String bod
         // Parse: {"artifact": "group:id:version", "instances": 1}
         var artifactMatch = ARTIFACT_PATTERN.matcher(body);
         var instancesMatch = INSTANCES_PATTERN.matcher(body);
-
         if (!artifactMatch.find()) {
             sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, "Missing 'artifact' field");
             return;
         }
-
         int instances = 1;
         if (instancesMatch.find()) {
             instances = Integer.parseInt(instancesMatch.group(1));
         }
-
         var artifactStr = artifactMatch.group(1);
         int finalInstances = instances;
         Artifact.artifact(artifactStr)
                 .onSuccess(artifact -> {
-                    AetherKey key = new AetherKey.BlueprintKey(artifact);
-                    AetherValue value = new AetherValue.BlueprintValue(finalInstances);
-                    KVCommand<AetherKey> command = new KVCommand.Put<>(key, value);
-
-                    node.apply(List.of(command))
-                        .onSuccess(_ -> sendJson(ctx, "{\"status\":\"deployed\",\"artifact\":\"" + artifactStr + "\",\"instances\":" + finalInstances + "}"))
-                        .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
-                })
-                .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, cause.message()));
+                               AetherKey key = new AetherKey.BlueprintKey(artifact);
+                               AetherValue value = new AetherValue.BlueprintValue(finalInstances);
+                               KVCommand<AetherKey> command = new KVCommand.Put<>(key, value);
+                               node.apply(List.of(command))
+                                   .onSuccess(_ -> sendJson(ctx,
+                                                            "{\"status\":\"deployed\",\"artifact\":\"" + artifactStr
+                                                            + "\",\"instances\":" + finalInstances + "}"))
+                                   .onFailure(cause -> sendJsonError(ctx,
+                                                                     HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                                                     cause.message()));
+                           })
+                .onFailure(cause -> sendJsonError(ctx,
+                                                  HttpResponseStatus.BAD_REQUEST,
+                                                  cause.message()));
     }
 
     private void handleScale(ChannelHandlerContext ctx, AetherNode node, String body) {
         // Parse: {"artifact": "group:id:version", "instances": N}
         var artifactMatch = ARTIFACT_PATTERN.matcher(body);
         var instancesMatch = INSTANCES_PATTERN.matcher(body);
-
         if (!artifactMatch.find() || !instancesMatch.find()) {
             sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, "Missing 'artifact' or 'instances' field");
             return;
         }
-
         var artifactStr = artifactMatch.group(1);
         var instances = Integer.parseInt(instancesMatch.group(1));
-
         Artifact.artifact(artifactStr)
                 .onSuccess(artifact -> {
-                    AetherKey key = new AetherKey.BlueprintKey(artifact);
-                    AetherValue value = new AetherValue.BlueprintValue(instances);
-                    KVCommand<AetherKey> command = new KVCommand.Put<>(key, value);
-
-                    node.apply(List.of(command))
-                        .onSuccess(_ -> sendJson(ctx, "{\"status\":\"scaled\",\"artifact\":\"" + artifactStr + "\",\"instances\":" + instances + "}"))
-                        .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
-                })
-                .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, cause.message()));
+                               AetherKey key = new AetherKey.BlueprintKey(artifact);
+                               AetherValue value = new AetherValue.BlueprintValue(instances);
+                               KVCommand<AetherKey> command = new KVCommand.Put<>(key, value);
+                               node.apply(List.of(command))
+                                   .onSuccess(_ -> sendJson(ctx,
+                                                            "{\"status\":\"scaled\",\"artifact\":\"" + artifactStr
+                                                            + "\",\"instances\":" + instances + "}"))
+                                   .onFailure(cause -> sendJsonError(ctx,
+                                                                     HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                                                     cause.message()));
+                           })
+                .onFailure(cause -> sendJsonError(ctx,
+                                                  HttpResponseStatus.BAD_REQUEST,
+                                                  cause.message()));
     }
 
     private void handleUndeploy(ChannelHandlerContext ctx, AetherNode node, String body) {
         // Parse: {"artifact": "group:id:version"}
         var artifactMatch = ARTIFACT_PATTERN.matcher(body);
-
         if (!artifactMatch.find()) {
             sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, "Missing 'artifact' field");
             return;
         }
-
         var artifactStr = artifactMatch.group(1);
-
         Artifact.artifact(artifactStr)
                 .onSuccess(artifact -> {
-                    AetherKey key = new AetherKey.BlueprintKey(artifact);
-                    KVCommand<AetherKey> command = new KVCommand.Remove<>(key);
-
-                    node.apply(List.of(command))
-                        .onSuccess(_ -> sendJson(ctx, "{\"status\":\"undeployed\",\"artifact\":\"" + artifactStr + "\"}"))
-                        .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
-                })
-                .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, cause.message()));
+                               AetherKey key = new AetherKey.BlueprintKey(artifact);
+                               KVCommand<AetherKey> command = new KVCommand.Remove<>(key);
+                               node.apply(List.of(command))
+                                   .onSuccess(_ -> sendJson(ctx,
+                                                            "{\"status\":\"undeployed\",\"artifact\":\"" + artifactStr
+                                                            + "\"}"))
+                                   .onFailure(cause -> sendJsonError(ctx,
+                                                                     HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                                                     cause.message()));
+                           })
+                .onFailure(cause -> sendJsonError(ctx,
+                                                  HttpResponseStatus.BAD_REQUEST,
+                                                  cause.message()));
     }
 
     private void handleBlueprint(ChannelHandlerContext ctx, AetherNode node, String body) {
         BlueprintParser.parse(body)
                        .onSuccess(blueprint -> {
-                           // Build commands for all slices in blueprint
-                           var commands = blueprint.slices().stream()
-                                                   .map(spec -> {
-                                                       AetherKey key = new AetherKey.BlueprintKey(spec.artifact());
-                                                       AetherValue value = new AetherValue.BlueprintValue(spec.instances());
-                                                       return (KVCommand<AetherKey>) new KVCommand.Put<>(key, value);
-                                                   })
-                                                   .toList();
-
-                           if (commands.isEmpty()) {
-                               sendJson(ctx, "{\"status\":\"applied\",\"blueprint\":\"" + blueprint.id().asString() + "\",\"slices\":0}");
-                               return;
-                           }
-
-                           node.apply(commands)
-                               .onSuccess(_ -> sendJson(ctx, "{\"status\":\"applied\",\"blueprint\":\"" + blueprint.id().asString() + "\",\"slices\":" + commands.size() + "}"))
-                               .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, cause.message()));
-                       })
-                       .onFailure(cause -> sendJsonError(ctx, HttpResponseStatus.BAD_REQUEST, cause.message()));
+                                      // Build commands for all slices in blueprint
+        var commands = blueprint.slices()
+                                .stream()
+                                .map(spec -> {
+                                         AetherKey key = new AetherKey.BlueprintKey(spec.artifact());
+                                         AetherValue value = new AetherValue.BlueprintValue(spec.instances());
+                                         return (KVCommand<AetherKey>) new KVCommand.Put<>(key, value);
+                                     })
+                                .toList();
+                                      if (commands.isEmpty()) {
+                                      sendJson(ctx,
+                                               "{\"status\":\"applied\",\"blueprint\":\"" + blueprint.id()
+                                                                                                     .asString()
+                                               + "\",\"slices\":0}");
+                                      return;
+                                  }
+                                      node.apply(commands)
+                                          .onSuccess(_ -> sendJson(ctx,
+                                                                   "{\"status\":\"applied\",\"blueprint\":\"" + blueprint.id()
+                                                                                                                         .asString()
+                                                                   + "\",\"slices\":" + commands.size() + "}"))
+                                          .onFailure(cause -> sendJsonError(ctx,
+                                                                            HttpResponseStatus.INTERNAL_SERVER_ERROR,
+                                                                            cause.message()));
+                                  })
+                       .onFailure(cause -> sendJsonError(ctx,
+                                                         HttpResponseStatus.BAD_REQUEST,
+                                                         cause.message()));
     }
 
     private String buildStatusResponse(AetherNode node) {
         var sb = new StringBuilder();
         sb.append("{");
-        sb.append("\"nodeId\":\"").append(node.self().id()).append("\",");
+        sb.append("\"nodeId\":\"")
+          .append(node.self()
+                      .id())
+          .append("\",");
         sb.append("\"status\":\"running\"");
         sb.append("}");
         return sb.toString();
     }
 
     private String buildNodesResponse(AetherNode node) {
-        var metrics = node.metricsCollector().allMetrics();
+        var metrics = node.metricsCollector()
+                          .allMetrics();
         var sb = new StringBuilder();
         sb.append("{\"nodes\":[");
-
         boolean first = true;
         for (NodeId nodeId : metrics.keySet()) {
             if (!first) sb.append(",");
-            sb.append("\"").append(nodeId.id()).append("\"");
+            sb.append("\"")
+              .append(nodeId.id())
+              .append("\"");
             first = false;
         }
-
         sb.append("]}");
         return sb.toString();
     }
 
     private String buildSlicesResponse(AetherNode node) {
-        var slices = node.sliceStore().loaded();
+        var slices = node.sliceStore()
+                         .loaded();
         var sb = new StringBuilder();
         sb.append("{\"slices\":[");
-
         boolean first = true;
         for (var slice : slices) {
             if (!first) sb.append(",");
-            sb.append("\"").append(slice.artifact().asString()).append("\"");
+            sb.append("\"")
+              .append(slice.artifact()
+                           .asString())
+              .append("\"");
             first = false;
         }
-
         sb.append("]}");
         return sb.toString();
     }
@@ -441,65 +482,84 @@ private String buildSlicesResponse(AetherNode node) {
     private String buildMetricsResponse(AetherNode node) {
         var sb = new StringBuilder();
         sb.append("{");
-
         // Load metrics section
         sb.append("\"load\":{");
-        var allMetrics = node.metricsCollector().allMetrics();
+        var allMetrics = node.metricsCollector()
+                             .allMetrics();
         boolean firstNode = true;
         for (var entry : allMetrics.entrySet()) {
             if (!firstNode) sb.append(",");
-            sb.append("\"").append(entry.getKey().id()).append("\":{");
-
+            sb.append("\"")
+              .append(entry.getKey()
+                           .id())
+              .append("\":{");
             boolean firstMetric = true;
-            for (var metric : entry.getValue().entrySet()) {
+            for (var metric : entry.getValue()
+                                   .entrySet()) {
                 if (!firstMetric) sb.append(",");
-                sb.append("\"").append(metric.getKey()).append("\":").append(metric.getValue());
+                sb.append("\"")
+                  .append(metric.getKey())
+                  .append("\":")
+                  .append(metric.getValue());
                 firstMetric = false;
             }
-
             sb.append("}");
             firstNode = false;
         }
         sb.append("},");
-
         // Deployment metrics section
         sb.append("\"deployments\":{");
-        var deploymentMetrics = node.deploymentMetricsCollector().allDeploymentMetrics();
+        var deploymentMetrics = node.deploymentMetricsCollector()
+                                    .allDeploymentMetrics();
         boolean firstArtifact = true;
         for (var entry : deploymentMetrics.entrySet()) {
             if (!firstArtifact) sb.append(",");
-            sb.append("\"").append(entry.getKey().asString()).append("\":[");
-
+            sb.append("\"")
+              .append(entry.getKey()
+                           .asString())
+              .append("\":[");
             boolean firstDeployment = true;
             for (var metrics : entry.getValue()) {
                 if (!firstDeployment) sb.append(",");
                 sb.append("{");
-                sb.append("\"nodeId\":\"").append(metrics.nodeId().id()).append("\",");
-                sb.append("\"status\":\"").append(metrics.status().name()).append("\",");
-                sb.append("\"fullDeploymentMs\":").append(metrics.fullDeploymentTime()).append(",");
-                sb.append("\"netDeploymentMs\":").append(metrics.netDeploymentTime()).append(",");
+                sb.append("\"nodeId\":\"")
+                  .append(metrics.nodeId()
+                                 .id())
+                  .append("\",");
+                sb.append("\"status\":\"")
+                  .append(metrics.status()
+                                 .name())
+                  .append("\",");
+                sb.append("\"fullDeploymentMs\":")
+                  .append(metrics.fullDeploymentTime())
+                  .append(",");
+                sb.append("\"netDeploymentMs\":")
+                  .append(metrics.netDeploymentTime())
+                  .append(",");
                 sb.append("\"transitions\":{");
-
                 var latencies = metrics.transitionLatencies();
                 boolean firstLatency = true;
                 for (var latency : latencies.entrySet()) {
                     if (!firstLatency) sb.append(",");
-                    sb.append("\"").append(latency.getKey()).append("\":").append(latency.getValue());
+                    sb.append("\"")
+                      .append(latency.getKey())
+                      .append("\":")
+                      .append(latency.getValue());
                     firstLatency = false;
                 }
-
                 sb.append("},");
-                sb.append("\"startTime\":").append(metrics.startTime()).append(",");
-                sb.append("\"activeTime\":").append(metrics.activeTime());
+                sb.append("\"startTime\":")
+                  .append(metrics.startTime())
+                  .append(",");
+                sb.append("\"activeTime\":")
+                  .append(metrics.activeTime());
                 sb.append("}");
                 firstDeployment = false;
             }
-
             sb.append("]");
             firstArtifact = false;
         }
         sb.append("}");
-
         sb.append("}");
         return sb.toString();
     }
@@ -507,23 +567,29 @@ private String buildMetricsResponse(AetherNode node) {
     private String buildSlicesStatusResponse(AetherNode node) {
         var sb = new StringBuilder();
         sb.append("{\"slices\":[");
-
-        var slices = node.sliceStore().loaded();
+        var slices = node.sliceStore()
+                         .loaded();
         boolean first = true;
         for (var slice : slices) {
             if (!first) sb.append(",");
             sb.append("{");
-            sb.append("\"artifact\":\"").append(slice.artifact().asString()).append("\",");
-            sb.append("\"state\":\"ACTIVE\","); // TODO: get actual state from kvstore
+            sb.append("\"artifact\":\"")
+              .append(slice.artifact()
+                           .asString())
+              .append("\",");
+            sb.append("\"state\":\"ACTIVE\",");
+            // TODO: get actual state from kvstore
             sb.append("\"instances\":[{");
-            sb.append("\"nodeId\":\"").append(node.self().id()).append("\",");
+            sb.append("\"nodeId\":\"")
+              .append(node.self()
+                          .id())
+              .append("\",");
             sb.append("\"state\":\"ACTIVE\",");
             sb.append("\"health\":\"HEALTHY\"");
             sb.append("}]");
             sb.append("}");
             first = false;
         }
-
         sb.append("]}");
         return sb.toString();
     }
@@ -534,34 +600,48 @@ private String buildInvocationMetricsResponse(AetherNode node) {
     }
 
     private String buildAlertsResponse() {
-        return "{\"active\":" + alertManager.activeAlertsAsJson() + ",\"history\":" + alertManager.alertHistoryAsJson() + "}";
+        return "{\"active\":" + alertManager.activeAlertsAsJson() + ",\"history\":" + alertManager.alertHistoryAsJson()
+               + "}";
     }
 
     private void sendJson(ChannelHandlerContext ctx, String content) {
         var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, buf.readableBytes());
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
+        response.headers()
+                .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                        buf.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
         var content = "{\"error\":\"" + status.reasonPhrase() + "\"}";
         var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, buf);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, buf.readableBytes());
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
+        response.headers()
+                .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                        buf.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     private void sendJsonError(ChannelHandlerContext ctx, HttpResponseStatus status, String message) {
-        var escapedMessage = message.replace("\"", "\\\"").replace("\n", "\\n");
+        var escapedMessage = message.replace("\"", "\\\"")
+                                    .replace("\n", "\\n");
         var content = "{\"error\":\"" + escapedMessage + "\"}";
         var buf = Unpooled.copiedBuffer(content, CharsetUtil.UTF_8);
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, buf);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, buf.readableBytes());
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
+        response.headers()
+                .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                        buf.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     @Override
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
index dd410d4f..55b599b0 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
@@ -1,12 +1,22 @@
 package org.pragmatica.aether.http;
 
+import org.pragmatica.aether.invoke.SliceInvoker;
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.lang.utils.Causes;
+import org.pragmatica.net.serialization.Deserializer;
+import org.pragmatica.net.serialization.Serializer;
+
+import java.util.HashMap;
+
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
 import io.netty.channel.socket.SocketChannel;
 import io.netty.channel.socket.nio.NioServerSocketChannel;
 import io.netty.handler.codec.http.FullHttpRequest;
@@ -14,17 +24,9 @@
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpServerCodec;
 import io.netty.handler.codec.http.QueryStringDecoder;
-import org.pragmatica.aether.invoke.SliceInvoker;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.HashMap;
-
 import static org.pragmatica.lang.Unit.unit;
 
 /**
@@ -32,7 +34,6 @@
  * Routes are dynamically registered via RouteRegistry when slices activate.
  */
 public interface HttpRouter {
-
     /**
      * Start the HTTP router.
      */
@@ -46,20 +47,17 @@ public interface HttpRouter {
     /**
      * Create an HTTP router with dynamic route registry.
      */
-    static HttpRouter httpRouter(
-            RouterConfig config,
-            RouteRegistry routeRegistry,
-            SliceInvoker invoker,
-            SliceDispatcher.ArtifactResolver artifactResolver,
-            Serializer serializer,
-            Deserializer deserializer
-    ) {
+    static HttpRouter httpRouter(RouterConfig config,
+                                 RouteRegistry routeRegistry,
+                                 SliceInvoker invoker,
+                                 SliceDispatcher.ArtifactResolver artifactResolver,
+                                 Serializer serializer,
+                                 Deserializer deserializer) {
         return new HttpRouterImpl(config, routeRegistry, invoker, artifactResolver, serializer, deserializer);
     }
 }
 
 class HttpRouterImpl implements HttpRouter {
-
     private static final Logger log = LoggerFactory.getLogger(HttpRouterImpl.class);
 
     private final RouterConfig config;
@@ -67,79 +65,78 @@ class HttpRouterImpl implements HttpRouter {
     private final BindingResolver bindingResolver;
     private final SliceDispatcher dispatcher;
     private final ResponseWriter responseWriter;
-    private final NioEventLoopGroup bossGroup;
-    private final NioEventLoopGroup workerGroup;
+    private final MultiThreadIoEventLoopGroup bossGroup;
+    private final MultiThreadIoEventLoopGroup workerGroup;
     private Channel serverChannel;
 
-    HttpRouterImpl(
-            RouterConfig config,
-            RouteRegistry routeRegistry,
-            SliceInvoker invoker,
-            SliceDispatcher.ArtifactResolver artifactResolver,
-            Serializer serializer,
-            Deserializer deserializer
-    ) {
+    HttpRouterImpl(RouterConfig config,
+                   RouteRegistry routeRegistry,
+                   SliceInvoker invoker,
+                   SliceDispatcher.ArtifactResolver artifactResolver,
+                   Serializer serializer,
+                   Deserializer deserializer) {
         this.config = config;
         this.routeRegistry = routeRegistry;
         this.bindingResolver = BindingResolver.bindingResolver(deserializer);
         this.dispatcher = SliceDispatcher.sliceDispatcher(invoker, artifactResolver);
         this.responseWriter = ResponseWriter.responseWriter(serializer);
-        this.bossGroup = new NioEventLoopGroup(1);
-        this.workerGroup = new NioEventLoopGroup();
+        this.bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+        this.workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
     }
 
     @Override
     public Promise<Unit> start() {
         return Promise.promise(promise -> {
-            var bootstrap = new ServerBootstrap()
-                    .group(bossGroup, workerGroup)
-                    .channel(NioServerSocketChannel.class)
-                    .childHandler(new ChannelInitializer<SocketChannel>() {
-                        @Override
-                        protected void initChannel(SocketChannel ch) {
-                            ChannelPipeline p = ch.pipeline();
-                            p.addLast(new HttpServerCodec());
-                            p.addLast(new HttpObjectAggregator(config.maxContentLength()));
-                            p.addLast(new HttpRequestHandler(
-                                    routeRegistry, bindingResolver, dispatcher, responseWriter
-                            ));
-                        }
-                    });
-
-            bootstrap.bind(config.port()).addListener(future -> {
-                if (future.isSuccess()) {
-                    serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
-                    log.info("HTTP router started on port {}", config.port());
-                    promise.succeed(unit());
-                } else {
-                    log.error("Failed to start HTTP router on port {}", config.port(), future.cause());
-                    promise.fail(Causes.fromThrowable(future.cause()));
-                }
-            });
+                                   var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
+                                                   .channel(NioServerSocketChannel.class)
+                                                   .childHandler(new ChannelInitializer<SocketChannel>() {
+            @Override
+            protected void initChannel(SocketChannel ch) {
+                                                                     ChannelPipeline p = ch.pipeline();
+                                                                     p.addLast(new HttpServerCodec());
+                                                                     p.addLast(new HttpObjectAggregator(config.maxContentLength()));
+                                                                     p.addLast(new HttpRequestHandler(
+            routeRegistry, bindingResolver, dispatcher, responseWriter));
+                                                                 }
         });
+                                   bootstrap.bind(config.port())
+                                            .addListener(future -> {
+                                                             if (future.isSuccess()) {
+                                                             serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
+                                                             log.info("HTTP router started on port {}",
+                                                                      config.port());
+                                                             promise.succeed(unit());
+                                                         }else {
+                                                             log.error("Failed to start HTTP router on port {}",
+                                                                       config.port(),
+                                                                       future.cause());
+                                                             promise.fail(Causes.fromThrowable(future.cause()));
+                                                         }
+                                                         });
+                               });
     }
 
     @Override
     public Promise<Unit> stop() {
         return Promise.promise(promise -> {
-            if (serverChannel != null) {
-                serverChannel.close().addListener(f -> {
-                    bossGroup.shutdownGracefully();
-                    workerGroup.shutdownGracefully();
-                    log.info("HTTP router stopped");
-                    promise.succeed(unit());
-                });
-            } else {
-                bossGroup.shutdownGracefully();
-                workerGroup.shutdownGracefully();
-                promise.succeed(unit());
-            }
-        });
+                                   if (serverChannel != null) {
+                                   serverChannel.close()
+                                                .addListener(f -> {
+                                                                 bossGroup.shutdownGracefully();
+                                                                 workerGroup.shutdownGracefully();
+                                                                 log.info("HTTP router stopped");
+                                                                 promise.succeed(unit());
+                                                             });
+                               }else {
+                                   bossGroup.shutdownGracefully();
+                                   workerGroup.shutdownGracefully();
+                                   promise.succeed(unit());
+                               }
+                               });
     }
 }
 
 class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
-
     private static final Logger log = LoggerFactory.getLogger(HttpRequestHandler.class);
 
     private final RouteRegistry routeRegistry;
@@ -147,12 +144,10 @@ class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
     private final SliceDispatcher dispatcher;
     private final ResponseWriter responseWriter;
 
-    HttpRequestHandler(
-            RouteRegistry routeRegistry,
-            BindingResolver bindingResolver,
-            SliceDispatcher dispatcher,
-            ResponseWriter responseWriter
-    ) {
+    HttpRequestHandler(RouteRegistry routeRegistry,
+                       BindingResolver bindingResolver,
+                       SliceDispatcher dispatcher,
+                       ResponseWriter responseWriter) {
         this.routeRegistry = routeRegistry;
         this.bindingResolver = bindingResolver;
         this.dispatcher = dispatcher;
@@ -161,72 +156,73 @@ class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
 
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
-        if (!request.decoderResult().isSuccess()) {
-            responseWriter.writeError(ctx, HttpResponseStatus.BAD_REQUEST,
-                    Causes.cause("Invalid HTTP request"));
+        if (!request.decoderResult()
+                    .isSuccess()) {
+            responseWriter.writeError(ctx, HttpResponseStatus.BAD_REQUEST, Causes.cause("Invalid HTTP request"));
             return;
         }
-
-        var method = HttpMethod.fromString(request.method().name());
+        var method = HttpMethod.fromString(request.method()
+                                                  .name());
         var decoder = new QueryStringDecoder(request.uri());
         var path = decoder.path();
-
         log.debug("Received {} {}", method, path);
-
-        routeRegistry.match(method, path).fold(
-            () -> {
-                responseWriter.writeError(ctx, HttpResponseStatus.NOT_FOUND,
-                        new HttpRouterError.RouteNotFound(path));
-                return null;
-            },
-            match -> {
-                handleMatchedRoute(ctx, method, path, decoder, request, match);
-                return null;
-            }
-        );
+        routeRegistry.match(method, path)
+                     .fold(() -> {
+                               responseWriter.writeError(ctx,
+                                                         HttpResponseStatus.NOT_FOUND,
+                                                         new HttpRouterError.RouteNotFound(path));
+                               return null;
+                           },
+                           match -> {
+                               handleMatchedRoute(ctx, method, path, decoder, request, match);
+                               return null;
+                           });
     }
 
-    private void handleMatchedRoute(ChannelHandlerContext ctx, HttpMethod method, String path,
-                                     QueryStringDecoder decoder, FullHttpRequest request, MatchResult match) {
+    private void handleMatchedRoute(ChannelHandlerContext ctx,
+                                    HttpMethod method,
+                                    String path,
+                                    QueryStringDecoder decoder,
+                                    FullHttpRequest request,
+                                    MatchResult match) {
         var route = match.route();
-
         // Build request context
         var queryParams = decoder.parameters();
         var headers = new HashMap<String, String>();
-        request.headers().forEach(entry -> headers.put(entry.getKey().toLowerCase(), entry.getValue()));
-        var body = new byte[request.content().readableBytes()];
-        request.content().readBytes(body);
-
+        request.headers()
+               .forEach(entry -> headers.put(entry.getKey()
+                                                  .toLowerCase(),
+                                             entry.getValue()));
+        var body = new byte[request.content()
+                                   .readableBytes()];
+        request.content()
+               .readBytes(body);
         var context = new RequestContext(method, path, match.pathVariables(), queryParams, headers, body);
-
         // Resolve bindings
         var bindingsResult = bindingResolver.resolve(route.bindings(), context);
         if (bindingsResult.isFailure()) {
-            bindingsResult.onFailure(cause ->
-                    responseWriter.writeError(ctx, HttpResponseStatus.BAD_REQUEST, cause)
-            );
+            bindingsResult.onFailure(cause -> responseWriter.writeError(ctx, HttpResponseStatus.BAD_REQUEST, cause));
             return;
         }
-
         // Dispatch to slice
         bindingsResult.onSuccess(resolvedParams -> {
-            dispatcher.dispatch(route, resolvedParams)
-                    .onSuccess(result -> responseWriter.writeSuccess(ctx, result))
-                    .onFailure(cause -> {
-                        var status = determineErrorStatus(cause);
-                        responseWriter.writeError(ctx, status, cause);
-                    });
-        });
+                                     dispatcher.dispatch(route, resolvedParams)
+                                               .onSuccess(result -> responseWriter.writeSuccess(ctx, result))
+                                               .onFailure(cause -> {
+                                                              var status = determineErrorStatus(cause);
+                                                              responseWriter.writeError(ctx, status, cause);
+                                                          });
+                                 });
     }
 
     private HttpResponseStatus determineErrorStatus(org.pragmatica.lang.Cause cause) {
         if (cause instanceof HttpRouterError.SliceNotFound) {
             return HttpResponseStatus.NOT_FOUND;
-        } else if (cause instanceof HttpRouterError.BindingFailed) {
+        }else if (cause instanceof HttpRouterError.BindingFailed) {
             return HttpResponseStatus.BAD_REQUEST;
-        } else if (cause instanceof HttpRouterError.DeserializationFailed) {
+        }else if (cause instanceof HttpRouterError.DeserializationFailed) {
             return HttpResponseStatus.BAD_REQUEST;
-        } else {
+        }else {
             return HttpResponseStatus.INTERNAL_SERVER_ERROR;
         }
     }
@@ -234,7 +230,6 @@ private HttpResponseStatus determineErrorStatus(org.pragmatica.lang.Cause cause)
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         log.error("Error handling HTTP request", cause);
-        responseWriter.writeError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR,
-                Causes.fromThrowable(cause));
+        responseWriter.writeError(ctx, HttpResponseStatus.INTERNAL_SERVER_ERROR, Causes.fromThrowable(cause));
     }
 }

From c8d06950095d00d37a8b4f9a1ea9f4e7649a6b4a Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 14:00:52 +0100
Subject: [PATCH 08/26] refactor: replace unwrap() with expect() in demo slices

---
 .../usecase/cancelorder/CancelOrderError.java |   1 -
 .../cancelorder/CancelOrderRequest.java       |   1 -
 .../cancelorder/CancelOrderResponse.java      |   9 +-
 .../usecase/cancelorder/CancelOrderSlice.java | 126 +++++------
 .../cancelorder/ValidCancelOrderRequest.java  |   4 +-
 .../getorderstatus/GetOrderStatusError.java   |   1 -
 .../getorderstatus/GetOrderStatusRequest.java |   1 -
 .../GetOrderStatusResponse.java               |  13 +-
 .../getorderstatus/GetOrderStatusSlice.java   |  68 +++---
 .../ValidGetOrderStatusRequest.java           |   1 -
 .../order/inventory/CheckStockRequest.java    |   1 -
 .../demo/order/inventory/InventoryError.java  |   1 -
 .../inventory/InventoryServiceSlice.java      | 117 +++++-----
 .../order/inventory/ReleaseStockRequest.java  |   1 -
 .../order/inventory/ReserveStockRequest.java  |   1 -
 .../order/inventory/StockAvailability.java    |   1 -
 .../demo/order/inventory/StockReleased.java   |   1 -
 .../order/inventory/StockReservation.java     |   1 -
 .../aether/demo/order/domain/Currency.java    |   5 +-
 .../aether/demo/order/domain/CustomerId.java  |   3 +-
 .../aether/demo/order/domain/Money.java       |   4 +-
 .../aether/demo/order/domain/OrderId.java     |   7 +-
 .../demo/order/domain/OrderRepository.java    |  91 ++++----
 .../aether/demo/order/domain/OrderStatus.java |   1 -
 .../aether/demo/order/domain/ProductId.java   |   3 +-
 .../usecase/placeorder/PlaceOrderError.java   |   1 -
 .../usecase/placeorder/PlaceOrderRequest.java |   7 +-
 .../placeorder/PlaceOrderResponse.java        |   9 +-
 .../usecase/placeorder/PlaceOrderSlice.java   | 211 ++++++++++--------
 .../placeorder/ValidPlaceOrderRequest.java    |  22 +-
 .../demo/order/pricing/GetPriceRequest.java   |   1 -
 .../demo/order/pricing/PricingError.java      |   1 -
 .../order/pricing/PricingServiceSlice.java    |  64 +++---
 33 files changed, 375 insertions(+), 404 deletions(-)

diff --git a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderError.java b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderError.java
index 49dc6e26..2e4b8541 100644
--- a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderError.java
+++ b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderError.java
@@ -3,7 +3,6 @@
 import org.pragmatica.lang.Cause;
 
 public sealed interface CancelOrderError extends Cause {
-
     record InvalidRequest(String details) implements CancelOrderError {
         @Override
         public String message() {
diff --git a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderRequest.java b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderRequest.java
index e05a21c5..d7269540 100644
--- a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderRequest.java
+++ b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.usecase.cancelorder;
-
 public record CancelOrderRequest(String orderId, String reason) {}
diff --git a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderResponse.java b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderResponse.java
index da3e8d0d..8e3d0cc1 100644
--- a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderResponse.java
+++ b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderResponse.java
@@ -6,8 +6,7 @@
 import java.time.Instant;
 
 public record CancelOrderResponse(
-    OrderId orderId,
-    OrderStatus status,
-    String reason,
-    Instant cancelledAt
-) {}
+ OrderId orderId,
+ OrderStatus status,
+ String reason,
+ Instant cancelledAt) {}
diff --git a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderSlice.java b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderSlice.java
index b220b8b5..d051e67d 100644
--- a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderSlice.java
+++ b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/CancelOrderSlice.java
@@ -30,15 +30,11 @@
  * 5. Return cancellation confirmation
  */
 public record CancelOrderSlice() implements Slice {
-
     private static final String INVENTORY = "org.pragmatica-lite.aether.demo:inventory-service:0.1.0";
 
     // Status that allow cancellation
-    private static final Set<OrderStatus> CANCELLABLE_STATUSES = Set.of(
-        OrderStatus.PENDING,
-        OrderStatus.CONFIRMED,
-        OrderStatus.PROCESSING
-    );
+    private static final Set<OrderStatus>CANCELLABLE_STATUSES = Set.of(
+    OrderStatus.PENDING, OrderStatus.CONFIRMED, OrderStatus.PROCESSING);
 
     private OrderRepository repository() {
         return OrderRepository.instance();
@@ -53,90 +49,92 @@ private SliceInvokerFacade invoker() {
     }
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("cancelOrder").unwrap(),
-                this::execute,
-                new TypeToken<CancelOrderResponse>() {},
-                new TypeToken<CancelOrderRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("cancelOrder")
+                  .expect("Invalid method name: cancelOrder"),
+        this::execute,
+        new TypeToken<CancelOrderResponse>() {},
+        new TypeToken<CancelOrderRequest>() {}));
     }
 
     @Override
     public List<SliceRoute> routes() {
         return List.of(
-            SliceRoute.delete("/api/orders/{orderId}", "cancelOrder")
-                .withPathVar("orderId")
-                .withBody()
-                .build()
-        );
+        SliceRoute.delete("/api/orders/{orderId}", "cancelOrder")
+                  .withPathVar("orderId")
+                  .withBody()
+                  .build());
     }
 
     private Promise<CancelOrderResponse> execute(CancelOrderRequest request) {
         return ValidCancelOrderRequest.validCancelOrderRequest(request)
-                                       .async()
-                                       .flatMap(this::findAndValidateOrder)
-                                       .flatMap(this::releaseAllStock)
-                                       .map(this::updateAndConfirm);
+                                      .async()
+                                      .flatMap(this::findAndValidateOrder)
+                                      .flatMap(this::releaseAllStock)
+                                      .map(this::updateAndConfirm);
     }
 
     private Promise<OrderWithContext> findAndValidateOrder(ValidCancelOrderRequest validRequest) {
-        return repository().findById(validRequest.orderId().value())
-            .fold(
-                () -> new CancelOrderError.OrderNotFound(validRequest.orderId().value()).<OrderWithContext>promise(),
-                order -> {
-                    if (!CANCELLABLE_STATUSES.contains(order.status())) {
-                        return new CancelOrderError.OrderNotCancellable(
-                            validRequest.orderId().value(),
-                            "Order is in " + order.status() + " status"
-                        ).<OrderWithContext>promise();
-                    }
-                    return Promise.success(new OrderWithContext(validRequest, order));
-                }
-            );
+        return repository()
+               .findById(validRequest.orderId()
+                                     .value())
+               .fold(() -> new CancelOrderError.OrderNotFound(validRequest.orderId()
+                                                                          .value()).<OrderWithContext>promise(),
+                     order -> {
+                         if (!CANCELLABLE_STATUSES.contains(order.status())) {
+                         return new CancelOrderError.OrderNotCancellable(
+        validRequest.orderId()
+                    .value(),
+        "Order is in " + order.status() + " status").<OrderWithContext>promise();
+                     }
+                         return Promise.success(new OrderWithContext(validRequest, order));
+                     });
     }
 
     private Promise<OrderWithReleases> releaseAllStock(OrderWithContext context) {
-        var releases = context.order().reservationIds().stream()
-            .map(reservationId -> invoker().invokeAndWait(
-                INVENTORY,
-                "releaseStock",
-                new ReleaseStockRequest(reservationId),
-                StockReleased.class
-            ))
-            .toList();
-
+        var releases = context.order()
+                              .reservationIds()
+                              .stream()
+                              .map(reservationId -> invoker()
+                                                    .invokeAndWait(INVENTORY,
+                                                                   "releaseStock",
+                                                                   new ReleaseStockRequest(reservationId),
+                                                                   StockReleased.class))
+                              .toList();
         return Promise.allOf(releases)
                       .flatMap(results -> {
-                          var allSuccess = results.stream().allMatch(r -> r.isSuccess());
-
-                          if (!allSuccess) {
-                              // In production, we'd handle partial releases
-                              return new CancelOrderError.StockReleaseFailed(
-                                  new CancelOrderError.InvalidRequest("Some reservations could not be released")
-                              ).promise();
-                          }
-
-                          return Promise.success(new OrderWithReleases(context.request(), context.order()));
-                      });
+                                   var allSuccess = results.stream()
+                                                           .allMatch(r -> r.isSuccess());
+                                   if (!allSuccess) {
+                                   // In production, we'd handle partial releases
+        return new CancelOrderError.StockReleaseFailed(
+        new CancelOrderError.InvalidRequest("Some reservations could not be released")).promise();
+                               }
+                                   return Promise.success(new OrderWithReleases(context.request(),
+                                                                                context.order()));
+                               });
     }
 
     private CancelOrderResponse updateAndConfirm(OrderWithReleases context) {
         // Update order status in the repository
-        var orderId = context.request().orderId().value();
-        repository().updateStatus(orderId, OrderStatus.CANCELLED);
-
+        var orderId = context.request()
+                             .orderId()
+                             .value();
+        repository()
+        .updateStatus(orderId, OrderStatus.CANCELLED);
         return new CancelOrderResponse(
-            context.request().orderId(),
-            OrderStatus.CANCELLED,
-            context.request().reason(),
-            Instant.now()
-        );
+        context.request()
+               .orderId(),
+        OrderStatus.CANCELLED,
+        context.request()
+               .reason(),
+        Instant.now());
     }
 
     // Pipeline context records
     private record OrderWithContext(ValidCancelOrderRequest request, StoredOrder order) {}
+
     private record OrderWithReleases(ValidCancelOrderRequest request, StoredOrder order) {}
 }
diff --git a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/ValidCancelOrderRequest.java b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/ValidCancelOrderRequest.java
index 59774c5a..a52287fa 100644
--- a/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/ValidCancelOrderRequest.java
+++ b/examples/order-demo/cancel-order/src/main/java/org/pragmatica/aether/demo/order/usecase/cancelorder/ValidCancelOrderRequest.java
@@ -4,9 +4,9 @@
 import org.pragmatica.lang.Result;
 
 public record ValidCancelOrderRequest(OrderId orderId, String reason) {
-
     public static Result<ValidCancelOrderRequest> validCancelOrderRequest(CancelOrderRequest raw) {
         return OrderId.orderId(raw.orderId())
-                      .map(orderId -> new ValidCancelOrderRequest(orderId, raw.reason()));
+                      .map(orderId -> new ValidCancelOrderRequest(orderId,
+                                                                  raw.reason()));
     }
 }
diff --git a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusError.java b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusError.java
index d350c2cb..b9e2a81b 100644
--- a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusError.java
+++ b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusError.java
@@ -3,7 +3,6 @@
 import org.pragmatica.lang.Cause;
 
 public sealed interface GetOrderStatusError extends Cause {
-
     record InvalidRequest(String details) implements GetOrderStatusError {
         @Override
         public String message() {
diff --git a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusRequest.java b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusRequest.java
index 6c52ef17..d38ea863 100644
--- a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusRequest.java
+++ b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.usecase.getorderstatus;
-
 public record GetOrderStatusRequest(String orderId) {}
diff --git a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusResponse.java b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusResponse.java
index 252778dd..dcc6fbb6 100644
--- a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusResponse.java
+++ b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusResponse.java
@@ -8,12 +8,11 @@
 import java.util.List;
 
 public record GetOrderStatusResponse(
-    OrderId orderId,
-    OrderStatus status,
-    Money total,
-    List<OrderItem> items,
-    Instant createdAt,
-    Instant updatedAt
-) {
+ OrderId orderId,
+ OrderStatus status,
+ Money total,
+ List<OrderItem> items,
+ Instant createdAt,
+ Instant updatedAt) {
     public record OrderItem(String productId, int quantity, Money unitPrice) {}
 }
diff --git a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusSlice.java b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusSlice.java
index 88e5fccd..e29f1888 100644
--- a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusSlice.java
+++ b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/GetOrderStatusSlice.java
@@ -15,7 +15,6 @@
  * Uses shared OrderRepository for cross-slice visibility.
  */
 public record GetOrderStatusSlice() implements Slice {
-
     private OrderRepository repository() {
         return OrderRepository.instance();
     }
@@ -25,52 +24,51 @@ public static GetOrderStatusSlice getOrderStatusSlice() {
     }
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("getOrderStatus").unwrap(),
-                this::execute,
-                new TypeToken<GetOrderStatusResponse>() {},
-                new TypeToken<GetOrderStatusRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("getOrderStatus")
+                  .expect("Invalid method name: getOrderStatus"),
+        this::execute,
+        new TypeToken<GetOrderStatusResponse>() {},
+        new TypeToken<GetOrderStatusRequest>() {}));
     }
 
     @Override
     public List<SliceRoute> routes() {
         return List.of(
-            SliceRoute.get("/api/orders/{orderId}", "getOrderStatus")
-                .withPathVar("orderId")
-                .build()
-        );
+        SliceRoute.get("/api/orders/{orderId}", "getOrderStatus")
+                  .withPathVar("orderId")
+                  .build());
     }
 
     private Promise<GetOrderStatusResponse> execute(GetOrderStatusRequest request) {
         return ValidGetOrderStatusRequest.validGetOrderStatusRequest(request)
-                                          .async()
-                                          .flatMap(this::findOrder);
+                                         .async()
+                                         .flatMap(this::findOrder);
     }
 
     private Promise<GetOrderStatusResponse> findOrder(ValidGetOrderStatusRequest validRequest) {
-        return repository().findById(validRequest.orderId().value())
-            .fold(
-                () -> new GetOrderStatusError.OrderNotFound(validRequest.orderId().value()).<GetOrderStatusResponse>promise(),
-                order -> {
-                    var items = order.items().stream()
-                        .map(item -> new GetOrderStatusResponse.OrderItem(
-                            item.productId(), item.quantity(), item.unitPrice()
-                        ))
-                        .toList();
-
-                    return Promise.success(new GetOrderStatusResponse(
-                        order.orderId(),
-                        order.status(),
-                        order.total(),
-                        items,
-                        order.createdAt(),
-                        order.updatedAt()
-                    ));
-                }
-            );
+        return repository()
+               .findById(validRequest.orderId()
+                                     .value())
+               .fold(() -> new GetOrderStatusError.OrderNotFound(validRequest.orderId()
+                                                                             .value()).<GetOrderStatusResponse>promise(),
+                     order -> {
+                         var items = order.items()
+                                          .stream()
+                                          .map(item -> new GetOrderStatusResponse.OrderItem(
+        item.productId(),
+        item.quantity(),
+        item.unitPrice()))
+                                          .toList();
+                         return Promise.success(new GetOrderStatusResponse(
+        order.orderId(),
+        order.status(),
+        order.total(),
+        items,
+        order.createdAt(),
+        order.updatedAt()));
+                     });
     }
 }
diff --git a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/ValidGetOrderStatusRequest.java b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/ValidGetOrderStatusRequest.java
index 179dd773..98bb78b8 100644
--- a/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/ValidGetOrderStatusRequest.java
+++ b/examples/order-demo/get-order-status/src/main/java/org/pragmatica/aether/demo/order/usecase/getorderstatus/ValidGetOrderStatusRequest.java
@@ -4,7 +4,6 @@
 import org.pragmatica.lang.Result;
 
 public record ValidGetOrderStatusRequest(OrderId orderId) {
-
     public static Result<ValidGetOrderStatusRequest> validGetOrderStatusRequest(GetOrderStatusRequest raw) {
         return OrderId.orderId(raw.orderId())
                       .map(ValidGetOrderStatusRequest::new);
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/CheckStockRequest.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/CheckStockRequest.java
index 46ab4b25..424cd9ce 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/CheckStockRequest.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/CheckStockRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record CheckStockRequest(String productId, int quantity) {}
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryError.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryError.java
index 68bba5d2..ff6e7df6 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryError.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryError.java
@@ -3,7 +3,6 @@
 import org.pragmatica.lang.Cause;
 
 public sealed interface InventoryError extends Cause {
-
     record ProductNotFound(String productId) implements InventoryError {
         @Override
         public String message() {
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryServiceSlice.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryServiceSlice.java
index 5b204654..ee8edf8a 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryServiceSlice.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/InventoryServiceSlice.java
@@ -26,7 +26,6 @@
  * - Realistic mode: Stock depletes and refills at configured rate
  */
 public record InventoryServiceSlice() implements Slice {
-
     // Stock mode: true = infinite supply, false = realistic mode
     private static final AtomicBoolean INFINITE_MODE = new AtomicBoolean(true);
 
@@ -34,12 +33,15 @@ public record InventoryServiceSlice() implements Slice {
     private static final int INITIAL_STOCK = 1_000_000;
 
     // Refill configuration
-    private static final AtomicInteger REFILL_RATE = new AtomicInteger(1000); // units per refill
-    private static final AtomicInteger REFILL_INTERVAL_MS = new AtomicInteger(100); // milliseconds
+    private static final AtomicInteger REFILL_RATE = new AtomicInteger(1000);
+
+    // units per refill
+    private static final AtomicInteger REFILL_INTERVAL_MS = new AtomicInteger(100);
 
+    // milliseconds
     // Stock data
-    private static final Map<String, AtomicInteger> STOCK = new ConcurrentHashMap<>();
-    private static final Map<String, ReservedStock> RESERVATIONS = new ConcurrentHashMap<>();
+    private static final Map<String, AtomicInteger>STOCK = new ConcurrentHashMap<>();
+    private static final Map<String, ReservedStock>RESERVATIONS = new ConcurrentHashMap<>();
 
     // Metrics
     private static final AtomicLong TOTAL_RESERVATIONS = new AtomicLong();
@@ -48,20 +50,19 @@ public record InventoryServiceSlice() implements Slice {
 
     // Refill scheduler
     private static final ScheduledExecutorService REFILL_SCHEDULER = Executors.newSingleThreadScheduledExecutor(r -> {
-        var t = new Thread(r, "inventory-refill");
-        t.setDaemon(true);
-        return t;
-    });
+                                                                                                                    var t = new Thread(r,
+                                                                                                                                       "inventory-refill");
+                                                                                                                    t.setDaemon(true);
+                                                                                                                    return t;
+                                                                                                                });
 
     static {
         // Initialize stock for known products
         STOCK.put("PROD-ABC123", new AtomicInteger(INITIAL_STOCK));
         STOCK.put("PROD-DEF456", new AtomicInteger(INITIAL_STOCK));
         STOCK.put("PROD-GHI789", new AtomicInteger(INITIAL_STOCK));
-
         // Start refill scheduler
-        REFILL_SCHEDULER.scheduleAtFixedRate(InventoryServiceSlice::refillStock,
-            100, 100, TimeUnit.MILLISECONDS);
+        REFILL_SCHEDULER.scheduleAtFixedRate(InventoryServiceSlice::refillStock, 100, 100, TimeUnit.MILLISECONDS);
     }
 
     private record ReservedStock(String productId, int quantity) {}
@@ -106,12 +107,7 @@ public static Map<String, Integer> getStockLevels() {
      */
     public static InventoryMetrics getMetrics() {
         return new InventoryMetrics(
-            TOTAL_RESERVATIONS.get(),
-            TOTAL_RELEASES.get(),
-            STOCK_OUTS.get(),
-            INFINITE_MODE.get(),
-            REFILL_RATE.get()
-        );
+        TOTAL_RESERVATIONS.get(), TOTAL_RELEASES.get(), STOCK_OUTS.get(), INFINITE_MODE.get(), REFILL_RATE.get());
     }
 
     /**
@@ -127,64 +123,62 @@ public static void resetStock() {
 
     private static void refillStock() {
         if (INFINITE_MODE.get()) {
-            return; // No refill needed in infinite mode
+            return;
         }
-
         var refillAmount = REFILL_RATE.get();
         STOCK.forEach((productId, stock) -> {
-            var current = stock.get();
-            if (current < INITIAL_STOCK) {
-                var newValue = Math.min(current + refillAmount, INITIAL_STOCK);
-                stock.set(newValue);
-            }
-        });
+                          var current = stock.get();
+                          if (current < INITIAL_STOCK) {
+                          var newValue = Math.min(current + refillAmount, INITIAL_STOCK);
+                          stock.set(newValue);
+                      }
+                      });
     }
 
     /**
      * Inventory metrics record.
      */
     public record InventoryMetrics(
-        long totalReservations,
-        long totalReleases,
-        long stockOuts,
-        boolean infiniteMode,
-        int refillRate
-    ) {}
+    long totalReservations,
+    long totalReleases,
+    long stockOuts,
+    boolean infiniteMode,
+    int refillRate) {}
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("checkStock").unwrap(),
-                this::checkStock,
-                new TypeToken<StockAvailability>() {},
-                new TypeToken<CheckStockRequest>() {}
-            ),
-            new SliceMethod<>(
-                MethodName.methodName("reserveStock").unwrap(),
-                this::reserveStock,
-                new TypeToken<StockReservation>() {},
-                new TypeToken<ReserveStockRequest>() {}
-            ),
-            new SliceMethod<>(
-                MethodName.methodName("releaseStock").unwrap(),
-                this::releaseStock,
-                new TypeToken<StockReleased>() {},
-                new TypeToken<ReleaseStockRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("checkStock")
+                  .expect("Invalid method name: checkStock"),
+        this::checkStock,
+        new TypeToken<StockAvailability>() {},
+        new TypeToken<CheckStockRequest>() {}),
+        new SliceMethod<>(
+        MethodName.methodName("reserveStock")
+                  .expect("Invalid method name: reserveStock"),
+        this::reserveStock,
+        new TypeToken<StockReservation>() {},
+        new TypeToken<ReserveStockRequest>() {}),
+        new SliceMethod<>(
+        MethodName.methodName("releaseStock")
+                  .expect("Invalid method name: releaseStock"),
+        this::releaseStock,
+        new TypeToken<StockReleased>() {},
+        new TypeToken<ReleaseStockRequest>() {}));
     }
 
     @Override
     public Promise<Unit> stop() {
         REFILL_SCHEDULER.shutdown();
-        try {
+        try{
             if (!REFILL_SCHEDULER.awaitTermination(1, TimeUnit.SECONDS)) {
                 REFILL_SCHEDULER.shutdownNow();
             }
         } catch (InterruptedException e) {
             REFILL_SCHEDULER.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
         return Promise.success(Unit.unit());
     }
@@ -192,11 +186,9 @@ public Promise<Unit> stop() {
     private Promise<StockAvailability> checkStock(CheckStockRequest request) {
         var productId = request.productId();
         var stock = STOCK.get(productId);
-
         if (stock == null) {
             return new InventoryError.ProductNotFound(productId).promise();
         }
-
         var available = stock.get();
         var sufficient = available >= request.quantity();
         return Promise.success(new StockAvailability(productId, available, sufficient));
@@ -205,14 +197,13 @@ private Promise<StockAvailability> checkStock(CheckStockRequest request) {
     private Promise<StockReservation> reserveStock(ReserveStockRequest request) {
         var productId = request.productId();
         var stock = STOCK.get(productId);
-
         if (stock == null) {
             return new InventoryError.ProductNotFound(productId).promise();
         }
-
-        var reservationId = "RES-" + UUID.randomUUID().toString().substring(0, 8);
+        var reservationId = "RES-" + UUID.randomUUID()
+                                        .toString()
+                                        .substring(0, 8);
         var quantity = request.quantity();
-
         if (INFINITE_MODE.get()) {
             // Infinite mode: don't actually decrement stock
             TOTAL_RESERVATIONS.incrementAndGet();
@@ -220,7 +211,6 @@ private Promise<StockReservation> reserveStock(ReserveStockRequest request) {
             RESERVATIONS.put(reservationId, new ReservedStock(productId, quantity));
             return Promise.success(new StockReservation(reservationId, productId, quantity));
         }
-
         // Realistic mode: atomic compare-and-set loop to avoid race conditions
         while (true) {
             var current = stock.get();
@@ -228,31 +218,26 @@ private Promise<StockReservation> reserveStock(ReserveStockRequest request) {
                 STOCK_OUTS.incrementAndGet();
                 return new InventoryError.InsufficientStock(productId, quantity, current).promise();
             }
-
             if (stock.compareAndSet(current, current - quantity)) {
                 // CAS succeeded - reservation is safe
                 TOTAL_RESERVATIONS.incrementAndGet();
                 RESERVATIONS.put(reservationId, new ReservedStock(productId, quantity));
                 return Promise.success(new StockReservation(reservationId, productId, quantity));
             }
-            // CAS failed - another thread modified stock, retry
         }
     }
 
     private Promise<StockReleased> releaseStock(ReleaseStockRequest request) {
         var reservation = RESERVATIONS.remove(request.reservationId());
-
         if (reservation == null) {
             // In demo/load testing, reservations may not exist - just succeed
             return Promise.success(new StockReleased(request.reservationId()));
         }
-
         // Restore stock
         var stock = STOCK.get(reservation.productId());
         if (stock != null) {
             stock.addAndGet(reservation.quantity());
         }
-
         TOTAL_RELEASES.incrementAndGet();
         return Promise.success(new StockReleased(request.reservationId()));
     }
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReleaseStockRequest.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReleaseStockRequest.java
index 4237df09..030c48aa 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReleaseStockRequest.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReleaseStockRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record ReleaseStockRequest(String reservationId) {}
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReserveStockRequest.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReserveStockRequest.java
index d6ad4bc1..545bdf5a 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReserveStockRequest.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/ReserveStockRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record ReserveStockRequest(String productId, int quantity, String orderId) {}
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockAvailability.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockAvailability.java
index 543b1877..02ca43e4 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockAvailability.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockAvailability.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record StockAvailability(String productId, int available, boolean sufficient) {}
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReleased.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReleased.java
index d975c0c9..ad74d033 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReleased.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReleased.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record StockReleased(String reservationId) {}
diff --git a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReservation.java b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReservation.java
index c851572b..929df388 100644
--- a/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReservation.java
+++ b/examples/order-demo/inventory-service/src/main/java/org/pragmatica/aether/demo/order/inventory/StockReservation.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.inventory;
-
 public record StockReservation(String reservationId, String productId, int quantity) {}
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Currency.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Currency.java
index a394b5a1..01702a42 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Currency.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Currency.java
@@ -1,5 +1,6 @@
 package org.pragmatica.aether.demo.order.domain;
-
 public enum Currency {
-    USD, EUR, GBP
+    USD,
+    EUR,
+    GBP
 }
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
index 7e3a2d25..4fde7ecd 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
@@ -10,7 +10,8 @@
 
 public record CustomerId(String value) {
     private static final Pattern CUSTOMER_ID_PATTERN = Pattern.compile("^CUST-[0-9]{8}$");
-    private static final Fn1<Cause, String> INVALID_CUSTOMER_ID = Causes.forOneValue("Invalid customer ID: {}");
+
+    private static final Fn1<Cause, String>INVALID_CUSTOMER_ID = Causes.forOneValue("Invalid customer ID: {}");
 
     public static Result<CustomerId> customerId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Money.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Money.java
index 2b120e76..daa37541 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Money.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/Money.java
@@ -3,7 +3,6 @@
 import java.math.BigDecimal;
 
 public record Money(BigDecimal amount, Currency currency) {
-
     public static Money usd(BigDecimal amount) {
         return new Money(amount, Currency.USD);
     }
@@ -20,7 +19,8 @@ public Money add(Money other) {
     }
 
     public Money multiply(int quantity) {
-        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)), this.currency);
+        return new Money(this.amount.multiply(BigDecimal.valueOf(quantity)),
+                         this.currency);
     }
 
     public Money subtract(Money other) {
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
index b72fd47d..e651e5ef 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
@@ -11,7 +11,8 @@
 
 public record OrderId(String value) {
     private static final Pattern ORDER_ID_PATTERN = Pattern.compile("^ORD-[a-f0-9]{8}$");
-    private static final Fn1<Cause, String> INVALID_ORDER_ID = Causes.forOneValue("Invalid order ID: {}");
+
+    private static final Fn1<Cause, String>INVALID_ORDER_ID = Causes.forOneValue("Invalid order ID: {}");
 
     public static Result<OrderId> orderId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
@@ -20,6 +21,8 @@ public static Result<OrderId> orderId(String raw) {
     }
 
     public static OrderId generate() {
-        return new OrderId("ORD-" + UUID.randomUUID().toString().substring(0, 8));
+        return new OrderId("ORD-" + UUID.randomUUID()
+                                       .toString()
+                                       .substring(0, 8));
     }
 }
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderRepository.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderRepository.java
index d0d126af..a88eb5e3 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderRepository.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderRepository.java
@@ -12,7 +12,6 @@
  * Uses static shared storage for demo purposes (orders visible across all slices).
  */
 public interface OrderRepository {
-
     /**
      * Store a new order.
      */
@@ -37,20 +36,17 @@ public interface OrderRepository {
      * Stored order record.
      */
     record StoredOrder(
-        OrderId orderId,
-        CustomerId customerId,
-        OrderStatus status,
-        Money total,
-        List<OrderItem> items,
-        List<String> reservationIds,
-        Instant createdAt,
-        Instant updatedAt
-    ) {
+    OrderId orderId,
+    CustomerId customerId,
+    OrderStatus status,
+    Money total,
+    List<OrderItem> items,
+    List<String> reservationIds,
+    Instant createdAt,
+    Instant updatedAt) {
         public StoredOrder withStatus(OrderStatus newStatus) {
             return new StoredOrder(
-                orderId, customerId, newStatus, total, items,
-                reservationIds, createdAt, Instant.now()
-            );
+            orderId, customerId, newStatus, total, items, reservationIds, createdAt, Instant.now());
         }
     }
 
@@ -58,10 +54,9 @@ public StoredOrder withStatus(OrderStatus newStatus) {
      * Order line item.
      */
     record OrderItem(
-        String productId,
-        int quantity,
-        Money unitPrice
-    ) {}
+    String productId,
+    int quantity,
+    Money unitPrice) {}
 
     /**
      * Get the shared repository instance.
@@ -86,42 +81,43 @@ private InMemoryOrderRepository() {
 
     private void seedMockOrders() {
         var now = Instant.now();
-
         // Order 1 - Confirmed
         var order1 = new StoredOrder(
-            new OrderId("ORD-12345678"),
-            CustomerId.customerId("CUST-00000001").unwrap(),
-            OrderStatus.CONFIRMED,
-            Money.usd("129.97"),
-            List.of(
-                new OrderItem("PROD-ABC123", 2, Money.usd("29.99")),
-                new OrderItem("PROD-DEF456", 1, Money.usd("49.99"))
-            ),
-            List.of("RES-11111111", "RES-22222222"),
-            now.minusSeconds(3600),
-            now
-        );
-        orders.put(order1.orderId().value(), order1);
-
+        new OrderId("ORD-12345678"),
+        CustomerId.customerId("CUST-00000001")
+                  .expect("Invalid customer ID: CUST-00000001"),
+        OrderStatus.CONFIRMED,
+        Money.usd("129.97"),
+        List.of(
+        new OrderItem("PROD-ABC123", 2, Money.usd("29.99")), new OrderItem("PROD-DEF456", 1, Money.usd("49.99"))),
+        List.of("RES-11111111", "RES-22222222"),
+        now.minusSeconds(3600),
+        now);
+        orders.put(order1.orderId()
+                         .value(),
+                   order1);
         // Order 2 - Shipped
         var order2 = new StoredOrder(
-            new OrderId("ORD-87654321"),
-            CustomerId.customerId("CUST-00000002").unwrap(),
-            OrderStatus.SHIPPED,
-            Money.usd("99.99"),
-            List.of(
-                new OrderItem("PROD-GHI789", 1, Money.usd("99.99"))
-            ),
-            List.of("RES-33333333"),
-            now.minusSeconds(86400),
-            now.minusSeconds(3600)
-        );
-        orders.put(order2.orderId().value(), order2);
+        new OrderId("ORD-87654321"),
+        CustomerId.customerId("CUST-00000002")
+                  .expect("Invalid customer ID: CUST-00000002"),
+        OrderStatus.SHIPPED,
+        Money.usd("99.99"),
+        List.of(
+        new OrderItem("PROD-GHI789", 1, Money.usd("99.99"))),
+        List.of("RES-33333333"),
+        now.minusSeconds(86400),
+        now.minusSeconds(3600));
+        orders.put(order2.orderId()
+                         .value(),
+                   order2);
     }
 
     @Override
     public void save(StoredOrder order) {
-        orders.put(order.orderId().value(), order);
+        orders.put(order.orderId()
+                        .value(),
+                   order);
     }
 
     @Override
@@ -142,8 +138,9 @@ public Option<String> randomOrderId() {
         if (orders.isEmpty()) {
             return Option.empty();
         }
-        var keys = orders.keySet().toArray(new String[0]);
-        var idx = (int) (Math.random() * keys.length);
+        var keys = orders.keySet()
+                         .toArray(new String[0]);
+        var idx = (int)(Math.random() * keys.length);
         return Option.option(keys[idx]);
     }
 }
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderStatus.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderStatus.java
index f7668934..c7355e69 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderStatus.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderStatus.java
@@ -1,5 +1,4 @@
 package org.pragmatica.aether.demo.order.domain;
-
 public enum OrderStatus {
     PENDING,
     CONFIRMED,
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
index 9334cf2a..ae6aeec6 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
@@ -10,7 +10,8 @@
 
 public record ProductId(String value) {
     private static final Pattern PRODUCT_ID_PATTERN = Pattern.compile("^PROD-[A-Z0-9]{6}$");
-    private static final Fn1<Cause, String> INVALID_PRODUCT_ID = Causes.forOneValue("Invalid product ID: {}");
+
+    private static final Fn1<Cause, String>INVALID_PRODUCT_ID = Causes.forOneValue("Invalid product ID: {}");
 
     public static Result<ProductId> productId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
diff --git a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderError.java b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderError.java
index 8de0194b..74b807de 100644
--- a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderError.java
+++ b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderError.java
@@ -3,7 +3,6 @@
 import org.pragmatica.lang.Cause;
 
 public sealed interface PlaceOrderError extends Cause {
-
     record InvalidRequest(String details) implements PlaceOrderError {
         @Override
         public String message() {
diff --git a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderRequest.java b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderRequest.java
index 444db6ba..2aeaeb82 100644
--- a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderRequest.java
+++ b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderRequest.java
@@ -3,9 +3,8 @@
 import java.util.List;
 
 public record PlaceOrderRequest(
-    String customerId,
-    List<OrderItemRequest> items,
-    String discountCode
-) {
+ String customerId,
+ List<OrderItemRequest> items,
+ String discountCode) {
     public record OrderItemRequest(String productId, int quantity) {}
 }
diff --git a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderResponse.java b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderResponse.java
index eed5d2bd..8bde7dba 100644
--- a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderResponse.java
+++ b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderResponse.java
@@ -7,8 +7,7 @@
 import java.util.List;
 
 public record PlaceOrderResponse(
-    OrderId orderId,
-    OrderStatus status,
-    Money total,
-    List<String> reservationIds
-) {}
+ OrderId orderId,
+ OrderStatus status,
+ Money total,
+ List<String> reservationIds) {}
diff --git a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderSlice.java b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderSlice.java
index 18021253..03e8cd72 100644
--- a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderSlice.java
+++ b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/PlaceOrderSlice.java
@@ -34,7 +34,6 @@
  * 5. Return order confirmation
  */
 public record PlaceOrderSlice() implements Slice {
-
     private static final String INVENTORY = "org.pragmatica-lite.aether.demo:inventory-service:0.1.0";
     private static final String PRICING = "org.pragmatica-lite.aether.demo:pricing-service:0.1.0";
 
@@ -47,24 +46,22 @@ private SliceInvokerFacade invoker() {
     }
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("placeOrder").unwrap(),
-                this::execute,
-                new TypeToken<PlaceOrderResponse>() {},
-                new TypeToken<PlaceOrderRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("placeOrder")
+                  .expect("Invalid method name: placeOrder"),
+        this::execute,
+        new TypeToken<PlaceOrderResponse>() {},
+        new TypeToken<PlaceOrderRequest>() {}));
     }
 
     @Override
     public List<SliceRoute> routes() {
         return List.of(
-            SliceRoute.post("/api/orders", "placeOrder")
-                .withBody()
-                .build()
-        );
+        SliceRoute.post("/api/orders", "placeOrder")
+                  .withBody()
+                  .build());
     }
 
     private Promise<PlaceOrderResponse> execute(PlaceOrderRequest request) {
@@ -77,114 +74,130 @@ private Promise<PlaceOrderResponse> execute(PlaceOrderRequest request) {
     }
 
     private Promise<ValidWithStockCheck> checkAllStock(ValidPlaceOrderRequest request) {
-        var stockChecks = request.items().stream()
-            .map(item -> invoker().invokeAndWait(
-                INVENTORY,
-                "checkStock",
-                new CheckStockRequest(item.productId(), item.quantity()),
-                StockAvailability.class
-            ))
-            .toList();
-
+        var stockChecks = request.items()
+                                 .stream()
+                                 .map(item -> invoker()
+                                              .invokeAndWait(INVENTORY,
+                                                             "checkStock",
+                                                             new CheckStockRequest(item.productId(),
+                                                                                   item.quantity()),
+                                                             StockAvailability.class))
+                                 .toList();
         return Promise.allOf(stockChecks)
                       .flatMap(results -> {
-                          var allAvailable = results.stream()
-                              .allMatch(r -> r.isSuccess() && r.unwrap().sufficient());
-
-                          if (!allAvailable) {
-                              return new PlaceOrderError.InventoryCheckFailed(
-                                  Causes.cause("Some items not available")
-                              ).promise();
-                          }
-                          return Promise.success(new ValidWithStockCheck(request));
-                      });
+                                   var allAvailable = results.stream()
+                                                             .allMatch(r -> r.isSuccess() && r.expect("Stock check passed")
+                                                                                              .sufficient());
+                                   if (!allAvailable) {
+                                   return new PlaceOrderError.InventoryCheckFailed(
+        Causes.cause("Some items not available")).promise();
+                               }
+                                   return Promise.success(new ValidWithStockCheck(request));
+                               });
     }
 
     private Promise<ValidWithPrice> calculateTotal(ValidWithStockCheck context) {
-        var lineItems = context.request().items().stream()
-            .map(item -> new CalculateTotalRequest.LineItem(item.productId(), item.quantity()))
-            .toList();
-
-        return invoker().invokeAndWait(
-            PRICING,
-            "calculateTotal",
-            new CalculateTotalRequest(lineItems, context.request().discountCode()),
-            OrderTotal.class
-        ).map(total -> new ValidWithPrice(context.request(), total))
-         .mapError(cause -> new PlaceOrderError.PricingFailed(cause));
+        var lineItems = context.request()
+                               .items()
+                               .stream()
+                               .map(item -> new CalculateTotalRequest.LineItem(item.productId(),
+                                                                               item.quantity()))
+                               .toList();
+        return invoker()
+               .invokeAndWait(PRICING,
+                              "calculateTotal",
+                              new CalculateTotalRequest(lineItems,
+                                                        context.request()
+                                                               .discountCode()),
+                              OrderTotal.class)
+               .map(total -> new ValidWithPrice(context.request(),
+                                                total))
+               .mapError(cause -> new PlaceOrderError.PricingFailed(cause));
     }
 
     private Promise<ValidWithReservations> reserveAllStock(ValidWithPrice context) {
         var orderId = OrderId.generate();
-
-        var reservations = context.request().items().stream()
-            .map(item -> invoker().invokeAndWait(
-                INVENTORY,
-                "reserveStock",
-                new ReserveStockRequest(item.productId(), item.quantity(), orderId.value()),
-                StockReservation.class
-            ))
-            .toList();
-
+        var reservations = context.request()
+                                  .items()
+                                  .stream()
+                                  .map(item -> invoker()
+                                               .invokeAndWait(INVENTORY,
+                                                              "reserveStock",
+                                                              new ReserveStockRequest(item.productId(),
+                                                                                      item.quantity(),
+                                                                                      orderId.value()),
+                                                              StockReservation.class))
+                                  .toList();
         return Promise.allOf(reservations)
                       .flatMap(results -> {
-                          var successful = new ArrayList<StockReservation>();
-                          for (var r : results) {
-                              if (r.isSuccess()) {
-                                  successful.add(r.unwrap());
-                              }
-                          }
-
-                          if (successful.size() != results.size()) {
-                              return new PlaceOrderError.ReservationFailed(
-                                  Causes.cause("Failed to reserve all items")
-                              ).promise();
-                          }
-
-                          return Promise.success(new ValidWithReservations(
-                              context.request(), context.total(), orderId, successful
-                          ));
-                      });
+                                   var successful = new ArrayList<StockReservation>();
+                                   for (var r : results) {
+                                   if (r.isSuccess()) {
+                                   successful.add(r.expect("Reservation succeeded"));
+                               }
+                               }
+                                   if (successful.size() != results.size()) {
+                                   return new PlaceOrderError.ReservationFailed(
+        Causes.cause("Failed to reserve all items")).promise();
+                               }
+                                   return Promise.success(new ValidWithReservations(
+        context.request(),
+        context.total(),
+        orderId,
+        successful));
+                               });
     }
 
     private PlaceOrderResponse createOrder(ValidWithReservations context) {
         // Build order items with prices
-        var items = context.request().items().stream()
-            .map(item -> {
-                // Calculate unit price from total / quantity (simplified)
-                var unitPrice = Money.usd("29.99"); // Default price, in production would come from pricing
-                return new OrderRepository.OrderItem(item.productId(), item.quantity(), unitPrice);
-            })
-            .toList();
-
+        var items = context.request()
+                           .items()
+                           .stream()
+                           .map(item -> {
+                                    // Calculate unit price from total / quantity (simplified)
+        var unitPrice = Money.usd("29.99");
+                                    // Default price, in production would come from pricing
+        return new OrderRepository.OrderItem(item.productId(),
+                                             item.quantity(),
+                                             unitPrice);
+                                })
+                           .toList();
         // Store the order in the shared repository
         var order = new OrderRepository.StoredOrder(
-            context.orderId(),
-            context.request().customerId(),
-            OrderStatus.CONFIRMED,
-            context.total().total(),
-            items,
-            context.reservations().stream().map(StockReservation::reservationId).toList(),
-            java.time.Instant.now(),
-            java.time.Instant.now()
-        );
-        OrderRepository.instance().save(order);
-
+        context.orderId(),
+        context.request()
+               .customerId(),
+        OrderStatus.CONFIRMED,
+        context.total()
+               .total(),
+        items,
+        context.reservations()
+               .stream()
+               .map(StockReservation::reservationId)
+               .toList(),
+        java.time.Instant.now(),
+        java.time.Instant.now());
+        OrderRepository.instance()
+                       .save(order);
         return new PlaceOrderResponse(
-            context.orderId(),
-            OrderStatus.CONFIRMED,
-            context.total().total(),
-            context.reservations().stream().map(StockReservation::reservationId).toList()
-        );
+        context.orderId(),
+        OrderStatus.CONFIRMED,
+        context.total()
+               .total(),
+        context.reservations()
+               .stream()
+               .map(StockReservation::reservationId)
+               .toList());
     }
 
     // Pipeline context records
     private record ValidWithStockCheck(ValidPlaceOrderRequest request) {}
+
     private record ValidWithPrice(ValidPlaceOrderRequest request, OrderTotal total) {}
+
     private record ValidWithReservations(
-        ValidPlaceOrderRequest request,
-        OrderTotal total,
-        OrderId orderId,
-        List<StockReservation> reservations
-    ) {}
+    ValidPlaceOrderRequest request,
+    OrderTotal total,
+    OrderId orderId,
+    List<StockReservation> reservations) {}
 }
diff --git a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/ValidPlaceOrderRequest.java b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/ValidPlaceOrderRequest.java
index 51e39d18..43b42a5d 100644
--- a/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/ValidPlaceOrderRequest.java
+++ b/examples/order-demo/place-order/src/main/java/org/pragmatica/aether/demo/order/usecase/placeorder/ValidPlaceOrderRequest.java
@@ -8,29 +8,29 @@
 import java.util.List;
 
 public record ValidPlaceOrderRequest(
-    CustomerId customerId,
-    List<ValidOrderItem> items,
-    String discountCode
-) {
+ CustomerId customerId,
+ List<ValidOrderItem> items,
+ String discountCode) {
     public record ValidOrderItem(String productId, int quantity) {}
 
     public static Result<ValidPlaceOrderRequest> validPlaceOrderRequest(PlaceOrderRequest raw) {
         return CustomerId.customerId(raw.customerId())
                          .flatMap(customerId -> validateItems(raw.items())
-                             .map(items -> new ValidPlaceOrderRequest(customerId, items, raw.discountCode())));
+                                                .map(items -> new ValidPlaceOrderRequest(customerId,
+                                                                                         items,
+                                                                                         raw.discountCode())));
     }
 
     private static Result<List<ValidOrderItem>> validateItems(List<PlaceOrderRequest.OrderItemRequest> items) {
         if (items == null || items.isEmpty()) {
             return new PlaceOrderError.InvalidRequest("At least one item required").result();
         }
-
         var validated = items.stream()
-            .map(item -> Result.all(ProductId.productId(item.productId()),
-                                    Quantity.quantity(item.quantity()))
-                               .map((pid, qty) -> new ValidOrderItem(pid.value(), qty.value())))
-            .toList();
-
+                             .map(item -> Result.all(ProductId.productId(item.productId()),
+                                                     Quantity.quantity(item.quantity()))
+                                                .map((pid, qty) -> new ValidOrderItem(pid.value(),
+                                                                                      qty.value())))
+                             .toList();
         return Result.allOf(validated);
     }
 }
diff --git a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/GetPriceRequest.java b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/GetPriceRequest.java
index f96c0e50..67655ab6 100644
--- a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/GetPriceRequest.java
+++ b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/GetPriceRequest.java
@@ -1,3 +1,2 @@
 package org.pragmatica.aether.demo.order.pricing;
-
 public record GetPriceRequest(String productId) {}
diff --git a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingError.java b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingError.java
index 4edcea90..7ff98c0a 100644
--- a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingError.java
+++ b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingError.java
@@ -3,7 +3,6 @@
 import org.pragmatica.lang.Cause;
 
 public sealed interface PricingError extends Cause {
-
     record PriceNotFound(String productId) implements PricingError {
         @Override
         public String message() {
diff --git a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingServiceSlice.java b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingServiceSlice.java
index d93f6a21..d12bb3ec 100644
--- a/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingServiceSlice.java
+++ b/examples/order-demo/pricing-service/src/main/java/org/pragmatica/aether/demo/order/pricing/PricingServiceSlice.java
@@ -15,53 +15,48 @@
  * Pricing Service Slice - handles product pricing and order total calculation.
  */
 public record PricingServiceSlice() implements Slice {
+    private static final Map<String, BigDecimal>PRICES = Map.of(
+    "PROD-ABC123",
+    new BigDecimal("29.99"),
+    "PROD-DEF456",
+    new BigDecimal("49.99"),
+    "PROD-GHI789",
+    new BigDecimal("99.99"));
 
-    private static final Map<String, BigDecimal> PRICES = Map.of(
-        "PROD-ABC123", new BigDecimal("29.99"),
-        "PROD-DEF456", new BigDecimal("49.99"),
-        "PROD-GHI789", new BigDecimal("99.99")
-    );
-
-    private static final Map<String, BigDecimal> DISCOUNTS = Map.of(
-        "SAVE10", new BigDecimal("0.10"),
-        "SAVE20", new BigDecimal("0.20")
-    );
+    private static final Map<String, BigDecimal>DISCOUNTS = Map.of(
+    "SAVE10", new BigDecimal("0.10"), "SAVE20", new BigDecimal("0.20"));
 
     public static PricingServiceSlice pricingServiceSlice() {
         return new PricingServiceSlice();
     }
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("getPrice").unwrap(),
-                this::getPrice,
-                new TypeToken<ProductPrice>() {},
-                new TypeToken<GetPriceRequest>() {}
-            ),
-            new SliceMethod<>(
-                MethodName.methodName("calculateTotal").unwrap(),
-                this::calculateTotal,
-                new TypeToken<OrderTotal>() {},
-                new TypeToken<CalculateTotalRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("getPrice")
+                  .expect("Invalid method name: getPrice"),
+        this::getPrice,
+        new TypeToken<ProductPrice>() {},
+        new TypeToken<GetPriceRequest>() {}),
+        new SliceMethod<>(
+        MethodName.methodName("calculateTotal")
+                  .expect("Invalid method name: calculateTotal"),
+        this::calculateTotal,
+        new TypeToken<OrderTotal>() {},
+        new TypeToken<CalculateTotalRequest>() {}));
     }
 
     private Promise<ProductPrice> getPrice(GetPriceRequest request) {
         var price = PRICES.get(request.productId());
-
         if (price == null) {
             return new PricingError.PriceNotFound(request.productId()).promise();
         }
-
         return Promise.success(new ProductPrice(request.productId(), Money.usd(price)));
     }
 
     private Promise<OrderTotal> calculateTotal(CalculateTotalRequest request) {
         var subtotal = BigDecimal.ZERO;
-
         for (var item : request.items()) {
             var price = PRICES.get(item.productId());
             if (price == null) {
@@ -69,15 +64,14 @@ private Promise<OrderTotal> calculateTotal(CalculateTotalRequest request) {
             }
             subtotal = subtotal.add(price.multiply(BigDecimal.valueOf(item.quantity())));
         }
-
-        var discountRate = request.discountCode() != null ? DISCOUNTS.get(request.discountCode()) : null;
-        var discount = discountRate != null ? subtotal.multiply(discountRate) : BigDecimal.ZERO;
+        var discountRate = request.discountCode() != null
+                           ? DISCOUNTS.get(request.discountCode())
+                           : null;
+        var discount = discountRate != null
+                       ? subtotal.multiply(discountRate)
+                       : BigDecimal.ZERO;
         var total = subtotal.subtract(discount);
-
         return Promise.success(new OrderTotal(
-            Money.usd(subtotal),
-            Money.usd(discount),
-            Money.usd(total)
-        ));
+        Money.usd(subtotal), Money.usd(discount), Money.usd(total)));
     }
 }

From 80a8076ada94a460f1fd4cd20b4a4ed02ac94dfe Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 15:46:30 +0100
Subject: [PATCH 09/26] refactor: add SocketOptions, TlsConfig, ServerConfig to
 common

---
 .../java/org/pragmatica/net/NodeAddress.java  |   1 -
 .../main/java/org/pragmatica/net/Server.java  | 159 ++++++++++++------
 .../java/org/pragmatica/net/ServerConfig.java |  33 ++++
 .../org/pragmatica/net/SocketOptions.java     |  16 ++
 .../java/org/pragmatica/net/TlsConfig.java    |  59 +++++++
 .../org/pragmatica/net/TlsContextFactory.java |  57 +++++++
 .../java/org/pragmatica/net/TlsError.java     |  30 ++++
 .../net/serialization/Deserializer.java       |   5 +-
 .../net/serialization/Serializer.java         |   5 +-
 .../binary/ClassRegistrator.java              |   2 +-
 .../binary/fury/FuryDeserializer.java         |   9 +-
 .../binary/fury/FuryFactory.java              |  13 +-
 .../binary/fury/FurySerializer.java           |   9 +-
 .../binary/kryo/KryoDeserializer.java         |  14 +-
 .../binary/kryo/KryoPoolFactory.java          |  13 +-
 .../binary/kryo/KryoSerializer.java           |  11 +-
 16 files changed, 342 insertions(+), 94 deletions(-)
 create mode 100644 common/src/main/java/org/pragmatica/net/ServerConfig.java
 create mode 100644 common/src/main/java/org/pragmatica/net/SocketOptions.java
 create mode 100644 common/src/main/java/org/pragmatica/net/TlsConfig.java
 create mode 100644 common/src/main/java/org/pragmatica/net/TlsContextFactory.java
 create mode 100644 common/src/main/java/org/pragmatica/net/TlsError.java

diff --git a/common/src/main/java/org/pragmatica/net/NodeAddress.java b/common/src/main/java/org/pragmatica/net/NodeAddress.java
index 0f04d293..a071c5ff 100644
--- a/common/src/main/java/org/pragmatica/net/NodeAddress.java
+++ b/common/src/main/java/org/pragmatica/net/NodeAddress.java
@@ -10,7 +10,6 @@ public interface NodeAddress {
 
     static NodeAddress nodeAddress(String host, int port) {
         record nodeAddress(String host, int port) implements NodeAddress {}
-
         return new nodeAddress(host, port);
     }
 
diff --git a/common/src/main/java/org/pragmatica/net/Server.java b/common/src/main/java/org/pragmatica/net/Server.java
index 6e3a1669..d9e5699a 100644
--- a/common/src/main/java/org/pragmatica/net/Server.java
+++ b/common/src/main/java/org/pragmatica/net/Server.java
@@ -1,5 +1,12 @@
 package org.pragmatica.net;
 
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.lang.utils.Causes;
+
+import java.util.List;
+import java.util.function.Supplier;
+
 import io.netty.bootstrap.Bootstrap;
 import io.netty.bootstrap.ServerBootstrap;
 import io.netty.channel.*;
@@ -9,55 +16,60 @@
 import io.netty.channel.socket.nio.NioSocketChannel;
 import io.netty.handler.logging.LogLevel;
 import io.netty.handler.logging.LoggingHandler;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.utils.Causes;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
-import java.util.function.Supplier;
-
 /**
- * Convenient wrapper for Netty server setup boilerplate. It also enables connecting to other servers as client,
- * reusing the same channel handlers.
+ * Convenient wrapper for Netty server setup boilerplate.
+ * Supports TLS, socket options, and client connections reusing the same channel handlers.
  */
 public interface Server {
     String name();
 
+    int port();
+
     Promise<Channel> connectTo(NodeAddress peerLocation);
 
     /**
-     * Shutdown the server
+     * Shutdown the server.
      *
-     * @param intermediateOperation Operation to run between server channel shutdown and event loop groups shutdown
+     * @param intermediateOperation Operation to run between server channel shutdown and event loop groups shutdown.
+     *                              Enables graceful shutdown: stop accepting new connections, finish existing work, then shutdown.
      */
     Promise<Unit> stop(Supplier<Promise<Unit>> intermediateOperation);
 
-    static Promise<Server> server(String name, int port, Supplier<List<ChannelHandler>> channelHandlers) {
-        record server(String name, int port, EventLoopGroup bossGroup, EventLoopGroup workerGroup,
-                      Channel serverChannel,
-                      Supplier<List<ChannelHandler>> channelHandlers) implements Server {
+    /**
+     * Create a server with the given configuration.
+     *
+     * @param config          server configuration
+     * @param channelHandlers supplier for channel handlers (called for each new connection)
+     *
+     * @return promise of the running server
+     */
+    static Promise<Server> server(ServerConfig config, Supplier<List<ChannelHandler>> channelHandlers) {
+        record server(
+        String name,
+        int port,
+        EventLoopGroup bossGroup,
+        EventLoopGroup workerGroup,
+        Channel serverChannel,
+        Supplier<List<ChannelHandler>> channelHandlers) implements Server {
             private static final Logger log = LoggerFactory.getLogger(Server.class);
 
             @Override
             public Promise<Unit> stop(Supplier<Promise<Unit>> intermediate) {
                 var stopPromise = Promise.<Unit>promise();
                 log.trace("Stopping {}: closing server channel", name());
-
                 serverChannel.close()
-                             .addListener(_ ->
-                                                  intermediate.get()
-                                                              .onResult(_ -> shutdownGroups())
-                                                              .onResult(stopPromise::resolve));
-
+                             .addListener(_ -> intermediate.get()
+                                                           .onResult(_ -> shutdownGroups())
+                                                           .onResult(stopPromise::resolve));
                 return stopPromise;
             }
 
             private void shutdownGroups() {
                 log.debug("Stopping {}: shutting down boss group", name());
                 bossGroup.shutdownGracefully();
-
                 log.debug("Stopping {}: shutting down worker group", name());
                 workerGroup.shutdownGracefully();
                 log.info("Server {} stopped", name());
@@ -65,29 +77,31 @@ private void shutdownGroups() {
 
             @Override
             public Promise<Channel> connectTo(NodeAddress address) {
-                var bootstrap = new Bootstrap()
-                        .group(workerGroup)
-                        .channel(NioSocketChannel.class)
-                        .handler(server.createChildHandler(channelHandlers));
-
+                var bootstrap = new Bootstrap().group(workerGroup)
+                                .channel(NioSocketChannel.class)
+                                .handler(createChildHandler(channelHandlers, null));
                 var promise = Promise.<Channel>promise();
-                bootstrap.connect(address.host(), address.port())
+                bootstrap.connect(address.host(),
+                                  address.port())
                          .addListener((ChannelFutureListener) future -> {
-                             if (future.isSuccess()) {
-                                 promise.succeed(future.channel());
-                             } else {
-                                 promise.fail(Causes.fromThrowable(future.cause()));
-                             }
-                         });
+                                          if (future.isSuccess()) {
+                                          promise.succeed(future.channel());
+                                      }else {
+                                          promise.fail(Causes.fromThrowable(future.cause()));
+                                      }
+                                      });
                 return promise;
             }
 
-            private static ChannelInitializer<SocketChannel> createChildHandler(Supplier<List<ChannelHandler>> channelHandlers) {
+            private static ChannelInitializer<SocketChannel> createChildHandler(Supplier<List<ChannelHandler>> channelHandlers,
+                                                                                io.netty.handler.ssl.SslContext sslContext) {
                 return new ChannelInitializer<>() {
                     @Override
                     protected void initChannel(SocketChannel ch) {
                         var pipeline = ch.pipeline();
-
+                        if (sslContext != null) {
+                            pipeline.addLast(sslContext.newHandler(ch.alloc()));
+                        }
                         for (var handler : channelHandlers.get()) {
                             pipeline.addLast(handler);
                         }
@@ -95,26 +109,67 @@ protected void initChannel(SocketChannel ch) {
                 };
             }
         }
-
+        // Handle TLS configuration
+        var sslContextResult = config.tls()
+                                     .map(TlsContextFactory::create)
+                                     .fold(() -> null,
+                                           result -> result);
+        if (sslContextResult != null && sslContextResult.isFailure()) {
+            return sslContextResult.mapError(cause -> cause)
+                                   .<Server> map(_ -> null)
+                                   .async();
+        }
+        var sslContext = sslContextResult != null
+                         ? sslContextResult.fold(_ -> null, ctx -> ctx)
+                         : null;
         var bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
         var workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
-        var bootstrap = new ServerBootstrap()
-                .group(bossGroup, workerGroup)
-                .channel(NioServerSocketChannel.class)
-                .handler(new LoggingHandler(LogLevel.TRACE))
-                .childHandler(server.createChildHandler(channelHandlers));
-
+        var socketOptions = config.socketOptions();
+        var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
+                        .channel(NioServerSocketChannel.class)
+                        .handler(new LoggingHandler(LogLevel.TRACE))
+                        .childHandler(server.createChildHandler(channelHandlers, sslContext))
+                        .option(ChannelOption.SO_BACKLOG,
+                                socketOptions.soBacklog())
+                        .childOption(ChannelOption.SO_KEEPALIVE,
+                                     socketOptions.soKeepalive());
         var promise = Promise.<Server>promise();
-
-        bootstrap.bind(port).addListener((ChannelFutureListener) future -> {
-            if (future.isSuccess()) {
-                server.log.info("Server {} started on port {}", name, port);
-                promise.succeed(new server(name, port, bossGroup, workerGroup, future.channel(), channelHandlers));
-            } else {
-                promise.fail(Causes.fromThrowable(future.cause()));
-            }
-        });
-
+        bootstrap.bind(config.port())
+                 .addListener((ChannelFutureListener) future -> {
+                                  if (future.isSuccess()) {
+                                  var protocol = sslContext != null
+                                                 ? "TLS"
+                                                 : "TCP";
+                                  server.log.info("Server {} started on port {} ({})",
+                                                  config.name(),
+                                                  config.port(),
+                                                  protocol);
+                                  promise.succeed(new server(
+        config.name(),
+        config.port(),
+        bossGroup,
+        workerGroup,
+        future.channel(),
+        channelHandlers));
+                              }else {
+                                  bossGroup.shutdownGracefully();
+                                  workerGroup.shutdownGracefully();
+                                  promise.fail(Causes.fromThrowable(future.cause()));
+                              }
+                              });
         return promise;
     }
+
+    /**
+     * Create a server with simple configuration.
+     *
+     * @param name            server name for logging
+     * @param port            port to bind to
+     * @param channelHandlers supplier for channel handlers
+     *
+     * @return promise of the running server
+     */
+    static Promise<Server> server(String name, int port, Supplier<List<ChannelHandler>> channelHandlers) {
+        return server(ServerConfig.serverConfig(name, port), channelHandlers);
+    }
 }
diff --git a/common/src/main/java/org/pragmatica/net/ServerConfig.java b/common/src/main/java/org/pragmatica/net/ServerConfig.java
new file mode 100644
index 00000000..395a191e
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/ServerConfig.java
@@ -0,0 +1,33 @@
+package org.pragmatica.net;
+
+import org.pragmatica.lang.Option;
+
+/**
+ * Configuration for TCP server.
+ *
+ * @param name          server name for logging
+ * @param port          port to bind to
+ * @param tls           optional TLS configuration for secure connections
+ * @param socketOptions socket-level options
+ */
+public record ServerConfig(
+ String name,
+ int port,
+ Option<TlsConfig> tls,
+ SocketOptions socketOptions) {
+    public static ServerConfig serverConfig(String name, int port) {
+        return new ServerConfig(name, port, Option.empty(), SocketOptions.defaults());
+    }
+
+    public static ServerConfig serverConfig(String name, int port, TlsConfig tls) {
+        return new ServerConfig(name, port, Option.some(tls), SocketOptions.defaults());
+    }
+
+    public ServerConfig withTls(TlsConfig tls) {
+        return new ServerConfig(name, port, Option.some(tls), socketOptions);
+    }
+
+    public ServerConfig withSocketOptions(SocketOptions socketOptions) {
+        return new ServerConfig(name, port, tls, socketOptions);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/SocketOptions.java b/common/src/main/java/org/pragmatica/net/SocketOptions.java
new file mode 100644
index 00000000..0027fcf2
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/SocketOptions.java
@@ -0,0 +1,16 @@
+package org.pragmatica.net;
+/**
+ * Socket-level options for server configuration.
+ *
+ * @param soBacklog   maximum queue length for incoming connection requests (SO_BACKLOG)
+ * @param soKeepalive whether to enable TCP keepalive probes (SO_KEEPALIVE)
+ */
+public record SocketOptions(int soBacklog, boolean soKeepalive) {
+    public static SocketOptions socketOptions(int soBacklog, boolean soKeepalive) {
+        return new SocketOptions(soBacklog, soKeepalive);
+    }
+
+    public static SocketOptions defaults() {
+        return new SocketOptions(128, true);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/TlsConfig.java b/common/src/main/java/org/pragmatica/net/TlsConfig.java
new file mode 100644
index 00000000..1223d78c
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/TlsConfig.java
@@ -0,0 +1,59 @@
+package org.pragmatica.net;
+
+import org.pragmatica.lang.Option;
+
+import java.nio.file.Path;
+
+/**
+ * TLS configuration for secure server connections.
+ * <p>
+ * Two modes supported:
+ * <ul>
+ *   <li>{@link SelfSigned} - generates self-signed certificate at startup (for development)</li>
+ *   <li>{@link FromFiles} - loads certificate and private key from PEM files (for production)</li>
+ * </ul>
+ */
+public sealed interface TlsConfig {
+    /**
+     * Self-signed certificate generated at startup.
+     * Suitable for development and testing only.
+     */
+    record SelfSigned() implements TlsConfig {}
+
+    /**
+     * Certificate and private key loaded from PEM files.
+     * Suitable for production use.
+     */
+    record FromFiles(
+    Path certificatePath,
+    Path privateKeyPath,
+    Option<String> keyPassword) implements TlsConfig {}
+
+    /**
+     * Create self-signed TLS configuration.
+     */
+    static TlsConfig selfSigned() {
+        return new SelfSigned();
+    }
+
+    /**
+     * Create TLS configuration from certificate files.
+     *
+     * @param certificatePath path to PEM certificate file
+     * @param privateKeyPath  path to PEM private key file
+     */
+    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath) {
+        return new FromFiles(certificatePath, privateKeyPath, Option.empty());
+    }
+
+    /**
+     * Create TLS configuration from password-protected certificate files.
+     *
+     * @param certificatePath path to PEM certificate file
+     * @param privateKeyPath  path to PEM private key file
+     * @param keyPassword     password for the private key
+     */
+    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath, String keyPassword) {
+        return new FromFiles(certificatePath, privateKeyPath, Option.some(keyPassword));
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/TlsContextFactory.java b/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
new file mode 100644
index 00000000..c0227170
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
@@ -0,0 +1,57 @@
+package org.pragmatica.net;
+
+import org.pragmatica.lang.Result;
+
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.ssl.SslContextBuilder;
+import io.netty.handler.ssl.util.SelfSignedCertificate;
+
+/**
+ * Factory for creating Netty SSL contexts from TLS configuration.
+ */
+public final class TlsContextFactory {
+    private TlsContextFactory() {}
+
+    /**
+     * Create SSL context from TLS configuration.
+     *
+     * @param config TLS configuration
+     *
+     * @return SSL context or error
+     */
+    public static Result<SslContext> create(TlsConfig config) {
+        return switch (config) {
+            case TlsConfig.SelfSigned() -> createSelfSigned();
+            case TlsConfig.FromFiles fromFiles -> createFromFiles(fromFiles);
+        };
+    }
+
+    private static Result<SslContext> createSelfSigned() {
+        try{
+            var ssc = new SelfSignedCertificate();
+            var sslContext = SslContextBuilder.forServer(ssc.certificate(),
+                                                         ssc.privateKey())
+                                              .build();
+            return Result.success(sslContext);
+        } catch (Exception e) {
+            return new TlsError.SelfSignedGenerationFailed(e).result();
+        }
+    }
+
+    private static Result<SslContext> createFromFiles(TlsConfig.FromFiles config) {
+        try{
+            var password = config.keyPassword()
+                                 .fold(() -> null,
+                                       pwd -> pwd);
+            var builder = SslContextBuilder.forServer(
+            config.certificatePath()
+                  .toFile(),
+            config.privateKeyPath()
+                  .toFile(),
+            password);
+            return Result.success(builder.build());
+        } catch (Exception e) {
+            return new TlsError.CertificateLoadFailed(config.certificatePath(), e).result();
+        }
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/TlsError.java b/common/src/main/java/org/pragmatica/net/TlsError.java
new file mode 100644
index 00000000..6802f1b0
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/TlsError.java
@@ -0,0 +1,30 @@
+package org.pragmatica.net;
+
+import org.pragmatica.lang.Cause;
+
+import java.nio.file.Path;
+
+/**
+ * Error types for TLS operations.
+ */
+public sealed interface TlsError extends Cause {
+    /**
+     * Failed to load certificate from file.
+     */
+    record CertificateLoadFailed(Path path, Throwable cause) implements TlsError {
+        @Override
+        public String message() {
+            return "Failed to load certificate from " + path + ": " + cause.getMessage();
+        }
+    }
+
+    /**
+     * Failed to generate self-signed certificate.
+     */
+    record SelfSignedGenerationFailed(Throwable cause) implements TlsError {
+        @Override
+        public String message() {
+            return "Failed to generate self-signed certificate: " + cause.getMessage();
+        }
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java b/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
index a7e11bdf..a4d24a39 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
@@ -7,10 +7,9 @@
 public interface Deserializer {
     default <T> T decode(byte[] bytes) {
         var byteBuf = Unpooled.wrappedBuffer(bytes);
-
-        try {
+        try{
             return read(byteBuf);
-        } finally {
+        } finally{
             byteBuf.release();
         }
     }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/Serializer.java b/common/src/main/java/org/pragmatica/net/serialization/Serializer.java
index 1121dec9..17a48af7 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/Serializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/Serializer.java
@@ -7,11 +7,10 @@
 public interface Serializer {
     default <T> byte[] encode(T object) {
         var byteBuf = Unpooled.buffer();
-
-        try {
+        try{
             write(byteBuf, object);
             return byteBuf.array();
-        } finally {
+        } finally{
             byteBuf.release();
         }
     }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java b/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
index 912dd228..728119b3 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
@@ -3,5 +3,5 @@
 import java.util.function.Consumer;
 
 public interface ClassRegistrator {
-    void registerClasses(Consumer<Class<?>> consumer);
+    void registerClasses(Consumer<Class< ? >> consumer);
 }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
index 77671b6d..063e0d60 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
@@ -1,11 +1,12 @@
 package org.pragmatica.net.serialization.binary.fury;
 
+import org.pragmatica.net.serialization.Deserializer;
+import org.pragmatica.net.serialization.binary.ClassRegistrator;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufInputStream;
 import org.apache.fury.ThreadSafeFury;
 import org.apache.fury.io.FuryInputStream;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -18,14 +19,14 @@ record furyDeserializer(ThreadSafeFury fury) implements FuryDeserializer {
             @Override
             public <T> T read(ByteBuf byteBuf) {
                 try (var stream = new FuryInputStream(new ByteBufInputStream(byteBuf))) {
-                    return (T) fury().deserialize(stream);
+                    return (T) fury()
+                              .deserialize(stream);
                 } catch (Exception e) {
                     log.error("Error deserializing object", e);
                     throw new RuntimeException(e);
                 }
             }
         }
-
         return new furyDeserializer(FuryFactory.fury(registrators));
     }
 }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
index 8f4909b5..5f8a26ea 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
@@ -1,23 +1,22 @@
 package org.pragmatica.net.serialization.binary.fury;
 
-import org.apache.fury.Fury;
-import org.apache.fury.ThreadSafeFury;
-import org.apache.fury.config.Language;
 import org.pragmatica.net.serialization.binary.ClassRegistrator;
 
 import java.util.stream.Stream;
 
-public sealed interface FuryFactory {
+import org.apache.fury.Fury;
+import org.apache.fury.ThreadSafeFury;
+import org.apache.fury.config.Language;
 
+public sealed interface FuryFactory {
     static ThreadSafeFury fury(ClassRegistrator... registrators) {
-        int coreCount = Runtime.getRuntime().availableProcessors();
+        int coreCount = Runtime.getRuntime()
+                               .availableProcessors();
         var fury = Fury.builder()
                        .withLanguage(Language.JAVA)
                        .buildThreadSafeFuryPool(coreCount * 2, coreCount * 4);
-
         Stream.of(registrators)
               .forEach(registrator -> registrator.registerClasses(fury::register));
-
         return fury;
     }
 
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
index 38e1b30b..4329cc8c 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
@@ -1,10 +1,11 @@
 package org.pragmatica.net.serialization.binary.fury;
 
+import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.net.serialization.binary.ClassRegistrator;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufOutputStream;
 import org.apache.fury.ThreadSafeFury;
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -16,14 +17,14 @@ record furySerializer(ThreadSafeFury fury) implements FurySerializer {
             @Override
             public <T> void write(ByteBuf byteBuf, T object) {
                 try (var outputStream = new ByteBufOutputStream(byteBuf)) {
-                    fury().serialize(outputStream, object);
+                    fury()
+                    .serialize(outputStream, object);
                 } catch (Exception e) {
                     log.error("Error serializing object", e);
                     throw new RuntimeException(e);
                 }
             }
         }
-
         return new furySerializer(FuryFactory.fury(registrators));
     }
 }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
index 731e49af..982275c8 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
@@ -1,12 +1,13 @@
 package org.pragmatica.net.serialization.binary.kryo;
 
+import org.pragmatica.net.serialization.Deserializer;
+import org.pragmatica.net.serialization.binary.ClassRegistrator;
+
 import com.esotericsoftware.kryo.Kryo;
 import com.esotericsoftware.kryo.io.Input;
 import com.esotericsoftware.kryo.util.Pool;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufInputStream;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -19,19 +20,18 @@ record kryoDeserializer(Pool<Kryo> pool) implements KryoDeserializer {
             @Override
             public <T> T read(ByteBuf byteBuf) {
                 var kryo = pool.obtain();
-
                 try (var byteBufInputStream = new ByteBufInputStream(byteBuf);
-                     var input = new Input(byteBufInputStream)) {
+                var input = new Input(byteBufInputStream)) {
                     return (T) kryo.readClassAndObject(input);
                 } catch (Exception e) {
                     log.error("Error deserializing object", e);
                     throw new RuntimeException(e);
-                } finally {
-                    pool().free(kryo);
+                } finally{
+                    pool()
+                    .free(kryo);
                 }
             }
         }
-
         return new kryoDeserializer(KryoPoolFactory.kryoPool(registrators));
     }
 }
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
index 802c0623..272b57a4 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
@@ -1,22 +1,23 @@
 package org.pragmatica.net.serialization.binary.kryo;
 
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.util.Pool;
 import org.pragmatica.net.serialization.binary.ClassRegistrator;
 
 import java.util.stream.Stream;
 
-public sealed interface KryoPoolFactory {
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.util.Pool;
 
+public sealed interface KryoPoolFactory {
     static Pool<Kryo> kryoPool(ClassRegistrator... registrators) {
-        return new Pool<>(true, false, Runtime.getRuntime().availableProcessors() * 2) {
+        return new Pool<>(true,
+                          false,
+                          Runtime.getRuntime()
+                                 .availableProcessors() * 2) {
             @Override
             protected Kryo create() {
                 var kryo = new Kryo();
-
                 Stream.of(registrators)
                       .forEach(registrator -> registrator.registerClasses(kryo::register));
-
                 return kryo;
             }
         };
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
index 0e3a3ba0..dc14daa7 100644
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
+++ b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
@@ -1,12 +1,13 @@
 package org.pragmatica.net.serialization.binary.kryo;
 
+import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.net.serialization.binary.ClassRegistrator;
+
 import com.esotericsoftware.kryo.Kryo;
 import com.esotericsoftware.kryo.io.Output;
 import com.esotericsoftware.kryo.util.Pool;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufOutputStream;
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -18,19 +19,17 @@ record kryoSerializer(Pool<Kryo> pool) implements KryoSerializer {
             @Override
             public <T> void write(ByteBuf byteBuf, T object) {
                 var kryo = pool.obtain();
-
                 try (var byteBufOutputStream = new ByteBufOutputStream(byteBuf);
-                     var output = new Output(byteBufOutputStream)) {
+                var output = new Output(byteBufOutputStream)) {
                     kryo.writeClassAndObject(output, object);
                 } catch (Exception e) {
                     log.error("Error serializing object", e);
                     throw new RuntimeException(e);
-                } finally {
+                } finally{
                     pool.free(kryo);
                 }
             }
         }
-
         return new kryoSerializer(KryoPoolFactory.kryoPool(registrators));
     }
 }

From 11ed174ae153e1e78261f42fae0c86dd832b5f9b Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 15:48:19 +0100
Subject: [PATCH 10/26] refactor: add HTTP value objects to common

---
 .../pragmatica/http/CommonContentType.java    | 30 ++++++++
 .../org/pragmatica/http/ContentCategory.java  | 10 +++
 .../java/org/pragmatica/http/ContentType.java | 16 ++++
 .../java/org/pragmatica/http/Headers.java     | 74 +++++++++++++++++++
 .../java/org/pragmatica/http/HttpMethod.java  | 32 ++++++++
 .../java/org/pragmatica/http/HttpStatus.java  | 56 ++++++++++++++
 .../java/org/pragmatica/http/QueryParams.java | 70 ++++++++++++++++++
 7 files changed, 288 insertions(+)
 create mode 100644 common/src/main/java/org/pragmatica/http/CommonContentType.java
 create mode 100644 common/src/main/java/org/pragmatica/http/ContentCategory.java
 create mode 100644 common/src/main/java/org/pragmatica/http/ContentType.java
 create mode 100644 common/src/main/java/org/pragmatica/http/Headers.java
 create mode 100644 common/src/main/java/org/pragmatica/http/HttpMethod.java
 create mode 100644 common/src/main/java/org/pragmatica/http/HttpStatus.java
 create mode 100644 common/src/main/java/org/pragmatica/http/QueryParams.java

diff --git a/common/src/main/java/org/pragmatica/http/CommonContentType.java b/common/src/main/java/org/pragmatica/http/CommonContentType.java
new file mode 100644
index 00000000..7665d95b
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/CommonContentType.java
@@ -0,0 +1,30 @@
+package org.pragmatica.http;
+/**
+ * Common HTTP content types.
+ */
+public enum CommonContentType implements ContentType {
+    TEXT_PLAIN("text/plain; charset=UTF-8", ContentCategory.TEXT),
+    TEXT_HTML("text/html; charset=UTF-8", ContentCategory.TEXT),
+    TEXT_CSS("text/css; charset=UTF-8", ContentCategory.TEXT),
+    TEXT_JAVASCRIPT("text/javascript; charset=UTF-8", ContentCategory.TEXT),
+    APPLICATION_JSON("application/json; charset=UTF-8", ContentCategory.JSON),
+    APPLICATION_XML("application/xml; charset=UTF-8", ContentCategory.XML),
+    APPLICATION_OCTET_STREAM("application/octet-stream", ContentCategory.BINARY),
+    IMAGE_PNG("image/png", ContentCategory.BINARY),
+    IMAGE_JPEG("image/jpeg", ContentCategory.BINARY),
+    IMAGE_SVG("image/svg+xml", ContentCategory.XML);
+    private final String headerText;
+    private final ContentCategory category;
+    CommonContentType(String headerText, ContentCategory category) {
+        this.headerText = headerText;
+        this.category = category;
+    }
+    @Override
+    public String headerText() {
+        return headerText;
+    }
+    @Override
+    public ContentCategory category() {
+        return category;
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/ContentCategory.java b/common/src/main/java/org/pragmatica/http/ContentCategory.java
new file mode 100644
index 00000000..792cd978
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/ContentCategory.java
@@ -0,0 +1,10 @@
+package org.pragmatica.http;
+/**
+ * Content type categories for HTTP responses.
+ */
+public enum ContentCategory {
+    TEXT,
+    JSON,
+    BINARY,
+    XML
+}
diff --git a/common/src/main/java/org/pragmatica/http/ContentType.java b/common/src/main/java/org/pragmatica/http/ContentType.java
new file mode 100644
index 00000000..54dfd324
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/ContentType.java
@@ -0,0 +1,16 @@
+package org.pragmatica.http;
+/**
+ * HTTP Content-Type abstraction.
+ * <p>
+ * Use {@link CommonContentType} for standard content types, or create custom ones via factory method.
+ */
+public interface ContentType {
+    String headerText();
+
+    ContentCategory category();
+
+    static ContentType contentType(String headerText, ContentCategory category) {
+        record contentType(String headerText, ContentCategory category) implements ContentType {}
+        return new contentType(headerText, category);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/Headers.java b/common/src/main/java/org/pragmatica/http/Headers.java
new file mode 100644
index 00000000..7d4562a7
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/Headers.java
@@ -0,0 +1,74 @@
+package org.pragmatica.http;
+
+import org.pragmatica.lang.Option;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * HTTP headers with case-insensitive lookup (per HTTP specification).
+ */
+public interface Headers {
+    /**
+     * Get the first value for a header (case-insensitive lookup).
+     */
+    Option<String> get(String name);
+
+    /**
+     * Get all values for a header (case-insensitive lookup).
+     */
+    List<String> getAll(String name);
+
+    /**
+     * Get all headers as a map (keys are lowercase).
+     */
+    Map<String, List<String>> asMap();
+
+    /**
+     * Create headers from a raw map (will be normalized to lowercase keys).
+     */
+    static Headers headers(Map<String, List<String>> raw) {
+        record headers(Map<String, List<String>> normalized) implements Headers {
+            @Override
+            public Option<String> get(String name) {
+                var values = normalized.get(name.toLowerCase());
+                return values == null || values.isEmpty()
+                       ? Option.empty()
+                       : Option.some(values.getFirst());
+            }
+
+            @Override
+            public List<String> getAll(String name) {
+                var values = normalized.get(name.toLowerCase());
+                return values == null
+                       ? List.of()
+                       : values;
+            }
+
+            @Override
+            public Map<String, List<String>> asMap() {
+                return normalized;
+            }
+        }
+        var normalized = new HashMap<String, List<String>>();
+        raw.forEach((k, v) -> normalized.put(k.toLowerCase(), List.copyOf(v)));
+        return new headers(Map.copyOf(normalized));
+    }
+
+    /**
+     * Create headers from a single-value map (convenience for simple cases).
+     */
+    static Headers fromSingleValueMap(Map<String, String> raw) {
+        var multi = new HashMap<String, List<String>>();
+        raw.forEach((k, v) -> multi.put(k.toLowerCase(), List.of(v)));
+        return headers(multi);
+    }
+
+    /**
+     * Empty headers.
+     */
+    static Headers empty() {
+        return headers(Map.of());
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/HttpMethod.java b/common/src/main/java/org/pragmatica/http/HttpMethod.java
new file mode 100644
index 00000000..8c31e76e
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/HttpMethod.java
@@ -0,0 +1,32 @@
+package org.pragmatica.http;
+/**
+ * HTTP request methods.
+ */
+public enum HttpMethod {
+    GET,
+    POST,
+    PUT,
+    DELETE,
+    PATCH,
+    HEAD,
+    OPTIONS,
+    TRACE,
+    CONNECT;
+    /**
+     * Parse HTTP method from string.
+     */
+    public static HttpMethod from(String method) {
+        return switch (method.toUpperCase()) {
+            case"GET" -> GET;
+            case"POST" -> POST;
+            case"PUT" -> PUT;
+            case"DELETE" -> DELETE;
+            case"PATCH" -> PATCH;
+            case"HEAD" -> HEAD;
+            case"OPTIONS" -> OPTIONS;
+            case"TRACE" -> TRACE;
+            case"CONNECT" -> CONNECT;
+            default -> throw new IllegalArgumentException("Unknown HTTP method: " + method);
+        };
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/HttpStatus.java b/common/src/main/java/org/pragmatica/http/HttpStatus.java
new file mode 100644
index 00000000..25b49a10
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/HttpStatus.java
@@ -0,0 +1,56 @@
+package org.pragmatica.http;
+/**
+ * HTTP response status codes.
+ */
+public enum HttpStatus {
+    // 2xx Success
+    OK(200, "OK"),
+    CREATED(201, "Created"),
+    ACCEPTED(202, "Accepted"),
+    NO_CONTENT(204, "No Content"),
+    // 3xx Redirection
+    MOVED_PERMANENTLY(301, "Moved Permanently"),
+    FOUND(302, "Found"),
+    NOT_MODIFIED(304, "Not Modified"),
+    TEMPORARY_REDIRECT(307, "Temporary Redirect"),
+    PERMANENT_REDIRECT(308, "Permanent Redirect"),
+    // 4xx Client Errors
+    BAD_REQUEST(400, "Bad Request"),
+    UNAUTHORIZED(401, "Unauthorized"),
+    FORBIDDEN(403, "Forbidden"),
+    NOT_FOUND(404, "Not Found"),
+    METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
+    CONFLICT(409, "Conflict"),
+    UNPROCESSABLE_ENTITY(422, "Unprocessable Entity"),
+    TOO_MANY_REQUESTS(429, "Too Many Requests"),
+    // 5xx Server Errors
+    INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
+    NOT_IMPLEMENTED(501, "Not Implemented"),
+    BAD_GATEWAY(502, "Bad Gateway"),
+    SERVICE_UNAVAILABLE(503, "Service Unavailable"),
+    GATEWAY_TIMEOUT(504, "Gateway Timeout");
+    private final int code;
+    private final String reasonPhrase;
+    HttpStatus(int code, String reasonPhrase) {
+        this.code = code;
+        this.reasonPhrase = reasonPhrase;
+    }
+    public int code() {
+        return code;
+    }
+    public String reasonPhrase() {
+        return reasonPhrase;
+    }
+    public boolean isSuccess() {
+        return code >= 200 && code < 300;
+    }
+    public boolean isRedirect() {
+        return code >= 300 && code < 400;
+    }
+    public boolean isClientError() {
+        return code >= 400 && code < 500;
+    }
+    public boolean isServerError() {
+        return code >= 500 && code < 600;
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/QueryParams.java b/common/src/main/java/org/pragmatica/http/QueryParams.java
new file mode 100644
index 00000000..1c241d34
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/QueryParams.java
@@ -0,0 +1,70 @@
+package org.pragmatica.http;
+
+import org.pragmatica.lang.Option;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * HTTP query parameters.
+ */
+public interface QueryParams {
+    /**
+     * Get the first value for a parameter.
+     */
+    Option<String> get(String name);
+
+    /**
+     * Get all values for a parameter.
+     */
+    List<String> getAll(String name);
+
+    /**
+     * Get all parameters as a map.
+     */
+    Map<String, List<String>> asMap();
+
+    /**
+     * Check if parameter exists.
+     */
+    default boolean has(String name) {
+        return get(name)
+               .isPresent();
+    }
+
+    /**
+     * Create query parameters from a map.
+     */
+    static QueryParams queryParams(Map<String, List<String>> raw) {
+        record queryParams(Map<String, List<String>> params) implements QueryParams {
+            @Override
+            public Option<String> get(String name) {
+                var values = params.get(name);
+                return values == null || values.isEmpty()
+                       ? Option.empty()
+                       : Option.some(values.getFirst());
+            }
+
+            @Override
+            public List<String> getAll(String name) {
+                var values = params.get(name);
+                return values == null
+                       ? List.of()
+                       : values;
+            }
+
+            @Override
+            public Map<String, List<String>> asMap() {
+                return params;
+            }
+        }
+        return new queryParams(Map.copyOf(raw));
+    }
+
+    /**
+     * Empty query parameters.
+     */
+    static QueryParams empty() {
+        return queryParams(Map.of());
+    }
+}

From 06240496257b5a8305c17283773d00658ece9bfa Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 15:49:32 +0100
Subject: [PATCH 11/26] feat: add WebSocket abstractions to common

---
 .../http/websocket/WebSocketEndpoint.java     | 19 ++++++++++++
 .../http/websocket/WebSocketHandler.java      | 16 ++++++++++
 .../http/websocket/WebSocketMessage.java      | 25 ++++++++++++++++
 .../http/websocket/WebSocketSession.java      | 30 +++++++++++++++++++
 4 files changed, 90 insertions(+)
 create mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
 create mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
 create mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
 create mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java

diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
new file mode 100644
index 00000000..f6ab4cd3
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
@@ -0,0 +1,19 @@
+package org.pragmatica.http.websocket;
+
+import java.util.function.Supplier;
+
+/**
+ * WebSocket endpoint configuration.
+ *
+ * @param path    the WebSocket path (e.g., "/ws/events")
+ * @param handler supplier for WebSocket handler (called for each new connection)
+ */
+public record WebSocketEndpoint(String path, Supplier<WebSocketHandler> handler) {
+    public static WebSocketEndpoint webSocketEndpoint(String path, Supplier<WebSocketHandler> handler) {
+        return new WebSocketEndpoint(path, handler);
+    }
+
+    public static WebSocketEndpoint webSocketEndpoint(String path, WebSocketHandler handler) {
+        return new WebSocketEndpoint(path, () -> handler);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
new file mode 100644
index 00000000..d7b89ae6
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
@@ -0,0 +1,16 @@
+package org.pragmatica.http.websocket;
+/**
+ * Handler for WebSocket messages.
+ * <p>
+ * All message types (Open, Text, Binary, Close) are delivered through the single
+ * {@link #handle(WebSocketSession, WebSocketMessage)} method.
+ */
+public interface WebSocketHandler {
+    /**
+     * Handle a WebSocket message.
+     *
+     * @param session the session that received the message
+     * @param message the message (Open, Text, Binary, or Close)
+     */
+    void handle(WebSocketSession session, WebSocketMessage message);
+}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
new file mode 100644
index 00000000..ff780d7b
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
@@ -0,0 +1,25 @@
+package org.pragmatica.http.websocket;
+/**
+ * WebSocket message types.
+ */
+public sealed interface WebSocketMessage {
+    /**
+     * Connection opened.
+     */
+    record Open() implements WebSocketMessage {}
+
+    /**
+     * Text message received.
+     */
+    record Text(String content) implements WebSocketMessage {}
+
+    /**
+     * Binary message received.
+     */
+    record Binary(byte[] content) implements WebSocketMessage {}
+
+    /**
+     * Connection closed.
+     */
+    record Close() implements WebSocketMessage {}
+}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java
new file mode 100644
index 00000000..22dba104
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java
@@ -0,0 +1,30 @@
+package org.pragmatica.http.websocket;
+/**
+ * WebSocket session for sending messages and managing connection.
+ */
+public interface WebSocketSession {
+    /**
+     * Unique session identifier.
+     */
+    String id();
+
+    /**
+     * Send a text message.
+     */
+    void send(String text);
+
+    /**
+     * Send a binary message.
+     */
+    void send(byte[] binary);
+
+    /**
+     * Close the connection.
+     */
+    void close();
+
+    /**
+     * Check if the session is still open.
+     */
+    boolean isOpen();
+}

From fe6a2525bd91c61fa4c8ad0f77dda4eca0cfc3dc Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 15:53:49 +0100
Subject: [PATCH 12/26] feat: add HttpServer to common module

---
 .../pragmatica/http/server/HttpServer.java    |  33 ++
 .../http/server/HttpServerConfig.java         |  82 ++++
 .../http/server/HttpServerError.java          |  28 ++
 .../http/server/NettyHttpServer.java          | 373 ++++++++++++++++++
 .../http/server/RequestContext.java           |  52 +++
 .../http/server/ResponseWriter.java           | 108 +++++
 6 files changed, 676 insertions(+)
 create mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServer.java
 create mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
 create mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServerError.java
 create mode 100644 common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
 create mode 100644 common/src/main/java/org/pragmatica/http/server/RequestContext.java
 create mode 100644 common/src/main/java/org/pragmatica/http/server/ResponseWriter.java

diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServer.java b/common/src/main/java/org/pragmatica/http/server/HttpServer.java
new file mode 100644
index 00000000..3809d933
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/HttpServer.java
@@ -0,0 +1,33 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+
+import java.util.function.BiConsumer;
+
+/**
+ * HTTP server abstraction.
+ */
+public interface HttpServer {
+    /**
+     * Server port.
+     */
+    int port();
+
+    /**
+     * Stop the server.
+     */
+    Promise<Unit> stop();
+
+    /**
+     * Create and start an HTTP server.
+     *
+     * @param config  server configuration
+     * @param handler request handler
+     *
+     * @return promise of the running server
+     */
+    static Promise<HttpServer> httpServer(HttpServerConfig config, BiConsumer<RequestContext, ResponseWriter> handler) {
+        return NettyHttpServer.create(config, handler);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java b/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
new file mode 100644
index 00000000..e9be9097
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
@@ -0,0 +1,82 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.http.websocket.WebSocketEndpoint;
+import org.pragmatica.lang.Option;
+import org.pragmatica.net.SocketOptions;
+import org.pragmatica.net.TlsConfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Configuration for HTTP server.
+ *
+ * @param name                 server name for logging
+ * @param port                 port to bind to
+ * @param tls                  optional TLS configuration
+ * @param maxContentLength     maximum content length for requests
+ * @param webSocketEndpoints   WebSocket endpoints
+ * @param chunkedWriteEnabled  whether to enable chunked transfer encoding
+ * @param socketOptions        socket-level options
+ */
+public record HttpServerConfig(
+ String name,
+ int port,
+ Option<TlsConfig> tls,
+ int maxContentLength,
+ List<WebSocketEndpoint> webSocketEndpoints,
+ boolean chunkedWriteEnabled,
+ SocketOptions socketOptions) {
+    private static final int DEFAULT_MAX_CONTENT_LENGTH = 65536;
+
+    public static HttpServerConfig httpServerConfig(String name, int port) {
+        return new HttpServerConfig(
+        name, port, Option.empty(), DEFAULT_MAX_CONTENT_LENGTH, List.of(), false, SocketOptions.defaults());
+    }
+
+    public HttpServerConfig withTls(TlsConfig tls) {
+        return new HttpServerConfig(name,
+                                    port,
+                                    Option.some(tls),
+                                    maxContentLength,
+                                    webSocketEndpoints,
+                                    chunkedWriteEnabled,
+                                    socketOptions);
+    }
+
+    public HttpServerConfig withMaxContentLength(int maxContentLength) {
+        return new HttpServerConfig(name,
+                                    port,
+                                    tls,
+                                    maxContentLength,
+                                    webSocketEndpoints,
+                                    chunkedWriteEnabled,
+                                    socketOptions);
+    }
+
+    public HttpServerConfig withWebSocket(WebSocketEndpoint endpoint) {
+        var endpoints = new ArrayList<>(webSocketEndpoints);
+        endpoints.add(endpoint);
+        return new HttpServerConfig(name,
+                                    port,
+                                    tls,
+                                    maxContentLength,
+                                    List.copyOf(endpoints),
+                                    chunkedWriteEnabled,
+                                    socketOptions);
+    }
+
+    public HttpServerConfig withChunkedWrite() {
+        return new HttpServerConfig(name, port, tls, maxContentLength, webSocketEndpoints, true, socketOptions);
+    }
+
+    public HttpServerConfig withSocketOptions(SocketOptions socketOptions) {
+        return new HttpServerConfig(name,
+                                    port,
+                                    tls,
+                                    maxContentLength,
+                                    webSocketEndpoints,
+                                    chunkedWriteEnabled,
+                                    socketOptions);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServerError.java b/common/src/main/java/org/pragmatica/http/server/HttpServerError.java
new file mode 100644
index 00000000..3a22edbc
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/HttpServerError.java
@@ -0,0 +1,28 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.lang.Cause;
+
+/**
+ * Error types for HTTP server operations.
+ */
+public sealed interface HttpServerError extends Cause {
+    /**
+     * Failed to bind to the specified port.
+     */
+    record BindFailed(int port, Throwable cause) implements HttpServerError {
+        @Override
+        public String message() {
+            return "Failed to bind to port " + port + ": " + cause.getMessage();
+        }
+    }
+
+    /**
+     * Failed to start server.
+     */
+    record StartFailed(String reason) implements HttpServerError {
+        @Override
+        public String message() {
+            return "Failed to start HTTP server: " + reason;
+        }
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java b/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
new file mode 100644
index 00000000..e699632e
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
@@ -0,0 +1,373 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.http.Headers;
+import org.pragmatica.http.HttpMethod;
+import org.pragmatica.http.HttpStatus;
+import org.pragmatica.http.QueryParams;
+import org.pragmatica.http.ContentType;
+import org.pragmatica.http.websocket.WebSocketEndpoint;
+import org.pragmatica.http.websocket.WebSocketHandler;
+import org.pragmatica.http.websocket.WebSocketMessage;
+import org.pragmatica.http.websocket.WebSocketSession;
+import org.pragmatica.lang.Option;
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.net.SocketOptions;
+import org.pragmatica.net.TlsContextFactory;
+
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioIoHandler;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.handler.codec.http.*;
+import io.netty.handler.codec.http.websocketx.*;
+import io.netty.handler.ssl.SslContext;
+import io.netty.handler.stream.ChunkedWriteHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.pragmatica.lang.Unit.unit;
+
+/**
+ * Netty-based HTTP server implementation.
+ */
+final class NettyHttpServer implements HttpServer {
+    private static final Logger LOG = LoggerFactory.getLogger(NettyHttpServer.class);
+
+    private final int port;
+    private final EventLoopGroup bossGroup;
+    private final EventLoopGroup workerGroup;
+    private final Channel serverChannel;
+
+    private NettyHttpServer(int port, EventLoopGroup bossGroup, EventLoopGroup workerGroup, Channel serverChannel) {
+        this.port = port;
+        this.bossGroup = bossGroup;
+        this.workerGroup = workerGroup;
+        this.serverChannel = serverChannel;
+    }
+
+    @Override
+    public int port() {
+        return port;
+    }
+
+    @Override
+    public Promise<Unit> stop() {
+        return Promise.promise(promise -> {
+                                   LOG.info("Stopping HTTP server on port {}", port);
+                                   if (serverChannel != null) {
+                                   serverChannel.close()
+                                                .addListener(_ -> {
+                                   cleanup();
+                                   promise.succeed(unit());
+                               });
+                               }else {
+                                   cleanup();
+                                   promise.succeed(unit());
+                               }
+                               });
+    }
+
+    private void cleanup() {
+        if (workerGroup != null) {
+            workerGroup.shutdownGracefully();
+        }
+        if (bossGroup != null) {
+            bossGroup.shutdownGracefully();
+        }
+    }
+
+    static Promise<HttpServer> create(HttpServerConfig config, BiConsumer<RequestContext, ResponseWriter> handler) {
+        // Handle TLS
+        var sslContextResult = config.tls()
+                                     .map(TlsContextFactory::create)
+                                     .fold(() -> null,
+                                           r -> r);
+        if (sslContextResult != null && sslContextResult.isFailure()) {
+            return sslContextResult.<HttpServer> map(_ -> null)
+                   .async();
+        }
+        var sslContext = sslContextResult != null
+                         ? sslContextResult.fold(_ -> null, ctx -> ctx)
+                         : null;
+        var bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+        var workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+        var socketOptions = config.socketOptions();
+        var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
+                        .channel(NioServerSocketChannel.class)
+                        .childHandler(new HttpServerInitializer(config, handler, sslContext))
+                        .option(ChannelOption.SO_BACKLOG,
+                                socketOptions.soBacklog())
+                        .childOption(ChannelOption.SO_KEEPALIVE,
+                                     socketOptions.soKeepalive());
+        return Promise.promise(promise -> {
+                                   bootstrap.bind(config.port())
+                                            .addListener((ChannelFutureListener) future -> {
+                                                             if (future.isSuccess()) {
+                                                             var protocol = sslContext != null
+                                                                            ? "HTTPS"
+                                                                            : "HTTP";
+                                                             LOG.info("{} server '{}' started on port {}",
+                                                                      protocol,
+                                                                      config.name(),
+                                                                      config.port());
+                                                             promise.succeed(new NettyHttpServer(config.port(),
+                                                                                                 bossGroup,
+                                                                                                 workerGroup,
+                                                                                                 future.channel()));
+                                                         }else {
+                                                             bossGroup.shutdownGracefully();
+                                                             workerGroup.shutdownGracefully();
+                                                             promise.fail(new HttpServerError.BindFailed(config.port(),
+                                                                                                         future.cause()));
+                                                         }
+                                                         });
+                               });
+    }
+
+    private static class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
+        private final HttpServerConfig config;
+        private final BiConsumer<RequestContext, ResponseWriter> handler;
+        private final SslContext sslContext;
+
+        HttpServerInitializer(HttpServerConfig config,
+                              BiConsumer<RequestContext, ResponseWriter> handler,
+                              SslContext sslContext) {
+            this.config = config;
+            this.handler = handler;
+            this.sslContext = sslContext;
+        }
+
+        @Override
+        protected void initChannel(SocketChannel ch) {
+            var pipeline = ch.pipeline();
+            if (sslContext != null) {
+                pipeline.addLast(sslContext.newHandler(ch.alloc()));
+            }
+            pipeline.addLast(new HttpServerCodec());
+            pipeline.addLast(new HttpObjectAggregator(config.maxContentLength()));
+            if (config.chunkedWriteEnabled()) {
+                pipeline.addLast(new ChunkedWriteHandler());
+            }
+            // Add WebSocket handlers for each endpoint
+            for (var endpoint : config.webSocketEndpoints()) {
+                pipeline.addLast(new WebSocketServerProtocolHandler(endpoint.path(), null, true));
+            }
+            pipeline.addLast(new HttpRequestHandler(handler, config.webSocketEndpoints()));
+        }
+    }
+
+    @ChannelHandler.Sharable
+    private static class HttpRequestHandler extends SimpleChannelInboundHandler<Object> {
+        private static final Logger LOG = LoggerFactory.getLogger(HttpRequestHandler.class);
+
+        private final BiConsumer<RequestContext, ResponseWriter> handler;
+        private final Map<String, WebSocketEndpoint> wsEndpoints;
+        private WebSocketHandler currentWsHandler;
+        private NettyWebSocketSession currentWsSession;
+
+        HttpRequestHandler(BiConsumer<RequestContext, ResponseWriter> handler, List<WebSocketEndpoint> endpoints) {
+            this.handler = handler;
+            this.wsEndpoints = new HashMap<>();
+            for (var endpoint : endpoints) {
+                wsEndpoints.put(endpoint.path(), endpoint);
+            }
+        }
+
+        @Override
+        protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
+            if (msg instanceof FullHttpRequest request) {
+                handleHttpRequest(ctx, request);
+            }else if (msg instanceof WebSocketFrame frame) {
+                handleWebSocketFrame(ctx, frame);
+            }
+        }
+
+        private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request) {
+            // Check if this is a WebSocket upgrade
+            var path = new QueryStringDecoder(request.uri()).path();
+            var wsEndpoint = wsEndpoints.get(path);
+            if (wsEndpoint != null && isWebSocketUpgrade(request)) {
+                // WebSocket upgrade will be handled by WebSocketServerProtocolHandler
+                // Just set up the handler for later
+                currentWsHandler = wsEndpoint.handler()
+                                             .get();
+                currentWsSession = new NettyWebSocketSession(ctx.channel());
+                ctx.fireChannelRead(request.retain());
+                return;
+            }
+            // Regular HTTP request
+            var requestContext = createRequestContext(request);
+            var responseWriter = new NettyResponseWriter(ctx);
+            try{
+                handler.accept(requestContext, responseWriter);
+            } catch (Exception e) {
+                LOG.error("Error handling request", e);
+                responseWriter.error(HttpStatus.INTERNAL_SERVER_ERROR, "Internal Server Error");
+            }
+        }
+
+        private boolean isWebSocketUpgrade(FullHttpRequest request) {
+            return request.headers()
+                          .contains(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET, true);
+        }
+
+        private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
+            if (currentWsHandler == null) {
+                return;
+            }
+            if (currentWsSession == null) {
+                currentWsSession = new NettyWebSocketSession(ctx.channel());
+            }
+            if (frame instanceof TextWebSocketFrame textFrame) {
+                currentWsHandler.handle(currentWsSession,
+                                        new WebSocketMessage.Text(textFrame.text()));
+            }else if (frame instanceof BinaryWebSocketFrame binaryFrame) {
+                var bytes = new byte[binaryFrame.content()
+                                                .readableBytes()];
+                binaryFrame.content()
+                           .readBytes(bytes);
+                currentWsHandler.handle(currentWsSession, new WebSocketMessage.Binary(bytes));
+            }else if (frame instanceof CloseWebSocketFrame) {
+                currentWsHandler.handle(currentWsSession, new WebSocketMessage.Close());
+                currentWsHandler = null;
+                currentWsSession = null;
+            }
+        }
+
+        @Override
+        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
+            if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
+                if (currentWsHandler != null && currentWsSession != null) {
+                    currentWsHandler.handle(currentWsSession, new WebSocketMessage.Open());
+                }
+            }
+            super.userEventTriggered(ctx, evt);
+        }
+
+        @Override
+        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+            LOG.error("Error in HTTP handler", cause);
+            ctx.close();
+        }
+
+        private RequestContext createRequestContext(FullHttpRequest request) {
+            var decoder = new QueryStringDecoder(request.uri());
+            var path = decoder.path();
+            var method = HttpMethod.from(request.method()
+                                                .name());
+            // Parse headers
+            var headerMap = new HashMap<String, List<String>>();
+            for (var entry : request.headers()) {
+                headerMap.computeIfAbsent(entry.getKey()
+                                               .toLowerCase(),
+                                          _ -> new java.util.ArrayList<>())
+                         .add(entry.getValue());
+            }
+            var headers = Headers.headers(headerMap);
+            // Parse query params
+            var queryParams = QueryParams.queryParams(decoder.parameters());
+            // Read body
+            var content = request.content();
+            var body = new byte[content.readableBytes()];
+            content.readBytes(body);
+            return new NettyRequestContext(method, path, headers, queryParams, body);
+        }
+    }
+
+    private record NettyRequestContext(
+    HttpMethod method,
+    String path,
+    Headers headers,
+    QueryParams queryParams,
+    byte[] body) implements RequestContext {}
+
+    private static class NettyResponseWriter implements ResponseWriter {
+        private final ChannelHandlerContext ctx;
+        private final io.netty.handler.codec.http.HttpHeaders responseHeaders;
+        private boolean written = false;
+
+        NettyResponseWriter(ChannelHandlerContext ctx) {
+            this.ctx = ctx;
+            this.responseHeaders = new DefaultHttpHeaders();
+        }
+
+        @Override
+        public ResponseWriter header(String name, String value) {
+            responseHeaders.set(name, value);
+            return this;
+        }
+
+        @Override
+        public void write(HttpStatus status, byte[] body, ContentType contentType) {
+            if (written) {
+                return;
+            }
+            written = true;
+            var nettyStatus = HttpResponseStatus.valueOf(status.code());
+            var content = Unpooled.wrappedBuffer(body);
+            var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, nettyStatus, content);
+            response.headers()
+                    .set(HttpHeaderNames.CONTENT_TYPE,
+                         contentType.headerText());
+            response.headers()
+                    .set(HttpHeaderNames.CONTENT_LENGTH, body.length);
+            response.headers()
+                    .add(responseHeaders);
+            ctx.writeAndFlush(response)
+               .addListener(ChannelFutureListener.CLOSE);
+        }
+    }
+
+    private static class NettyWebSocketSession implements WebSocketSession {
+        private final Channel channel;
+        private final String id;
+
+        NettyWebSocketSession(Channel channel) {
+            this.channel = channel;
+            this.id = UUID.randomUUID()
+                          .toString();
+        }
+
+        @Override
+        public String id() {
+            return id;
+        }
+
+        @Override
+        public void send(String text) {
+            if (channel.isActive()) {
+                channel.writeAndFlush(new TextWebSocketFrame(text));
+            }
+        }
+
+        @Override
+        public void send(byte[] binary) {
+            if (channel.isActive()) {
+                channel.writeAndFlush(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(binary)));
+            }
+        }
+
+        @Override
+        public void close() {
+            if (channel.isActive()) {
+                channel.writeAndFlush(new CloseWebSocketFrame())
+                       .addListener(ChannelFutureListener.CLOSE);
+            }
+        }
+
+        @Override
+        public boolean isOpen() {
+            return channel.isActive();
+        }
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/server/RequestContext.java b/common/src/main/java/org/pragmatica/http/server/RequestContext.java
new file mode 100644
index 00000000..5080e566
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/RequestContext.java
@@ -0,0 +1,52 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.http.Headers;
+import org.pragmatica.http.HttpMethod;
+import org.pragmatica.http.QueryParams;
+
+/**
+ * HTTP request context providing access to request data.
+ */
+public interface RequestContext {
+    /**
+     * HTTP method.
+     */
+    HttpMethod method();
+
+    /**
+     * Request path (without query string).
+     */
+    String path();
+
+    /**
+     * Request headers.
+     */
+    Headers headers();
+
+    /**
+     * Query parameters.
+     */
+    QueryParams queryParams();
+
+    /**
+     * Request body as bytes.
+     */
+    byte[] body();
+
+    /**
+     * Request body as UTF-8 string.
+     */
+    default String bodyAsString() {
+        var bytes = body();
+        return bytes.length == 0
+               ? ""
+               : new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Check if request has a body.
+     */
+    default boolean hasBody() {
+        return body().length > 0;
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java b/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
new file mode 100644
index 00000000..07ac8c08
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
@@ -0,0 +1,108 @@
+package org.pragmatica.http.server;
+
+import org.pragmatica.http.CommonContentType;
+import org.pragmatica.http.ContentType;
+import org.pragmatica.http.HttpStatus;
+import org.pragmatica.lang.Cause;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Response writer for HTTP handlers.
+ * <p>
+ * Each response method can only be called once per request.
+ */
+public interface ResponseWriter {
+    /**
+     * Write response with status, body, and content type.
+     */
+    void write(HttpStatus status, byte[] body, ContentType contentType);
+
+    /**
+     * Add header to the response. Must be called before write methods.
+     */
+    ResponseWriter header(String name, String value);
+
+    // Convenience methods
+    /**
+     * Write successful JSON response.
+     */
+    default void ok(String json) {
+        write(HttpStatus.OK, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
+    }
+
+    /**
+     * Write successful response with content type.
+     */
+    default void ok(byte[] body, ContentType contentType) {
+        write(HttpStatus.OK, body, contentType);
+    }
+
+    /**
+     * Write successful text response.
+     */
+    default void okText(String text) {
+        write(HttpStatus.OK, text.getBytes(StandardCharsets.UTF_8), CommonContentType.TEXT_PLAIN);
+    }
+
+    /**
+     * Write successful HTML response.
+     */
+    default void okHtml(String html) {
+        write(HttpStatus.OK, html.getBytes(StandardCharsets.UTF_8), CommonContentType.TEXT_HTML);
+    }
+
+    /**
+     * Write 204 No Content response.
+     */
+    default void noContent() {
+        write(HttpStatus.NO_CONTENT, new byte[0], CommonContentType.TEXT_PLAIN);
+    }
+
+    /**
+     * Write 404 Not Found response.
+     */
+    default void notFound() {
+        error(HttpStatus.NOT_FOUND, "Not Found");
+    }
+
+    /**
+     * Write 400 Bad Request response.
+     */
+    default void badRequest(String message) {
+        error(HttpStatus.BAD_REQUEST, message);
+    }
+
+    /**
+     * Write error response.
+     */
+    default void error(HttpStatus status, String message) {
+        var json = "{\"error\":\"" + escapeJson(message) + "\"}";
+        write(status, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
+    }
+
+    /**
+     * Write 500 Internal Server Error response.
+     */
+    default void internalError(Cause cause) {
+        error(HttpStatus.INTERNAL_SERVER_ERROR, cause.message());
+    }
+
+    /**
+     * Write JSON response with status.
+     */
+    default void respond(HttpStatus status, String json) {
+        write(status, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
+    }
+
+    private static String escapeJson(String s) {
+        if (s == null) {
+            return "";
+        }
+        return s.replace("\\", "\\\\")
+                .replace("\"", "\\\"")
+                .replace("\n", "\\n")
+                .replace("\r", "\\r")
+                .replace("\t", "\\t");
+    }
+}

From c0fd7d784b9380f4ee8321184588d08af882715d Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 15:57:46 +0100
Subject: [PATCH 13/26] refactor: delete http-server module, replaced by
 common/http

---
 .../org/pragmatica/aether/cli/AetherCli.java  | 138 ++--
 .../cluster/consensus/rabia/Batch.java        |   7 +-
 .../cluster/consensus/rabia/Phase.java        |   1 -
 .../consensus/rabia/ProtocolConfig.java       |  19 +-
 .../cluster/consensus/rabia/RabiaEngine.java  | 260 +++---
 .../consensus/rabia/RabiaPersistence.java     |  26 +-
 .../consensus/rabia/RabiaProtocolMessage.java |  16 +-
 .../cluster/consensus/rabia/StateValue.java   |   5 +-
 .../cluster/leader/LeaderManager.java         |  42 +-
 .../metrics/DeploymentMetricsMessage.java     |  35 +-
 .../cluster/metrics/MetricsMessage.java       |   1 -
 .../org/pragmatica/cluster/net/NodeId.java    |   3 +-
 .../org/pragmatica/cluster/net/NodeInfo.java  |   1 -
 .../pragmatica/cluster/net/netty/Decoder.java |  14 +-
 .../pragmatica/cluster/net/netty/Encoder.java |   7 +-
 .../pragmatica/cluster/net/netty/Handler.java |  20 +-
 .../net/netty/NettyClusterNetwork.java        | 144 ++--
 .../cluster/node/rabia/CustomClasses.java     |  22 +-
 .../cluster/node/rabia/NodeConfig.java        |   1 -
 .../cluster/node/rabia/RabiaNode.java         |  48 +-
 .../org/pragmatica/cluster/state/Command.java |   4 +-
 .../cluster/state/StateMachine.java           |   5 +-
 .../cluster/state/kvstore/KVStore.java        |  20 +-
 .../cluster/state/kvstore/KVStoreLocalIO.java |   3 +-
 .../state/kvstore/KVStoreNotification.java    |  10 +-
 .../cluster/state/kvstore/StructuredKey.java  |   1 -
 .../state/kvstore/StructuredPattern.java      |   4 +-
 .../topology/QuorumStateNotification.java     |   2 +-
 .../topology/ip/TcpTopologyManager.java       |  79 +-
 .../cluster/topology/ip/TopologyConfig.java   |   3 +-
 .../pragmatica/dht/ConsistentHashRing.java    |  16 +-
 .../java/org/pragmatica/dht/DHTClient.java    |   5 +-
 .../java/org/pragmatica/dht/DHTConfig.java    |  12 +-
 .../java/org/pragmatica/dht/DHTMessage.java   |   3 +-
 .../main/java/org/pragmatica/dht/DHTNode.java |  55 +-
 .../org/pragmatica/dht/LocalDHTClient.java    |   2 +-
 .../org/pragmatica/dht/LocalPartitionMap.java |  11 +-
 .../java/org/pragmatica/dht/Partition.java    |   3 +-
 .../java/org/pragmatica/dht/PartitionMap.java |   5 +-
 .../dht/storage/MemoryStorageEngine.java      |  10 +-
 .../pragmatica/dht/storage/StorageEngine.java |   3 +-
 .../java/org/pragmatica/message/Message.java  |   7 +-
 .../pragmatica/message/MessageReceiver.java   |   3 +-
 .../org/pragmatica/message/MessageRouter.java |  97 ++-
 .../message/RouterConfigurator.java           |   1 -
 .../pragmatica/utility/HierarchyScanner.java  |  53 +-
 .../org/pragmatica/utility/IdGenerator.java   |   5 +-
 .../java/org/pragmatica/utility/Sleep.java    |   5 +-
 .../java/org/pragmatica/utility/ULID.java     | 197 +++--
 .../aether/example/StringProcessorSlice.java  |   5 +-
 .../aether/forge/ForgeApiHandler.java         | 763 ++++++++++--------
 .../pragmatica/aether/forge/ForgeCluster.java | 153 ++--
 .../pragmatica/aether/forge/ForgeMetrics.java |  28 +-
 .../aether/forge/LoadGenerator.java           | 171 ++--
 .../aether/forge/LocalSliceInvoker.java       |  34 +-
 .../aether/forge/StaticFileHandler.java       |  76 +-
 .../forge/simulator/BackendSimulation.java    |  55 +-
 .../forge/simulator/ChaosController.java      |  98 +--
 .../aether/forge/simulator/ChaosEvent.java    |  13 +-
 .../aether/forge/simulator/DataGenerator.java |  28 +-
 .../forge/simulator/EntryPointMetrics.java    |  86 +-
 .../forge/simulator/SimulatorConfig.java      | 211 ++---
 .../aether/forge/simulator/SimulatorMode.java |  47 +-
 http-server/pom.xml                           |  48 --
 .../pragmatica/http/server/HttpMethod.java    |  34 -
 .../pragmatica/http/server/HttpServer.java    |  66 --
 .../http/server/HttpServerConfig.java         |  61 --
 .../http/server/HttpServerError.java          |  51 --
 .../pragmatica/http/server/HttpStatus.java    |  68 --
 .../http/server/RequestContext.java           | 121 ---
 .../http/server/ResponseWriter.java           |  87 --
 .../org/pragmatica/http/server/TlsConfig.java |  61 --
 .../http/server/impl/HttpRequestHandler.java  |  94 ---
 .../http/server/impl/NettyHttpServer.java     | 146 ----
 .../http/server/impl/NettyResponseWriter.java | 143 ----
 .../http/server/impl/TlsContextFactory.java   |  55 --
 .../http/server/HttpMethodTest.java           |  43 -
 .../http/server/HttpServerConfigTest.java     |  56 --
 .../server/HttpServerIntegrationTest.java     | 180 -----
 .../http/server/HttpStatusTest.java           |  63 --
 .../http/server/RequestContextTest.java       | 159 ----
 .../pragmatica/http/server/TlsConfigTest.java |  44 -
 .../infra/artifact/ArtifactRepoSlice.java     |  51 +-
 .../aether/infra/artifact/ArtifactStore.java  | 187 ++---
 .../infra/artifact/MavenProtocolHandler.java  | 210 ++---
 jbct-bug-report.md                            | 133 +++
 .../main/java/org/pragmatica/aether/Main.java |  71 +-
 .../pragmatica/aether/api/AlertManager.java   | 115 ++-
 .../aether/api/DashboardMetricsPublisher.java | 154 ++--
 .../aether/api/DashboardWebSocketHandler.java |  20 +-
 .../aether/controller/ClusterController.java  |  22 +-
 .../aether/controller/ControlLoop.java        |  79 +-
 .../controller/DecisionTreeController.java    |  58 +-
 .../cluster/BlueprintServiceImpl.java         |  20 +-
 .../cluster/ClusterDeploymentManager.java     | 220 +++--
 .../node/NodeDeploymentManager.java           | 532 ++++++------
 .../aether/endpoint/EndpointRegistry.java     |  65 +-
 .../aether/http/BindingResolver.java          |  43 +-
 .../pragmatica/aether/http/HttpMethod.java    |  15 +-
 .../aether/http/HttpRouterError.java          |   1 -
 .../pragmatica/aether/http/MatchResult.java   |   5 +-
 .../pragmatica/aether/http/PathPattern.java   |  27 +-
 .../aether/http/RequestContext.java           |  13 +-
 .../aether/http/ResponseWriter.java           |  33 +-
 .../pragmatica/aether/http/RouteRegistry.java | 181 ++---
 .../pragmatica/aether/http/RouterConfig.java  |   9 +-
 .../aether/http/SliceDispatcher.java          |  33 +-
 .../aether/invoke/InvocationHandler.java      |  88 +-
 .../aether/invoke/InvocationMessage.java      |  23 +-
 .../aether/invoke/SliceInvoker.java           | 329 ++++----
 .../aether/metrics/MetricsCollector.java      |  59 +-
 .../aether/metrics/MetricsScheduler.java      |  54 +-
 .../metrics/deployment/DeploymentEvent.java   |  12 +-
 .../metrics/deployment/DeploymentMetrics.java |  96 +--
 .../DeploymentMetricsCollector.java           | 166 ++--
 .../DeploymentMetricsScheduler.java           |  63 +-
 .../InvocationMetricsCollector.java           | 105 +--
 .../metrics/invocation/MethodMetrics.java     |  59 +-
 .../metrics/invocation/SlowInvocation.java    |  35 +-
 .../metrics/invocation/ThresholdStrategy.java |  29 +-
 .../aether/node/AetherCustomClasses.java      |  27 +-
 .../pragmatica/aether/node/AetherNode.java    | 298 ++++---
 .../aether/node/AetherNodeConfig.java         |  69 +-
 pom.xml                                       |   1 -
 .../aether/slice/annotation/Slice.java        |   5 +-
 .../org/pragmatica/aether/slice/Slice.java    |   8 +-
 .../pragmatica/aether/slice/SliceBridge.java  |   3 +-
 .../pragmatica/aether/slice/SliceMethod.java  |   4 +-
 .../pragmatica/aether/slice/SliceRoute.java   |  13 +-
 .../pragmatica/aether/slice/SliceRuntime.java |  19 +-
 .../pragmatica/aether/artifact/Artifact.java  |  13 +-
 .../pragmatica/aether/artifact/Version.java   |  21 +-
 .../aether/slice/FrameworkClassLoader.java    |  50 +-
 .../slice/SharedLibraryClassLoader.java       |  16 +-
 .../aether/slice/SliceActionConfig.java       |  51 +-
 .../aether/slice/SliceBridgeImpl.java         |  96 +--
 .../aether/slice/SliceClassLoader.java        |  12 +-
 .../aether/slice/SliceManifest.java           |  34 +-
 .../pragmatica/aether/slice/SliceState.java   |  35 +-
 .../pragmatica/aether/slice/SliceStore.java   |   1 -
 .../aether/slice/SliceStoreImpl.java          | 121 +--
 .../slice/blueprint/BlueprintExpander.java    |  58 +-
 .../aether/slice/blueprint/BlueprintId.java   |  10 +-
 .../slice/blueprint/BlueprintParser.java      |  36 +-
 .../aether/slice/blueprint/ExpanderError.java |   6 +-
 .../blueprint/RepositoryDependencyLoader.java |  23 +-
 .../slice/dependency/ArtifactDependency.java  |  55 +-
 .../slice/dependency/ArtifactMapper.java      |  37 +-
 .../slice/dependency/CompatibilityResult.java |   1 -
 .../dependency/DependencyCycleDetector.java   |  16 +-
 .../dependency/DependencyDescriptor.java      |  45 +-
 .../slice/dependency/DependencyFile.java      |  97 +--
 .../slice/dependency/DependencyResolver.java  | 307 +++----
 .../dependency/SharedDependencyLoader.java    | 239 +++---
 .../slice/dependency/SliceDependencies.java   |  28 +-
 .../aether/slice/dependency/SliceFactory.java |  52 +-
 .../slice/dependency/SliceRegistry.java       |  35 +-
 .../slice/dependency/VersionPattern.java      |  98 +--
 .../aether/slice/kvstore/AetherKey.java       |  90 ++-
 .../aether/slice/kvstore/AetherValue.java     |  18 +-
 .../aether/slice/repository/Location.java     |   1 -
 .../repository/maven/LocalRepository.java     |  27 +-
 .../maven/MavenLocalRepoLocator.java          |  29 +-
 .../aether/slice/routing/Binding.java         |   5 +-
 .../aether/slice/routing/BindingSource.java   |  29 +-
 .../aether/slice/routing/RouteTarget.java     |  39 +-
 .../aether/slice/routing/SliceSpec.java       |   5 +-
 .../FurySerializerFactoryProvider.java        |  10 +-
 .../KryoSerializerFactoryProvider.java        |  34 +-
 .../SerializerFactoryProvider.java            |   2 +-
 170 files changed, 4496 insertions(+), 6030 deletions(-)
 delete mode 100644 http-server/pom.xml
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/HttpMethod.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/HttpServer.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/HttpServerError.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/HttpStatus.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/RequestContext.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/ResponseWriter.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/TlsConfig.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/impl/HttpRequestHandler.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/impl/NettyResponseWriter.java
 delete mode 100644 http-server/src/main/java/org/pragmatica/http/server/impl/TlsContextFactory.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/HttpMethodTest.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/HttpServerConfigTest.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/HttpServerIntegrationTest.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/HttpStatusTest.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/RequestContextTest.java
 delete mode 100644 http-server/src/test/java/org/pragmatica/http/server/TlsConfigTest.java
 create mode 100644 jbct-bug-report.md

diff --git a/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java b/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
index 67571184..e6a16400 100644
--- a/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
+++ b/cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java
@@ -1,10 +1,5 @@
 package org.pragmatica.aether.cli;
 
-import picocli.CommandLine;
-import picocli.CommandLine.Command;
-import picocli.CommandLine.Option;
-import picocli.CommandLine.Parameters;
-
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -16,6 +11,11 @@
 import java.nio.file.Path;
 import java.util.concurrent.Callable;
 
+import picocli.CommandLine;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+import picocli.CommandLine.Parameters;
+
 /**
  * Aether cluster management CLI.
  *
@@ -40,26 +40,23 @@
  * </pre>
  */
 @Command(name = "aether",
-         mixinStandardHelpOptions = true,
-         version = "Aether 0.6.3",
-         description = "Command-line interface for Aether cluster management",
-         subcommands = {
-                 AetherCli.StatusCommand.class,
-                 AetherCli.NodesCommand.class,
-                 AetherCli.SlicesCommand.class,
-                 AetherCli.MetricsCommand.class,
-                 AetherCli.HealthCommand.class,
-                 AetherCli.DeployCommand.class,
-                 AetherCli.ScaleCommand.class,
-                 AetherCli.UndeployCommand.class,
-                 AetherCli.BlueprintCommand.class,
-                 AetherCli.ArtifactCommand.class
-         })
+ mixinStandardHelpOptions = true,
+ version = "Aether 0.6.3",
+ description = "Command-line interface for Aether cluster management",
+ subcommands = {AetherCli.StatusCommand.class,
+ AetherCli.NodesCommand.class,
+ AetherCli.SlicesCommand.class,
+ AetherCli.MetricsCommand.class,
+ AetherCli.HealthCommand.class,
+ AetherCli.DeployCommand.class,
+ AetherCli.ScaleCommand.class,
+ AetherCli.UndeployCommand.class,
+ AetherCli.BlueprintCommand.class,
+ AetherCli.ArtifactCommand.class})
 public class AetherCli implements Runnable {
-
     @Option(names = {"-c", "--connect"},
-            description = "Node address to connect to (host:port)",
-            defaultValue = "localhost:8080")
+    description = "Node address to connect to (host:port)",
+    defaultValue = "localhost:8080")
     private String nodeAddress;
 
     private final HttpClient httpClient = HttpClient.newHttpClient();
@@ -67,14 +64,13 @@ public class AetherCli implements Runnable {
     public static void main(String[] args) {
         var cli = new AetherCli();
         var cmd = new CommandLine(cli);
-
         if (args.length == 0 || (args.length == 2 && (args[0].equals("-c") || args[0].equals("--connect")))) {
             // REPL mode when no command specified (only --connect option)
             if (args.length == 2) {
                 cli.nodeAddress = args[1];
             }
             cli.runRepl(cmd);
-        } else {
+        }else {
             // Batch mode
             int exitCode = cmd.execute(args);
             System.exit(exitCode);
@@ -91,23 +87,22 @@ private void runRepl(CommandLine cmd) {
         System.out.println("Aether v0.6.3 - Connected to " + nodeAddress);
         System.out.println("Type 'help' for available commands, 'exit' to quit.");
         System.out.println();
-
         try (var reader = new BufferedReader(new InputStreamReader(System.in))) {
             String line;
             while (true) {
                 System.out.print("aether> ");
                 System.out.flush();
                 line = reader.readLine();
-
-                if (line == null || line.trim().equalsIgnoreCase("exit") || line.trim().equalsIgnoreCase("quit")) {
+                if (line == null || line.trim()
+                                        .equalsIgnoreCase("exit") || line.trim()
+                                                                         .equalsIgnoreCase("quit")) {
                     System.out.println("Goodbye!");
                     break;
                 }
-
-                if (line.trim().isEmpty()) {
+                if (line.trim()
+                        .isEmpty()) {
                     continue;
                 }
-
                 // Parse and execute command
                 String[] replArgs = parseReplCommand(line.trim());
                 if (replArgs.length > 0) {
@@ -116,7 +111,6 @@ private void runRepl(CommandLine cmd) {
                     fullArgs[0] = "--connect";
                     fullArgs[1] = nodeAddress;
                     System.arraycopy(replArgs, 0, fullArgs, 2, replArgs.length);
-
                     cmd.execute(fullArgs);
                 }
             }
@@ -131,18 +125,16 @@ private String[] parseReplCommand(String line) {
     }
 
     String fetchFromNode(String path) {
-        try {
+        try{
             var uri = URI.create("http://" + nodeAddress + path);
             var request = HttpRequest.newBuilder()
                                      .uri(uri)
                                      .GET()
                                      .build();
-
             var response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
-
             if (response.statusCode() == 200) {
                 return response.body();
-            } else {
+            }else {
                 return "{\"error\":\"HTTP " + response.statusCode() + ": " + response.body() + "\"}";
             }
         } catch (Exception e) {
@@ -151,19 +143,17 @@ String fetchFromNode(String path) {
     }
 
     String postToNode(String path, String body) {
-        try {
+        try{
             var uri = URI.create("http://" + nodeAddress + path);
             var request = HttpRequest.newBuilder()
                                      .uri(uri)
                                      .header("Content-Type", "application/json")
                                      .POST(HttpRequest.BodyPublishers.ofString(body))
                                      .build();
-
             var response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
-
             if (response.statusCode() == 200) {
                 return response.body();
-            } else {
+            }else {
                 return "{\"error\":\"HTTP " + response.statusCode() + ": " + response.body() + "\"}";
             }
         } catch (Exception e) {
@@ -172,19 +162,20 @@ String postToNode(String path, String body) {
     }
 
     String putToNode(String path, byte[] content, String contentType) {
-        try {
+        try{
             var uri = URI.create("http://" + nodeAddress + path);
             var request = HttpRequest.newBuilder()
                                      .uri(uri)
                                      .header("Content-Type", contentType)
                                      .PUT(HttpRequest.BodyPublishers.ofByteArray(content))
                                      .build();
-
             var response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
-
             if (response.statusCode() == 200 || response.statusCode() == 201) {
-                return response.body().isEmpty() ? "{\"status\":\"ok\"}" : response.body();
-            } else {
+                return response.body()
+                               .isEmpty()
+                       ? "{\"status\":\"ok\"}"
+                       : response.body();
+            }else {
                 return "{\"error\":\"HTTP " + response.statusCode() + ": " + response.body() + "\"}";
             }
         } catch (Exception e) {
@@ -193,7 +184,6 @@ String putToNode(String path, byte[] content, String contentType) {
     }
 
     // ===== Subcommands =====
-
     @Command(name = "status", description = "Show cluster status")
     static class StatusCommand implements Callable<Integer> {
         @CommandLine.ParentCommand
@@ -317,12 +307,10 @@ public Integer call() {
     }
 
     @Command(name = "artifact",
-             description = "Artifact repository management",
-             subcommands = {
-                     ArtifactCommand.DeployArtifactCommand.class,
-                     ArtifactCommand.ListArtifactsCommand.class,
-                     ArtifactCommand.VersionsCommand.class
-             })
+    description = "Artifact repository management",
+    subcommands = {ArtifactCommand.DeployArtifactCommand.class,
+    ArtifactCommand.ListArtifactsCommand.class,
+    ArtifactCommand.VersionsCommand.class})
     static class ArtifactCommand implements Runnable {
         @CommandLine.ParentCommand
         private AetherCli parent;
@@ -351,27 +339,20 @@ static class DeployArtifactCommand implements Callable<Integer> {
 
             @Override
             public Integer call() {
-                try {
+                try{
                     if (!Files.exists(jarPath)) {
                         System.err.println("File not found: " + jarPath);
                         return 1;
                     }
-
                     byte[] content = Files.readAllBytes(jarPath);
                     var coordinates = groupId + ":" + artifactId + ":" + version;
-                    var repoPath = "/repository/" +
-                                   groupId.replace('.', '/') + "/" +
-                                   artifactId + "/" +
-                                   version + "/" +
-                                   artifactId + "-" + version + ".jar";
-
+                    var repoPath = "/repository/" + groupId.replace('.', '/') + "/" + artifactId + "/" + version + "/" + artifactId
+                                   + "-" + version + ".jar";
                     var response = artifactParent.parent.putToNode(repoPath, content, "application/java-archive");
-
                     if (response.startsWith("{\"error\":")) {
                         System.out.println("Failed to deploy: " + response);
                         return 1;
                     }
-
                     System.out.println("Deployed " + coordinates);
                     System.out.println("  File: " + jarPath);
                     System.out.println("  Size: " + content.length + " bytes");
@@ -420,10 +401,8 @@ public Integer call() {
     }
 
     @Command(name = "blueprint",
-             description = "Blueprint management",
-             subcommands = {
-                     BlueprintCommand.ApplyCommand.class
-             })
+    description = "Blueprint management",
+    subcommands = {BlueprintCommand.ApplyCommand.class})
     static class BlueprintCommand implements Runnable {
         @CommandLine.ParentCommand
         private AetherCli parent;
@@ -443,20 +422,17 @@ static class ApplyCommand implements Callable<Integer> {
 
             @Override
             public Integer call() {
-                try {
+                try{
                     if (!Files.exists(blueprintPath)) {
                         System.err.println("Blueprint file not found: " + blueprintPath);
                         return 1;
                     }
-
                     var content = Files.readString(blueprintPath);
                     var response = blueprintParent.parent.postToNode("/blueprint", content);
-
                     if (response.contains("\"error\":")) {
                         System.out.println("Failed to apply blueprint: " + response);
                         return 1;
                     }
-
                     System.out.println(formatJson(response));
                     return 0;
                 } catch (IOException e) {
@@ -472,48 +448,44 @@ private static String formatJson(String json) {
         if (json == null || json.isEmpty()) {
             return json;
         }
-
         var sb = new StringBuilder();
         int indent = 0;
         boolean inString = false;
-
-        for (int i = 0; i < json.length(); i++) {
+        for (int i = 0; i < json.length(); i++ ) {
             char c = json.charAt(i);
-
             if (c == '"' && (i == 0 || json.charAt(i - 1) != '\\')) {
                 inString = !inString;
                 sb.append(c);
-            } else if (!inString) {
+            }else if (!inString) {
                 switch (c) {
-                    case '{', '[' -> {
+                    case'{', '[' -> {
                         sb.append(c);
                         sb.append('\n');
-                        indent++;
+                        indent++ ;
                         sb.append("  ".repeat(indent));
                     }
-                    case '}', ']' -> {
+                    case'}', ']' -> {
                         sb.append('\n');
-                        indent--;
+                        indent-- ;
                         sb.append("  ".repeat(indent));
                         sb.append(c);
                     }
-                    case ',' -> {
+                    case',' -> {
                         sb.append(c);
                         sb.append('\n');
                         sb.append("  ".repeat(indent));
                     }
-                    case ':' -> sb.append(": ");
+                    case':' -> sb.append(": ");
                     default -> {
                         if (!Character.isWhitespace(c)) {
                             sb.append(c);
                         }
                     }
                 }
-            } else {
+            }else {
                 sb.append(c);
             }
         }
-
         return sb.toString();
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
index bf07501a..02ea3e74 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
@@ -12,18 +12,15 @@ public record Batch<C extends Command>(BatchId id,
     @Override
     public int compareTo(Batch<C> o) {
         var timestampCompare = Long.compare(timestamp, o.timestamp);
-
         if (timestampCompare != 0) {
             return timestampCompare;
         }
-
         var idCompare = Integer.compare(id.hashCode(), o.id.hashCode());
-
         if (idCompare != 0) {
             return idCompare;
         }
-
-        return correlationId.id().compareTo(o.correlationId.id());
+        return correlationId.id()
+                            .compareTo(o.correlationId.id());
     }
 
     public static <C extends Command> Batch<C> batch(List<C> commands) {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
index 957f62cb..446830ec 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
@@ -1,5 +1,4 @@
 package org.pragmatica.cluster.consensus.rabia;
-
 /// Represents a protocol phase as defined in the Rabia formal specification.
 public record Phase(long value) implements Comparable<Phase> {
     public static final Phase ZERO = new Phase(0);
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
index c72bfc89..21bc7b78 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
@@ -8,21 +8,20 @@
  * Configuration for the Rabia consensus engine.
  */
 public record ProtocolConfig(
-        TimeSpan cleanupInterval,
-        TimeSpan syncRetryInterval,
-        long removeOlderThanPhases
-) {
+ TimeSpan cleanupInterval,
+ TimeSpan syncRetryInterval,
+ long removeOlderThanPhases) {
     /// Creates a default (production) configuration.
     public static ProtocolConfig defaultConfig() {
-        return new ProtocolConfig(timeSpan(60).seconds(),
-                                  timeSpan(5).seconds(),
-                                  100);
+        return new ProtocolConfig(timeSpan(60)
+                                  .seconds(), timeSpan(5)
+                                             .seconds(), 100);
     }
 
     /// Creates a test configuration.
     public static ProtocolConfig testConfig() {
-        return new ProtocolConfig(timeSpan(60).seconds(),
-                                  timeSpan(100).millis(),
-                                  100);
+        return new ProtocolConfig(timeSpan(60)
+                                  .seconds(), timeSpan(100)
+                                             .millis(), 100);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
index 0c52600b..61248631 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
@@ -17,8 +17,6 @@
 import org.pragmatica.lang.utils.SharedScheduler;
 import org.pragmatica.message.MessageReceiver;
 import org.pragmatica.message.MessageRouter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.Comparator;
 import java.util.List;
@@ -30,6 +28,9 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.cluster.consensus.rabia.Batch.batch;
 import static org.pragmatica.cluster.consensus.rabia.Batch.emptyBatch;
 import static org.pragmatica.cluster.consensus.rabia.RabiaPersistence.SavedState.savedState;
@@ -59,8 +60,8 @@ public class RabiaEngine<C extends Command> {
     private final AtomicBoolean isInPhase = new AtomicBoolean(false);
     private final AtomicReference<Promise<Unit>> startPromise = new AtomicReference<>(Promise.promise());
     private final AtomicReference<Phase> lastCommittedPhase = new AtomicReference<>(Phase.ZERO);
-    //--------------------------------- Node State End
 
+    //--------------------------------- Node State End
     /// Creates a new Rabia consensus engine.
     ///
     /// @param topologyManager The address book for node communication
@@ -71,12 +72,12 @@ public RabiaEngine(TopologyManager topologyManager,
                        ClusterNetwork network,
                        StateMachine<C> stateMachine,
                        ProtocolConfig config) {
-        this.self = topologyManager.self().id();
+        this.self = topologyManager.self()
+                                   .id();
         this.topologyManager = topologyManager;
         this.network = network;
         this.stateMachine = stateMachine;
         this.config = config;
-
         // Setup periodic tasks
         SharedScheduler.scheduleAtFixedRate(this::cleanupOldPhases, config.cleanupInterval());
         SharedScheduler.schedule(this::synchronize, config.syncRetryInterval());
@@ -85,18 +86,15 @@ public RabiaEngine(TopologyManager topologyManager,
     public void configure(MessageRouter.MutableRouter router) {
         // Subscribe to quorum events
         router.addRoute(QuorumStateNotification.class, this::quorumState);
-
         // Synchronous messages
         router.addRoute(Propose.class, this::processPropose);
         router.addRoute(VoteRound1.class, this::processVoteRound1);
         router.addRoute(VoteRound2.class, this::processVoteRound2);
         router.addRoute(Decision.class, this::processDecision);
         router.addRoute(SyncResponse.class, this::processSyncResponse);
-
         // Asynchronous messages
         router.addRoute(SyncRequest.class, this::handleSyncRequest);
         router.addRoute(NewBatch.class, this::handleNewBatch);
-
         // Local command submission requests
         router.addRoute(SubmitCommands.class, this::handleSubmit);
     }
@@ -112,16 +110,18 @@ public void quorumState(QuorumStateNotification quorumStateNotification) {
 
     private void clusterConnected() {
         log.info("Node {}: quorum connected. Starting synchronization attempts", self);
-
-        SharedScheduler.schedule(this::synchronize, config.syncRetryInterval().randomize(SCALE));
+        SharedScheduler.schedule(this::synchronize,
+                                 config.syncRetryInterval()
+                                       .randomize(SCALE));
     }
 
     private void clusterDisconnected() {
         if (!active.compareAndSet(true, false)) {
             return;
         }
-
-        persistence.save(stateMachine, lastCommittedPhase.get(), pendingBatches.values())
+        persistence.save(stateMachine,
+                         lastCommittedPhase.get(),
+                         pendingBatches.values())
                    .onSuccessRun(() -> log.info("Node {} disconnected. State persisted", self))
                    .onFailure(cause -> log.error("Node {} failed to persist state: {}", self, cause));
         phases.clear();
@@ -134,39 +134,36 @@ private void clusterDisconnected() {
 
     public <R> Promise<List<R>> apply(List<C> commands) {
         var pendingAnswer = Promise.<List<R>>promise();
-
-        return submitCommands(commands, batch -> correlationMap.put(batch.correlationId(), pendingAnswer))
-                .async()
-                .flatMap(_ -> pendingAnswer);
+        return submitCommands(commands,
+                              batch -> correlationMap.put(batch.correlationId(),
+                                                          pendingAnswer))
+               .async()
+               .flatMap(_ -> pendingAnswer);
     }
 
     @MessageReceiver
     public void handleSubmit(SubmitCommands<C> submitCommands) {
-        submitCommands(submitCommands.commands(), _ -> {
-        });
+        submitCommands(submitCommands.commands(),
+                       _ -> {});
     }
 
     private Result<Batch<C>> submitCommands(List<C> commands, Consumer<Batch<C>> onBatchPrepared) {
         if (commands.isEmpty()) {
-            return ConsensusErrors.commandBatchIsEmpty().result();
+            return ConsensusErrors.commandBatchIsEmpty()
+                                  .result();
         }
-
         if (!active.get()) {
-            return ConsensusErrors.nodeInactive(self).result();
+            return ConsensusErrors.nodeInactive(self)
+                                  .result();
         }
-
         var batch = batch(commands);
-
         log.trace("Node {}: client submitted {} command(s). Prepared batch: {}", self, commands.size(), batch);
-
         pendingBatches.put(batch.correlationId(), batch);
         onBatchPrepared.accept(batch);
         network.broadcast(new NewBatch<>(self, batch));
-
         if (!isInPhase.get()) {
             executor.execute(this::startPhase);
         }
-
         return Result.success(batch);
     }
 
@@ -209,8 +206,10 @@ public void processSyncResponse(SyncResponse<C> syncResponse) {
 
     @SuppressWarnings("unchecked")
     @MessageReceiver
-    public void handleNewBatch(NewBatch<?> newBatch) {
-        pendingBatches.put(newBatch.batch().correlationId(), (Batch<C>) newBatch.batch());
+    public void handleNewBatch(NewBatch< ? > newBatch) {
+        pendingBatches.put(newBatch.batch()
+                                   .correlationId(),
+                           (Batch<C>) newBatch.batch());
     }
 
     /// Starts a new phase with pending commands.
@@ -219,24 +218,20 @@ private void startPhase() {
         if (!isInPhase.compareAndSet(false, true)) {
             return;
         }
-
         if (pendingBatches.isEmpty()) {
-            isInPhase.set(false);  // Reset since we won't actually start
+            isInPhase.set(false);
+            // Reset since we won't actually start
             return;
         }
-
         var phase = currentPhase.get();
         var batch = pendingBatches.values()
                                   .stream()
                                   .sorted()
                                   .findFirst()
                                   .orElse(emptyBatch());
-
         log.trace("Node {} starting phase {} with batch {}", self, phase, batch.id());
-
         var phaseData = getOrCreatePhaseData(phase);
         phaseData.proposals.put(self, batch);
-
         network.broadcast(new Propose<>(self, phase, batch));
     }
 
@@ -245,14 +240,14 @@ private void synchronize() {
         if (active.get()) {
             return;
         }
-
         // Clear stale responses
         syncResponses.clear();
         var request = new SyncRequest(self);
         log.trace("Node {}: requesting phase synchronization {}", self, request);
         network.broadcast(request);
-
-        SharedScheduler.schedule(this::synchronize, config.syncRetryInterval().randomize(SCALE));
+        SharedScheduler.schedule(this::synchronize,
+                                 config.syncRetryInterval()
+                                       .randomize(SCALE));
     }
 
     /// Handles a synchronization response from another node.
@@ -261,47 +256,46 @@ private void handleSyncResponse(SyncResponse<C> response) {
             log.trace("Node {} ignoring synchronization response {}. Node is active", self, response);
             return;
         }
-
         syncResponses.put(response.sender(), response.state());
-
         if (syncResponses.size() < topologyManager.quorumSize()) {
             log.trace("Node {} received {} responses {}, not enough to proceed (quorum size = {})",
-                      self, syncResponses.size(), syncResponses.keySet(), topologyManager.quorumSize());
+                      self,
+                      syncResponses.size(),
+                      syncResponses.keySet(),
+                      topologyManager.quorumSize());
             return;
         }
-
         log.trace("Node {} received {} responses, collected: {}", self, syncResponses.size(), syncResponses);
-
         // Use the latest known state among received responses
         var candidate = syncResponses.values()
                                      .stream()
                                      .sorted(Comparator.comparing(SavedState::lastCommittedPhase))
                                      .toList()
                                      .getLast();
-
         log.trace("Node {} uses {} as synchronization candidate out of {}", self, candidate, syncResponses.size());
         restoreState(candidate);
     }
 
     private void restoreState(SavedState<C> state) {
         syncResponses.clear();
-
         if (state.snapshot().length == 0) {
             activate();
             return;
         }
         stateMachine.restoreSnapshot(state.snapshot())
                     .onSuccess(_ -> {
-                        currentPhase.set(state.lastCommittedPhase());
-                        lastCommittedPhase.set(state.lastCommittedPhase());
-                        state.pendingBatches()
-                             .forEach(batch -> pendingBatches.put(batch.correlationId(), batch));
-                        persistence.save(stateMachine, currentPhase.get(), pendingBatches.values());
-
-                        log.info("Node {} restored state from persistence. Current phase {}",
-                                 self,
-                                 currentPhase.get());
-                    })
+                                   currentPhase.set(state.lastCommittedPhase());
+                                   lastCommittedPhase.set(state.lastCommittedPhase());
+                                   state.pendingBatches()
+                                        .forEach(batch -> pendingBatches.put(batch.correlationId(),
+                                                                             batch));
+                                   persistence.save(stateMachine,
+                                                    currentPhase.get(),
+                                                    pendingBatches.values());
+                                   log.info("Node {} restored state from persistence. Current phase {}",
+                                            self,
+                                            currentPhase.get());
+                               })
                     .onSuccessRun(this::activate)
                     .onFailure(cause -> log.error("Node {} failed to restore state: {}", self, cause));
     }
@@ -312,7 +306,6 @@ private void activate() {
         startPromise.get()
                     .succeed(Unit.unit());
         syncResponses.clear();
-
         log.info("Node {} activated in phase {}", self, currentPhase.get());
         executor.execute(this::startPhase);
     }
@@ -322,19 +315,20 @@ private void activate() {
     public void handleSyncRequest(SyncRequest request) {
         if (active.get()) {
             stateMachine.makeSnapshot()
-                        .map(snapshot -> new SyncResponse<>(self, savedState(snapshot,
-                                                                             lastCommittedPhase.get(),
-                                                                             pendingBatches.values())))
-                        .onSuccess(response -> network.send(request.sender(), response))
+                        .map(snapshot -> new SyncResponse<>(self,
+                                                            savedState(snapshot,
+                                                                       lastCommittedPhase.get(),
+                                                                       pendingBatches.values())))
+                        .onSuccess(response -> network.send(request.sender(),
+                                                            response))
                         .onFailure(cause -> log.error("Node {} failed to create snapshot: {}", self, cause));
-        } else {
+        }else {
             log.trace("Node {} is inactive, trying to share saved (or empty) state for request: {}", self, request);
-
-            var response = new SyncResponse<>(self, persistence.load()
-                                                               .or(SavedState.empty()));
+            var response = new SyncResponse<>(self,
+                                              persistence.load()
+                                                         .or(SavedState.empty()));
             network.send(request.sender(), response);
         }
-
     }
 
     /// Cleans up old phase data to prevent memory leaks.
@@ -342,16 +336,13 @@ private void cleanupOldPhases() {
         if (!active.get()) {
             return;
         }
-
         var current = currentPhase.get();
-
         phases.keySet()
               .removeIf(phase -> isExpiredPhase(phase, current));
     }
 
     private boolean isExpiredPhase(Phase phase, Phase current) {
-        return phase.compareTo(current) < 0
-               && current.value() - phase.value() > config.removeOlderThanPhases();
+        return phase.compareTo(current) < 0 && current.value() - phase.value() > config.removeOlderThanPhases();
     }
 
     /// Handles a Propose message from another node.
@@ -360,53 +351,45 @@ private void handlePropose(Propose<C> propose) {
             log.warn("Node {} ignores proposal {}. Node is dormant", self, propose);
             return;
         }
-
         log.trace("Node {} received proposal from {} for phase {}", self, propose.sender(), propose.phase());
-
         var currentPhaseValue = currentPhase.get();
         // Ignore proposals for past phases
-        if (propose.phase().compareTo(currentPhaseValue) < 0) {
+        if (propose.phase()
+                   .compareTo(currentPhaseValue) < 0) {
             log.trace("Node {} ignoring proposal for past phase {}", self, propose.phase());
             return;
         }
-
         // Potentially add check for proposals too far in the future
         var phaseData = getOrCreatePhaseData(propose.phase());
-
         // Ensure the phase state is correct. If we receive a proposal for the current
         // phase value but aren't "in" it, enter it now.
         // This assumes the currentPhaseValue is correctly managed by sync/moveToNextPhase
-        if (propose.phase().equals(currentPhaseValue) && !isInPhase.get()) {
-            log.trace("Node {} entering phase {} triggered by proposal from {}",
-                      self,
-                      propose.phase(),
-                      propose.sender());
+        if (propose.phase()
+                   .equals(currentPhaseValue) && !isInPhase.get()) {
+            log.trace("Node {} entering phase {} triggered by proposal from {}", self, propose.phase(), propose.sender());
             isInPhase.set(true);
         }
-
         phaseData.proposals.putIfAbsent(propose.sender(), propose.value());
-
-        if (isInPhase.get()
-            && currentPhase.get().equals(propose.phase())
-            && !phaseData.round1Votes.containsKey(self)) {
-
+        if (isInPhase.get() && currentPhase.get()
+                                           .equals(propose.phase()) && !phaseData.round1Votes.containsKey(self)) {
             var vote = phaseData.evaluateInitialVote(self, propose);
-
             log.trace("Node {} broadcasting R1 vote {} for phase {} based on received proposal from {}",
-                      self, vote, propose.phase(), propose.sender());
-
+                      self,
+                      vote,
+                      propose.phase(),
+                      propose.sender());
             network.broadcast(vote);
-            phaseData.round1Votes.put(self, vote.stateValue()); // Record our own vote
-        } else {
+            phaseData.round1Votes.put(self, vote.stateValue());
+        }else {
             log.trace(
-                    "Node {} conditions not met to vote R1 on proposal from {} for phase {}. Active: {}, InPhase: {}, CurrentPhase: {}, HasVotedR1: {}",
-                    self,
-                    propose.sender(),
-                    propose.phase(),
-                    active.get(),
-                    isInPhase.get(),
-                    currentPhase.get(),
-                    phaseData.round1Votes.containsKey(self));
+            "Node {} conditions not met to vote R1 on proposal from {} for phase {}. Active: {}, InPhase: {}, CurrentPhase: {}, HasVotedR1: {}",
+            self,
+            propose.sender(),
+            propose.phase(),
+            active.get(),
+            isInPhase.get(),
+            currentPhase.get(),
+            phaseData.round1Votes.containsKey(self));
         }
     }
 
@@ -416,24 +399,20 @@ private void handleVoteRound1(VoteRound1 vote) {
             log.warn("Node {} ignores vote1 {}. Node is dormant", self, vote);
             return;
         }
-
         log.trace("Node {} received round 1 vote from {} for phase {} with value {}",
-                  self, vote.sender(), vote.phase(), vote.stateValue());
-
+                  self,
+                  vote.sender(),
+                  vote.phase(),
+                  vote.stateValue());
         var phaseData = getOrCreatePhaseData(vote.phase());
         phaseData.round1Votes.put(vote.sender(), vote.stateValue());
-
         // If we're active and in this phase, check if we can proceed to round 2
-        if (isInPhase.get()
-            && currentPhase.get().equals(vote.phase())
-            && !phaseData.round2Votes.containsKey(self)) {
-
+        if (isInPhase.get() && currentPhase.get()
+                                           .equals(vote.phase()) && !phaseData.round2Votes.containsKey(self)) {
             if (!phaseData.hasRound1MajorityVotes(topologyManager.quorumSize())) {
                 return;
             }
-
             var round2Vote = phaseData.evaluateRound2Vote(topologyManager.quorumSize());
-
             log.trace("Node {} votes in round 2 {}", self, round2Vote);
             network.broadcast(new VoteRound2(self, vote.phase(), round2Vote));
             phaseData.round2Votes.put(self, round2Vote);
@@ -446,18 +425,16 @@ private void handleVoteRound2(VoteRound2 vote) {
             log.warn("Node {} ignores vote2 {}. Node is dormant", self, vote);
             return;
         }
-
         log.trace("Node {} received round 2 vote from {} for phase {} with value {}",
-                  self, vote.sender(), vote.phase(), vote.stateValue());
-
+                  self,
+                  vote.sender(),
+                  vote.phase(),
+                  vote.stateValue());
         var phaseData = getOrCreatePhaseData(vote.phase());
         phaseData.round2Votes.put(vote.sender(), vote.stateValue());
-
         // If we're active and in this phase, check if we can make a decision
-        if (isInPhase.get()
-            && currentPhase.get().equals(vote.phase())
-            && !phaseData.hasDecided.get()) {
-
+        if (isInPhase.get() && currentPhase.get()
+                                           .equals(vote.phase()) && !phaseData.hasDecided.get()) {
             if (phaseData.hasRound2MajorityVotes(topologyManager.quorumSize())) {
                 var decision = phaseData.processRound2Completion(self, topologyManager.fPlusOne());
                 network.broadcast(decision);
@@ -470,7 +447,9 @@ private void commitDecision(PhaseData<C> phaseData, Decision<C> decision) {
         // Broadcast the decision
         if (phaseData.hasDecided.compareAndSet(false, true)) {
             // Apply commands to state machine ONLY if it was a V1 decision with a non-empty batch
-            if (decision.stateValue() == StateValue.V1 && !decision.value().commands().isEmpty()) {
+            if (decision.stateValue() == StateValue.V1 && !decision.value()
+                                                                   .commands()
+                                                                   .isEmpty()) {
                 commitChanges(phaseData, decision);
             }
             moveToNextPhase(phaseData.phase);
@@ -480,14 +459,17 @@ private void commitDecision(PhaseData<C> phaseData, Decision<C> decision) {
     @SuppressWarnings("unchecked")
     private void commitChanges(PhaseData<C> phaseData, Decision<C> decision) {
         log.trace("Node {} applies decision {}", self, decision);
-
-        var results = stateMachine.process(decision.value().commands());
+        var results = stateMachine.process(decision.value()
+                                                   .commands());
         lastCommittedPhase.set(phaseData.phase);
-        pendingBatches.remove(decision.value().correlationId());
-        correlationMap.computeIfPresent(decision.value().correlationId(), (_, promise) -> {
-            promise.succeed(results);
-            return null;    // Remove mapping
-        });
+        pendingBatches.remove(decision.value()
+                                      .correlationId());
+        correlationMap.computeIfPresent(decision.value()
+                                                .correlationId(),
+                                        (_, promise) -> {
+                                            promise.succeed(results);
+                                            return null;
+                                        });
     }
 
     /// Handles a decision message from another node.
@@ -496,9 +478,7 @@ private void handleDecision(Decision<C> decision) {
             log.warn("Node {} ignores decision {}. Node is dormant", self, decision);
             return;
         }
-
         log.trace("Node {} received decision {}", self, decision);
-
         commitDecision(getOrCreatePhaseData(decision.phase()), decision);
     }
 
@@ -507,9 +487,7 @@ private void moveToNextPhase(Phase currentPhase) {
         var nextPhase = currentPhase.successor();
         this.currentPhase.set(nextPhase);
         isInPhase.set(false);
-
         log.trace("Node {} moving to phase {}", self, nextPhase);
-
         // If we have more commands to process, start a new phase
         if (!pendingBatches.isEmpty()) {
             executor.execute(this::startPhase);
@@ -552,9 +530,10 @@ public Batch<C> findAgreedProposal(NodeId self) {
                                               .distinct()
                                               .count();
             if (distinctProposals == 1) {
-                return proposals.values().iterator().next();
+                return proposals.values()
+                                .iterator()
+                                .next();
             }
-
             // Otherwise, just use our own proposal or an empty one
             return proposals.getOrDefault(self, emptyBatch());
         }
@@ -568,13 +547,10 @@ public VoteRound1 evaluateInitialVote(NodeId self, Propose<C> propose) {
                                                                                                  .correlationId()))
                                             .distinct()
                                             .toList();
-
             if (existingProposal.size() > 1) {
                 return new VoteRound1(self, propose.phase(), StateValue.V0);
             }
-
             proposals.put(self, propose.value());
-
             return new VoteRound1(self, propose.phase(), StateValue.V1);
         }
 
@@ -585,23 +561,22 @@ public StateValue evaluateRound2Vote(int quorumSize) {
                     return value;
                 }
             }
-
             // Otherwise, vote VQUESTION
             return StateValue.VQUESTION;
         }
 
         public int countRound1VotesForValue(StateValue value) {
             return (int) round1Votes.values()
-                                    .stream()
-                                    .filter(v -> v == value)
-                                    .count();
+                                   .stream()
+                                   .filter(v -> v == value)
+                                   .count();
         }
 
         public int countRound2VotesForValue(StateValue value) {
             return (int) round2Votes.values()
-                                    .stream()
-                                    .filter(v -> v == value)
-                                    .count();
+                                   .stream()
+                                   .filter(v -> v == value)
+                                   .count();
         }
 
         public Decision<C> processRound2Completion(NodeId self, int fPlusOneSize) {
@@ -609,17 +584,14 @@ public Decision<C> processRound2Completion(NodeId self, int fPlusOneSize) {
             if (countRound2VotesForValue(StateValue.V1) >= fPlusOneSize) {
                 return new Decision<>(self, phase, StateValue.V1, findAgreedProposal(self));
             }
-
             // 2. Check for f+1 votes for V0
             if (countRound2VotesForValue(StateValue.V0) >= fPlusOneSize) {
                 return new Decision<>(self, phase, StateValue.V0, emptyBatch());
             }
-
             // 3. Fallback: If none of the above conditions are met, use the coin flip.
             //    This covers the ambiguous cases (mixed votes, including VQUESTION,
             //    that don't meet thresholds) and the "all VQUESTION" case implicitly.
             var decision = coinFlip(self);
-
             // If coin flip is V1, we still need to try and find *an* agreed proposal.
             // The definition of findAgreedProposal might need review for this case,
             // but typically it would look for *any* proposal associated with V1 votes
@@ -627,13 +599,13 @@ public Decision<C> processRound2Completion(NodeId self, int fPlusOneSize) {
             var batch = decision == StateValue.V1
                         ? findAgreedProposal(self)
                         : Batch.<C>emptyBatch();
-
             return new Decision<>(self, phase, decision, batch);
         }
 
         /// Gets a coin flip value for a phase, creating one if needed.
         private StateValue coinFlip(NodeId self) {
-            long seed = phase.value() ^ self.id().hashCode();
+            long seed = phase.value() ^ self.id()
+                                            .hashCode();
             return (Math.abs(seed) % 2 == 0)
                    ? StateValue.V0
                    : StateValue.V1;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
index 820a015b..c7d36fe6 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
@@ -18,8 +18,7 @@ public interface RabiaPersistence<C extends Command> {
     Option<SavedState<C>> load();
 
     static <C extends Command> RabiaPersistence<C> inMemory() {
-        record inMemory<C extends Command>(AtomicReference<SavedState<C>> state) implements RabiaPersistence<C> {
-
+        record inMemory <C extends Command>(AtomicReference<SavedState<C>> state) implements RabiaPersistence<C> {
             @Override
             public Result<Unit> save(StateMachine<C> stateMachine,
                                      Phase lastCommittedPhase,
@@ -35,11 +34,11 @@ public Result<Unit> save(StateMachine<C> stateMachine,
 
             @Override
             public Option<SavedState<C>> load() {
-                return Option.option(state().get());
+                return Option.option(state()
+                                     .get());
             }
         }
-
-        return new inMemory<>(new AtomicReference<>());
+        return new inMemory <>(new AtomicReference<>());
     }
 
     interface SavedState<C extends Command> {
@@ -52,17 +51,17 @@ interface SavedState<C extends Command> {
         static <C extends Command> SavedState<C> savedState(byte[] snapshot,
                                                             Phase lastCommittedPhase,
                                                             Collection<Batch<C>> pendingBatches) {
-            record savedState<C extends Command>(byte[] snapshot, Phase lastCommittedPhase,
-                                                 List<Batch<C>> pendingBatches) implements SavedState<C> {
+            record savedState <C extends Command>(byte[] snapshot,
+                                                  Phase lastCommittedPhase,
+                                                  List<Batch<C>> pendingBatches) implements SavedState<C> {
                 @Override
                 public boolean equals(Object o) {
-                    if (!(o instanceof savedState<?>(byte[] snapshot1, Phase committedPhase, List<?> batches))) {
+                    if (! (o instanceof savedState < ? >(byte[] snapshot1, Phase committedPhase, List< ? > batches))) {
                         return false;
                     }
-
-                    return Objects.deepEquals(snapshot(), snapshot1)
-                           && Objects.equals(lastCommittedPhase(), committedPhase)
-                           && Objects.equals(pendingBatches(), batches);
+                    return Objects.deepEquals(snapshot(), snapshot1) && Objects.equals(lastCommittedPhase(),
+                                                                                       committedPhase) && Objects.equals(pendingBatches(),
+                                                                                                                         batches);
                 }
 
                 @Override
@@ -70,8 +69,7 @@ public int hashCode() {
                     return Objects.hash(Arrays.hashCode(snapshot()), lastCommittedPhase(), pendingBatches());
                 }
             }
-
-            return new savedState<>(snapshot, lastCommittedPhase, List.copyOf(pendingBatches));
+            return new savedState <>(snapshot, lastCommittedPhase, List.copyOf(pendingBatches));
         }
 
         static <C extends Command> SavedState<C> empty() {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
index 85ac1105..ccce3469 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
@@ -10,23 +10,23 @@ public sealed interface RabiaProtocolMessage extends ProtocolMessage {
     sealed interface Synchronous extends RabiaProtocolMessage {
         /// Initial proposal from a node.
         record Propose<C extends Command>(NodeId sender, Phase phase, Batch<C> value)
-                implements Synchronous {}
+        implements Synchronous {}
 
         /// Round 1 vote message.
         record VoteRound1(NodeId sender, Phase phase, StateValue stateValue)
-                implements Synchronous {}
+        implements Synchronous {}
 
         /// Round 2 vote message.
         record VoteRound2(NodeId sender, Phase phase, StateValue stateValue)
-                implements Synchronous {}
+        implements Synchronous {}
 
         /// Decision broadcast message.
         record Decision<C extends Command>(
-                NodeId sender,
-                Phase phase,
-                StateValue stateValue,
-                Batch<C> value)
-                implements Synchronous {}
+        NodeId sender,
+        Phase phase,
+        StateValue stateValue,
+        Batch<C> value)
+        implements Synchronous {}
 
         /// State synchronization response.
         record SyncResponse<C extends Command>(NodeId sender, SavedState<C> state) implements Synchronous {}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
index bc034a88..39895d50 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
@@ -1,13 +1,10 @@
 package org.pragmatica.cluster.consensus.rabia;
-
 /// Represents the state values defined in the Rabia protocol (v0, v1, vquestion).
 public enum StateValue {
     /// Negative vote (no agreement).
     V0,
-
     /// Positive vote (agreement).
     V1,
-
     /// Uncertain/question (needs coin flip).
-    VQUESTION;
+    VQUESTION
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
index 09073073..3ab78283 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
@@ -19,34 +19,40 @@
 /// source of truth for the cluster management. The leader node can be used for this purpose.
 public interface LeaderManager {
     static LeaderManager leaderManager(NodeId self, MessageRouter router) {
-        record leaderManager(NodeId self, MessageRouter router, AtomicBoolean active,
+        record leaderManager(NodeId self,
+                             MessageRouter router,
+                             AtomicBoolean active,
                              AtomicReference<NodeId> currentLeader) implements LeaderManager {
             @Override
             public void nodeAdded(NodeAdded nodeAdded) {
-                tryElect(nodeAdded.topology().getFirst());
+                tryElect(nodeAdded.topology()
+                                  .getFirst());
             }
 
             @Override
             public void nodeRemoved(NodeRemoved nodeRemoved) {
                 // Should not happen, but better be safe than sorry.
-                if (nodeRemoved.topology().isEmpty()) {
+                if (nodeRemoved.topology()
+                               .isEmpty()) {
                     return;
                 }
-
-                tryElect(nodeRemoved.topology().getFirst());
+                tryElect(nodeRemoved.topology()
+                                    .getFirst());
             }
 
             @Override
             public void nodeDown(NodeDown nodeDown) {
-                currentLeader().set(null);
+                currentLeader()
+                .set(null);
                 stop();
             }
 
             private void tryElect(NodeId candidate) {
-                var oldLeader = currentLeader().get();
-
+                var oldLeader = currentLeader()
+                                .get();
                 // Potential leader change. Implicitly handles initial election.
-                if (currentLeader().compareAndSet(oldLeader, candidate)) {
+                if (currentLeader()
+                    .compareAndSet(oldLeader, candidate)) {
                     if (!candidate.equals(oldLeader)) {
                         notifyLeaderChange();
                     }
@@ -54,9 +60,13 @@ private void tryElect(NodeId candidate) {
             }
 
             private void notifyLeaderChange() {
-                if (active().get()) {
-                    var nodeId = currentLeader().get();
-                    router().route(leaderChange(option(nodeId), self.equals(nodeId)));
+                if (active()
+                    .get()) {
+                    var nodeId = currentLeader()
+                                 .get();
+                    router()
+                    .route(leaderChange(option(nodeId),
+                                        self.equals(nodeId)));
                 }
             }
 
@@ -76,12 +86,14 @@ private void start() {
             private void stop() {
                 // Set inactive first to prevent new elections during shutdown
                 active.set(false);
-                currentLeader().set(null);
+                currentLeader()
+                .set(null);
                 // Send notification directly since active is now false
-                router().route(leaderChange(option(null), false));
+                router()
+                .route(leaderChange(option(null),
+                                    false));
             }
         }
-
         return new leaderManager(self, router, new AtomicBoolean(false), new AtomicReference<>());
     }
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java b/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
index 842af3e9..7eab3d05 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
@@ -12,36 +12,39 @@
  * nodes respond with their local metrics.
  */
 public sealed interface DeploymentMetricsMessage extends ProtocolMessage {
-
     /**
      * Single deployment metrics entry using primitive types for serialization.
      */
     record DeploymentMetricsEntry(
-        String artifact,          // Artifact as string
-        String nodeId,            // NodeId as string
-        long startTime,           // T0: Blueprint change
-        long loadTime,            // T1: LOAD received
-        long loadedTime,          // T2: LOADED committed
-        long activateTime,        // T3: ACTIVATE committed
-        long activeTime,          // T4: ACTIVE committed
-        String status             // SUCCESS, FAILED_LOADING, FAILED_ACTIVATING, IN_PROGRESS
-    ) {}
+    String artifact,
+    // Artifact as string
+    String nodeId,
+    // NodeId as string
+    long startTime,
+    // T0: Blueprint change
+    long loadTime,
+    // T1: LOAD received
+    long loadedTime,
+    // T2: LOADED committed
+    long activateTime,
+    // T3: ACTIVATE committed
+    long activeTime,
+    // T4: ACTIVE committed
+    String status) {}
 
     /**
      * Deployment metrics ping sent by leader to all nodes.
      * Contains aggregated deployment metrics from all known deployments.
      */
     record DeploymentMetricsPing(
-        NodeId sender,
-        Map<String, List<DeploymentMetricsEntry>> metrics  // artifact -> list of entries
-    ) implements DeploymentMetricsMessage {}
+    NodeId sender,
+    Map<String, List<DeploymentMetricsEntry>> metrics) implements DeploymentMetricsMessage {}
 
     /**
      * Deployment metrics pong sent by nodes in response to ping.
      * Contains local deployment metrics.
      */
     record DeploymentMetricsPong(
-        NodeId sender,
-        Map<String, List<DeploymentMetricsEntry>> metrics  // artifact -> list of entries
-    ) implements DeploymentMetricsMessage {}
+    NodeId sender,
+    Map<String, List<DeploymentMetricsEntry>> metrics) implements DeploymentMetricsMessage {}
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java b/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
index 8ce238ba..1b3d0bea 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
@@ -11,7 +11,6 @@
  * nodes respond with their metrics.
  */
 public sealed interface MetricsMessage extends ProtocolMessage {
-
     /**
      * Metrics ping sent by leader to all nodes.
      * Contains sender's metrics, nodes respond with their own.
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java b/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
index c94c11e0..3f37d583 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
@@ -6,7 +6,8 @@
 public record NodeId(String id) implements Comparable<NodeId> {
     @Override
     public int compareTo(NodeId o) {
-        return id().compareTo(o.id());
+        return id()
+               .compareTo(o.id());
     }
 
     /// Create new node ID from the given string.
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java b/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
index f5f652d5..edf55dea 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
@@ -11,7 +11,6 @@ public interface NodeInfo {
     /// Create new node information.
     static NodeInfo nodeInfo(NodeId id, NodeAddress address) {
         record nodeInfo(NodeId id, NodeAddress address) implements NodeInfo {}
-
         return new nodeInfo(id, address);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
index 4c99cfce..9b7eeed8 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
@@ -1,15 +1,16 @@
 package org.pragmatica.cluster.net.netty;
 
+import org.pragmatica.message.Message;
+import org.pragmatica.net.serialization.Deserializer;
+
+import java.util.List;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
-import org.pragmatica.message.Message;
-import org.pragmatica.net.serialization.Deserializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.List;
-
 public class Decoder extends ByteToMessageDecoder {
     private static final Logger log = LoggerFactory.getLogger(Decoder.class);
 
@@ -21,12 +22,11 @@ public Decoder(Deserializer deserializer) {
 
     @Override
     protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
-        try {
+        try{
             var object = deserializer.read(in);
-
             if (object instanceof Message.Wired) {
                 out.add(object);
-            } else {
+            }else {
                 log.error("Attempt to decode non-Wired object: {}", object);
             }
         } catch (Exception e) {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
index 649923a8..614ede33 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
@@ -1,10 +1,11 @@
 package org.pragmatica.cluster.net.netty;
 
+import org.pragmatica.message.Message;
+import org.pragmatica.net.serialization.Serializer;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
-import org.pragmatica.message.Message;
-import org.pragmatica.net.serialization.Serializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -19,7 +20,7 @@ public Encoder(Serializer serializer) {
 
     @Override
     protected void encode(ChannelHandlerContext ctx, Message.Wired msg, ByteBuf out) {
-        try {
+        try{
             serializer.write(out, msg);
         } catch (Exception e) {
             log.error("Error encoding message", e);
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
index a8b62349..fbbbd5bb 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
@@ -1,14 +1,15 @@
 package org.pragmatica.cluster.net.netty;
 
+import org.pragmatica.message.Message;
+
+import java.util.function.Consumer;
+
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import org.pragmatica.message.Message;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.function.Consumer;
-
 public class Handler extends SimpleChannelInboundHandler<Message.Wired> {
     private static final Logger log = LoggerFactory.getLogger(Handler.class);
     private final Consumer<Channel> peerConnected;
@@ -26,8 +27,7 @@ public Handler(Consumer<Channel> peerConnected,
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, Message.Wired msg) {
         log.trace("Received message: {}", msg);
-
-        try {
+        try{
             messageHandler.accept(msg);
         } catch (Exception e) {
             log.error("Error handling message: {}", msg, e);
@@ -36,15 +36,17 @@ protected void channelRead0(ChannelHandlerContext ctx, Message.Wired msg) {
 
     @Override
     public void channelActive(ChannelHandlerContext ctx) {
-        log.debug("New channel active: {}", ctx.channel().remoteAddress());
-
+        log.debug("New channel active: {}",
+                  ctx.channel()
+                     .remoteAddress());
         peerConnected.accept(ctx.channel());
     }
 
     @Override
     public void channelInactive(ChannelHandlerContext ctx) {
-        log.debug("Channel deactivated: {}", ctx.channel().remoteAddress());
-
+        log.debug("Channel deactivated: {}",
+                  ctx.channel()
+                     .remoteAddress());
         peerDisconnected.accept(ctx.channel());
     }
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 7b65b846..380f442c 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -1,9 +1,5 @@
 package org.pragmatica.cluster.net.netty;
 
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelHandler;
-import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
-import io.netty.handler.codec.LengthFieldPrepender;
 import org.pragmatica.cluster.consensus.ProtocolMessage;
 import org.pragmatica.cluster.net.ClusterNetwork;
 import org.pragmatica.cluster.net.NetworkManagementOperation;
@@ -25,8 +21,6 @@
 import org.pragmatica.net.Server;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -39,6 +33,13 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandler;
+import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
+import io.netty.handler.codec.LengthFieldPrepender;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.cluster.net.NetworkManagementOperation.ConnectNode;
 import static org.pragmatica.cluster.net.NetworkManagementOperation.DisconnectNode;
 import static org.pragmatica.cluster.net.netty.NettyClusterNetwork.ViewChangeOperation.*;
@@ -63,15 +64,17 @@ public class NettyClusterNetwork implements ClusterNetwork {
     private final Executor executor;
 
     enum ViewChangeOperation {
-        ADD, REMOVE, SHUTDOWN
+        ADD,
+        REMOVE,
+        SHUTDOWN
     }
 
     public NettyClusterNetwork(TopologyManager topologyManager,
                                Serializer serializer,
                                Deserializer deserializer,
                                MessageRouter router) {
-
-        var processors = Runtime.getRuntime().availableProcessors();
+        var processors = Runtime.getRuntime()
+                                .availableProcessors();
         this.executor = Executors.newFixedThreadPool(processors > 1
                                                      ? processors
                                                      : 2);
@@ -79,12 +82,11 @@ public NettyClusterNetwork(TopologyManager topologyManager,
         this.topologyManager = topologyManager;
         this.router = router;
         this.handlers = () -> List.of(
-                new LengthFieldBasedFrameDecoder(1048576, 0, LENGTH_FIELD_LEN, 0, INITIAL_BYTES_TO_STRIP),
-                new LengthFieldPrepender(LENGTH_FIELD_LEN),
-                new Decoder(deserializer),
-                new Encoder(serializer),
-                new Handler(this::peerConnected, this::peerDisconnected, router::route));
-
+        new LengthFieldBasedFrameDecoder(1048576, 0, LENGTH_FIELD_LEN, 0, INITIAL_BYTES_TO_STRIP),
+        new LengthFieldPrepender(LENGTH_FIELD_LEN),
+        new Decoder(deserializer),
+        new Encoder(serializer),
+        new Handler(this::peerConnected, this::peerDisconnected, router::route));
         schedulePing();
     }
 
@@ -93,37 +95,39 @@ public void configure(MessageRouter.MutableRouter router) {
         router.addRoute(ConnectNode.class, this::connect);
         router.addRoute(DisconnectNode.class, this::disconnect);
         router.addRoute(ListConnectedNodes.class, this::listNodes);
-
         router.addRoute(Ping.class, this::handlePing);
         router.addRoute(Pong.class, this::handlePong);
     }
 
     private void schedulePing() {
-        SharedScheduler.schedule(this::pingNodes, topologyManager.pingInterval().randomize(SCALE));
+        SharedScheduler.schedule(this::pingNodes,
+                                 topologyManager.pingInterval()
+                                                .randomize(SCALE));
     }
 
     private Option<NodeId> randomNode() {
         if (!isRunning.get() || peerLinks.isEmpty()) {
             return Option.none();
         }
-
         var ids = new ArrayList<>(peerLinks.keySet());
         Collections.shuffle(ids);
-
         return Option.some(ids.getFirst());
     }
 
     private void pingNodes() {
         randomNode()
-                .onPresent(peerId -> sendToChannel(peerId, new Ping(self.id()), peerLinks.get(peerId)));
-
+        .onPresent(peerId -> sendToChannel(peerId,
+                                           new Ping(self.id()),
+                                           peerLinks.get(peerId)));
         schedulePing();
     }
 
     @Override
     public void handlePing(Ping ping) {
         log.debug("Node {} received ping from {}", self.id(), ping.sender());
-        sendToChannel(ping.sender(), new Pong(self.id()), peerLinks.get(ping.sender()));
+        sendToChannel(ping.sender(),
+                      new Pong(self.id()),
+                      peerLinks.get(ping.sender()));
     }
 
     @Override
@@ -142,7 +146,8 @@ private void peerConnected(Channel channel) {
                        .onPresent(nodeId -> peerLinks.put(nodeId, channel))
                        .onPresent(nodeId -> log.debug("Node {} connected", nodeId))
                        .onPresent(nodeId -> processViewChange(ADD, nodeId))
-                       .onEmpty(() -> log.warn("Unknown node {}, disconnecting", channel.remoteAddress()))
+                       .onEmpty(() -> log.warn("Unknown node {}, disconnecting",
+                                               channel.remoteAddress()))
                        .onEmpty(() -> channel.close()
                                              .addListener(_ -> log.info("Host {} disconnected",
                                                                         channel.remoteAddress())));
@@ -158,43 +163,46 @@ private void peerDisconnected(Channel channel) {
     @Override
     public Promise<Unit> start() {
         if (isRunning.compareAndSet(false, true)) {
-            return Server.server("NettyClusterNetwork", self.address().port(), handlers)
+            return Server.server("NettyClusterNetwork",
+                                 self.address()
+                                     .port(),
+                                 handlers)
                          .onSuccess(NettyClusterNetwork.this.server::set)
                          .onFailure(_ -> isRunning.set(false))
                          .mapToUnit();
         }
-
         return Promise.unitPromise();
     }
 
     @Override
     public Promise<Unit> stop() {
         if (isRunning.compareAndSet(true, false)) {
-            log.info("Stopping {}: notifying view change", server.get().name());
+            log.info("Stopping {}: notifying view change",
+                     server.get()
+                           .name());
             processViewChange(SHUTDOWN, self.id());
-
             return server.get()
                          .stop(() -> {
-                             log.info("Stopping {}: closing peer connections", server.get().name());
-
-                             var promises = new ArrayList<Promise<Unit>>();
-                             for (var link : peerLinks.values()) {
-                                 var promise = Promise.<Unit>promise();
-                                 link.close()
-                                     .addListener(future -> {
-                                         if (future.isSuccess()) {
-                                             promise.succeed(Unit.unit());
-                                         } else {
-                                             promise.fail(Causes.fromThrowable(future.cause()));
-                                         }
-                                     });
-                                 promises.add(promise);
-                             }
-                             return Promise.allOf(promises)
-                                           .mapToUnit();
-                         });
+                                   log.info("Stopping {}: closing peer connections",
+                                            server.get()
+                                                  .name());
+                                   var promises = new ArrayList<Promise<Unit>>();
+                                   for (var link : peerLinks.values()) {
+                                   var promise = Promise.<Unit>promise();
+                                   link.close()
+                                       .addListener(future -> {
+                                                        if (future.isSuccess()) {
+                                                        promise.succeed(Unit.unit());
+                                                    }else {
+                                                        promise.fail(Causes.fromThrowable(future.cause()));
+                                                    }
+                                                    });
+                                   promises.add(promise);
+                               }
+                                   return Promise.allOf(promises)
+                                                 .mapToUnit();
+                               });
         }
-
         return Promise.unitPromise();
     }
 
@@ -204,24 +212,22 @@ public void connect(ConnectNode connectNode) {
             log.error("Attempt to connect {} while node is not running", connectNode.node());
             return;
         }
-
-        if (connectNode.node().equals(self.id())) {
+        if (connectNode.node()
+                       .equals(self.id())) {
             return;
         }
-
         topologyManager.get(connectNode.node())
                        .onPresent(this::connectPeer)
-                       .onEmpty(() -> log.error("Unknown {}", connectNode.node()));
+                       .onEmpty(() -> log.error("Unknown {}",
+                                                connectNode.node()));
     }
 
     private void connectPeer(NodeInfo nodeInfo) {
         var peerId = nodeInfo.id();
-
         if (peerLinks.containsKey(peerId)) {
             log.warn("Node {} already connected", peerId);
             return;
         }
-
         // Executed asynchronously to avoid blocking the main thread
         server.get()
               .connectTo(nodeInfo.address())
@@ -229,31 +235,33 @@ private void connectPeer(NodeInfo nodeInfo) {
                   peerLinks.put(peerId, channel);
                   processViewChange(ADD, peerId);
               })
-              .onFailure(cause -> log.warn("Node {} failed to connect to {}: {}", peerId, nodeInfo.id(), cause));
+              .onFailure(cause -> log.warn("Node {} failed to connect to {}: {}",
+                                           peerId,
+                                           nodeInfo.id(),
+                                           cause));
     }
 
     @Override
     public void disconnect(DisconnectNode disconnectNode) {
         var channel = peerLinks.remove(disconnectNode.nodeId());
-
         if (channel == null) {
             return;
         }
-
         processViewChange(REMOVE, disconnectNode.nodeId());
-
         // Executed asynchronously to avoid blocking the main thread
         channel.close()
                .addListener(future -> {
-                   if (future.isSuccess()) {
-                       log.info("Node {} disconnected from node {}", self.id(), disconnectNode.nodeId());
-                   } else {
-                       log.warn("Node {} failed to disconnect from node {}: ",
-                                self.id(),
-                                disconnectNode.nodeId(),
-                                future.cause());
-                   }
-               });
+                                if (future.isSuccess()) {
+                                log.info("Node {} disconnected from node {}",
+                                         self.id(),
+                                         disconnectNode.nodeId());
+                            }else {
+                                log.warn("Node {} failed to disconnect from node {}: ",
+                                         self.id(),
+                                         disconnectNode.nodeId(),
+                                         future.cause());
+                            }
+                            });
     }
 
     @Override
@@ -266,21 +274,18 @@ private <M extends Message.Wired> void sendToChannel(NodeId peerId, M message, C
             log.warn("Node {} is not connected", peerId);
             return;
         }
-
         if (!channel.isActive()) {
             peerLinks.remove(peerId);
             processViewChange(REMOVE, peerId);
             log.warn("Node {} is not active", peerId);
             return;
         }
-
         channel.writeAndFlush(message);
     }
 
     @Override
     public <M extends ProtocolMessage> void broadcast(M message) {
-        peerLinks.forEach((peerId, channel) ->
-                                  executor.execute(() -> sendToChannel(peerId, message, channel)));
+        peerLinks.forEach((peerId, channel) -> executor.execute(() -> sendToChannel(peerId, message, channel)));
     }
 
     private void processViewChange(ViewChangeOperation operation, NodeId peerId) {
@@ -302,7 +307,6 @@ private void processViewChange(ViewChangeOperation operation, NodeId peerId) {
                 yield TopologyChangeNotification.nodeDown(peerId);
             }
         };
-
         router.route(viewChange);
     }
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
index cd1462a4..d8bf4494 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
@@ -12,17 +12,16 @@
 import static org.pragmatica.utility.HierarchyScanner.concreteSubtypes;
 
 public interface CustomClasses {
-
-    static void configure(Consumer<Class<?>> consumer) {
+    static void configure(Consumer<Class< ? >> consumer) {
         concreteSubtypes(RabiaProtocolMessage.class)
-                .forEach(consumer);
+        .forEach(consumer);
         concreteSubtypes(NetworkMessage.class)
-                .forEach(consumer);
+        .forEach(consumer);
         concreteSubtypes(KVCommand.class)
-                .forEach(consumer);
-
+        .forEach(consumer);
         consumer.accept(HashMap.class);
-        consumer.accept(RabiaPersistence.SavedState.empty().getClass());
+        consumer.accept(RabiaPersistence.SavedState.empty()
+                                        .getClass());
         consumer.accept(NodeId.class);
         consumer.accept(BatchId.class);
         consumer.accept(CorrelationId.class);
@@ -30,8 +29,11 @@ static void configure(Consumer<Class<?>> consumer) {
         consumer.accept(Batch.class);
         consumer.accept(StateValue.class);
         consumer.accept(byte[].class);
-        consumer.accept(List.of().getClass());
-        consumer.accept(List.of(1).getClass());
-        consumer.accept(List.of(1, 2, 3).getClass());
+        consumer.accept(List.of()
+                            .getClass());
+        consumer.accept(List.of(1)
+                            .getClass());
+        consumer.accept(List.of(1, 2, 3)
+                            .getClass());
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
index 685585f5..24f6f533 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
@@ -10,7 +10,6 @@ public interface NodeConfig {
 
     static NodeConfig nodeConfig(ProtocolConfig protocol, TopologyConfig topology) {
         record nodeConfig(ProtocolConfig protocol, TopologyConfig topology) implements NodeConfig {}
-
         return new nodeConfig(protocol, topology);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index f147d04a..7bb545eb 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -25,7 +25,6 @@
 import java.util.List;
 
 public interface RabiaNode<C extends Command> extends ClusterNode<C> {
-
     @SuppressWarnings("unused")
     MessageRouter router();
 
@@ -36,44 +35,48 @@ static <C extends Command> RabiaNode<C> rabiaNode(NodeConfig config,
                                                       StateMachine<C> stateMachine,
                                                       Serializer serializer,
                                                       Deserializer deserializer) {
-        record rabiaNode<C extends Command>(NodeConfig config,
-                                            MessageRouter router,
-                                            StateMachine<C> stateMachine,
-                                            ClusterNetwork network,
-                                            TopologyManager topologyManager,
-                                            RabiaEngine<C> consensus,
-                                            LeaderManager leaderManager) implements RabiaNode<C> {
+        record rabiaNode <C extends Command>(NodeConfig config,
+                                             MessageRouter router,
+                                             StateMachine<C> stateMachine,
+                                             ClusterNetwork network,
+                                             TopologyManager topologyManager,
+                                             RabiaEngine<C> consensus,
+                                             LeaderManager leaderManager) implements RabiaNode<C> {
             @Override
             public NodeId self() {
-                return config().topology().self();
+                return config()
+                       .topology()
+                       .self();
             }
 
             @Override
             public Promise<Unit> start() {
-                return network().start()
-                                .onSuccessRunAsync(topologyManager()::start)
-                                .flatMap(consensus()::start);
+                return network()
+                       .start()
+                       .onSuccessRunAsync(topologyManager()::start)
+                       .flatMap(consensus()::start);
             }
 
             @Override
             public Promise<Unit> stop() {
-                return consensus().stop()
-                                  .onResultRun(topologyManager()::stop)
-                                  .flatMap(network()::stop);
+                return consensus()
+                       .stop()
+                       .onResultRun(topologyManager()::stop)
+                       .flatMap(network()::stop);
             }
 
             @Override
             public <R> Promise<List<R>> apply(List<C> commands) {
-                return consensus().apply(commands);
+                return consensus()
+                       .apply(commands);
             }
         }
-
         var topologyManager = TcpTopologyManager.tcpTopologyManager(config.topology(), router);
-        var leaderManager = LeaderManager.leaderManager(config.topology().self(), router);
+        var leaderManager = LeaderManager.leaderManager(config.topology()
+                                                              .self(),
+                                                        router);
         var network = new NettyClusterNetwork(topologyManager, serializer, deserializer, router);
-        var consensus = new RabiaEngine<>(topologyManager, network, stateMachine,
-                                          config.protocol());
-
+        var consensus = new RabiaEngine<>(topologyManager, network, stateMachine, config.protocol());
         // TODO: Migrate to ImmutableRouter - all routes need centralized assembly
         router.addRoute(TopologyManagementMessage.AddNode.class, topologyManager::handleAddNodeMessage);
         router.addRoute(TopologyManagementMessage.RemoveNode.class, topologyManager::handleRemoveNodeMessage);
@@ -86,7 +89,6 @@ public <R> Promise<List<R>> apply(List<C> commands) {
         router.addRoute(QuorumStateNotification.class, leaderManager::watchQuorumState);
         network.configure(router);
         consensus.configure(router);
-
-        return new rabiaNode<>(config, router, stateMachine, network, topologyManager, consensus, leaderManager);
+        return new rabiaNode <>(config, router, stateMachine, network, topologyManager, consensus, leaderManager);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/Command.java b/cluster/src/main/java/org/pragmatica/cluster/state/Command.java
index 988c8c93..afa1f8e8 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/Command.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/Command.java
@@ -1,5 +1,3 @@
 package org.pragmatica.cluster.state;
-
 /// Marker interface for state machine commands.
-public interface Command {
-}
+public interface Command {}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
index 5b148c09..2395f671 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
@@ -16,7 +16,8 @@ public interface StateMachine<T extends Command> {
 
     @SuppressWarnings("unchecked")
     default <R> List<R> process(List<T> commands) {
-        return commands.stream().map(command -> (R) process(command))
+        return commands.stream()
+                       .map(command -> (R) process(command))
                        .toList();
     }
 
@@ -24,7 +25,7 @@ default <R> List<R> process(List<T> commands) {
     /// The snapshot should be serializable and should capture the complete state.
     ///
     /// @return A Result containing the serialized state snapshot
-    Result<byte[]> makeSnapshot();
+    Result<byte[] > makeSnapshot();
 
     /// Restore the machine's state from a snapshot.
     /// This should completely replace the current state with the state from the snapshot.
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index ed6a1b6d..1c56a094 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -44,46 +44,40 @@ public void configure(MutableRouter router) {
     @Override
     public Option<V> process(KVCommand command) {
         return switch (command) {
-            case Get<?> get -> handleGet((Get<K>) get);
-            case Put<?, ?> put -> handlePut((Put<K, V>) put);
-            case Remove<?> remove -> handleRemove((Remove<K>) remove);
+            case Get< ? > get -> handleGet((Get<K>) get);
+            case Put< ? , ? > put -> handlePut((Put<K, V>) put);
+            case Remove< ? > remove -> handleRemove((Remove<K>) remove);
         };
     }
 
     private Option<V> handleGet(Get<K> get) {
         var value = Option.option(storage.get(get.key()));
-
         router.route(new ValueGet<>(get, value));
-
         return value;
     }
 
     private Option<V> handlePut(Put<K, V> put) {
         var oldValue = Option.option(storage.put(put.key(), put.value()));
-
         router.route(new ValuePut<>(put, oldValue));
-
         return oldValue;
     }
 
     private Option<V> handleRemove(Remove<K> remove) {
         var oldValue = Option.option(storage.remove(remove.key()));
-
         router.route(new ValueRemove<>(remove, oldValue));
-
         return oldValue;
     }
 
     @Override
-    public Result<byte[]> makeSnapshot() {
-        return Result.lift(Causes::fromThrowable,
-                           () -> serializer.encode(new HashMap<>(storage)));
+    public Result<byte[] > makeSnapshot() {
+        return Result.lift(Causes::fromThrowable, () -> serializer.encode(new HashMap<>(storage)));
     }
 
     @SuppressWarnings("unchecked")
     @Override
     public Result<Unit> restoreSnapshot(byte[] snapshot) {
-        return Result.lift(Causes::fromThrowable, () -> deserializer.decode(snapshot))
+        return Result.lift(Causes::fromThrowable,
+                           () -> deserializer.decode(snapshot))
                      .map(map -> (Map<K, V>) map)
                      .onSuccessRun(this::notifyRemoveAll)
                      .onSuccessRun(storage::clear)
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
index 2b951c5a..f144bbc8 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
@@ -9,7 +9,8 @@ public sealed interface KVStoreLocalIO extends Message.Local {
     sealed interface Request extends KVStoreLocalIO {
         record Find(StructuredPattern pattern) implements Request {
             public <K extends StructuredKey, V> boolean matches(Map.Entry<K, V> entry) {
-                return entry.getKey().matches(pattern);
+                return entry.getKey()
+                            .matches(pattern);
             }
         }
     }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
index d7c2f786..c711358c 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
@@ -5,15 +5,15 @@
 
 public sealed interface KVStoreNotification<K extends StructuredKey> extends StateMachineNotification<KVCommand<K>> {
     default boolean matches(StructuredPattern pattern) {
-        return cause().key().matches(pattern);
+        return cause()
+               .key()
+               .matches(pattern);
     }
 
-    record ValuePut<K extends StructuredKey, V>(KVCommand.Put<K, V> cause, Option<V> oldValue) implements
-                                                                                               KVStoreNotification<K> {}
+    record ValuePut<K extends StructuredKey, V>(KVCommand.Put<K, V> cause, Option<V> oldValue) implements KVStoreNotification<K> {}
 
     record ValueGet<K extends StructuredKey, V>(KVCommand.Get<K> cause,
                                                 Option<V> value) implements KVStoreNotification<K> {}
 
-    record ValueRemove<K extends StructuredKey, V>(KVCommand.Remove<K> cause, Option<V> value) implements
-                                                                                               KVStoreNotification<K> {}
+    record ValueRemove<K extends StructuredKey, V>(KVCommand.Remove<K> cause, Option<V> value) implements KVStoreNotification<K> {}
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredKey.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredKey.java
index bf38e0c9..72725fcd 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredKey.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredKey.java
@@ -1,5 +1,4 @@
 package org.pragmatica.cluster.state.kvstore;
-
 public interface StructuredKey {
     boolean matches(StructuredPattern pattern);
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredPattern.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredPattern.java
index 2076693d..2aa67ba6 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredPattern.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/StructuredPattern.java
@@ -1,4 +1,2 @@
 package org.pragmatica.cluster.state.kvstore;
-
-public interface StructuredPattern {
-}
+public interface StructuredPattern {}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java b/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
index d097186b..0a3afb01 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
@@ -5,5 +5,5 @@
 /// Quorum state notifications
 public enum QuorumStateNotification implements Message.Local {
     ESTABLISHED,
-    DISAPPEARED,
+    DISAPPEARED
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
index f98d5fc2..cef905d1 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
@@ -11,8 +11,6 @@
 import org.pragmatica.message.MessageReceiver;
 import org.pragmatica.message.MessageRouter;
 import org.pragmatica.net.NodeAddress;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
@@ -22,6 +20,9 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicBoolean;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /// Topology manager for TCP/IP networks.
 public interface TcpTopologyManager extends TopologyManager {
     @MessageReceiver
@@ -44,10 +45,11 @@ public interface TcpTopologyManager extends TopologyManager {
     void stop();
 
     static TcpTopologyManager tcpTopologyManager(TopologyConfig config, MessageRouter router) {
-        record Manager(Map<NodeId, NodeInfo> nodesById, Map<NodeAddress, NodeId> nodeIdsByAddress,
-                       MessageRouter router, TopologyConfig config, AtomicBoolean active) implements
-                                                                                          TcpTopologyManager {
-
+        record Manager(Map<NodeId, NodeInfo> nodesById,
+                       Map<NodeAddress, NodeId> nodeIdsByAddress,
+                       MessageRouter router,
+                       TopologyConfig config,
+                       AtomicBoolean active) implements TcpTopologyManager {
             private static final Logger log = LoggerFactory.getLogger(TcpTopologyManager.class);
 
             Manager(Map<NodeId, NodeInfo> nodesById,
@@ -60,29 +62,30 @@ record Manager(Map<NodeId, NodeInfo> nodesById, Map<NodeAddress, NodeId> nodeIds
                 this.nodesById = nodesById;
                 this.nodeIdsByAddress = nodeIdsByAddress;
                 this.active = active;
-
-                config().coreNodes().forEach(this::addNode);
-
+                config()
+                .coreNodes()
+                .forEach(this::addNode);
                 log.trace("Topology manager {} initialized with {} nodes", config.self(), config.coreNodes());
-
                 SharedScheduler.scheduleAtFixedRate(this::initReconcile, config.reconciliationInterval());
             }
 
             private void initReconcile() {
                 if (active.get()) {
-                    router().route(new NetworkManagementOperation.ListConnectedNodes());
-                } else if (nodesById().isEmpty()) {
-                    config().coreNodes().forEach(this::addNode);
+                    router()
+                    .route(new NetworkManagementOperation.ListConnectedNodes());
+                }else if (nodesById()
+                          .isEmpty()) {
+                    config()
+                    .coreNodes()
+                    .forEach(this::addNode);
                 }
             }
 
             @Override
             public void reconcile(NetworkManagementOperation.ConnectedNodesList connectedNodesList) {
                 var snapshot = new HashSet<>(nodesById.keySet());
-
                 connectedNodesList.connected()
                                   .forEach(snapshot::remove);
-
                 snapshot.forEach(this::requestConnection);
             }
 
@@ -98,36 +101,45 @@ public void handleRemoveNodeMessage(TopologyManagementMessage.RemoveNode removeN
 
             @Override
             public void handleDiscoverNodesMessage(TopologyManagementMessage.DiscoverNodes discoverNodes) {
-                router().route(new TopologyManagementMessage.DiscoveredNodes(List.copyOf(nodesById.values())));
+                router()
+                .route(new TopologyManagementMessage.DiscoveredNodes(List.copyOf(nodesById.values())));
             }
 
             @Override
             public void handleMergeNodesMessage(TopologyManagementMessage.DiscoveredNodes discoveredNodes) {
-                discoveredNodes.nodeInfos().forEach(this::addNode);
+                discoveredNodes.nodeInfos()
+                               .forEach(this::addNode);
             }
 
             private void addNode(NodeInfo nodeInfo) {
                 // To avoid reliance on the networking layer behavior, adding is done
                 // atomically and the command to establish the connection is sent only once.
-                if (nodesById().putIfAbsent(nodeInfo.id(), nodeInfo) == null) {
-                    nodeIdsByAddress().putIfAbsent(nodeInfo.address(), nodeInfo.id());
+                if (nodesById()
+                    .putIfAbsent(nodeInfo.id(),
+                                 nodeInfo) == null) {
+                    nodeIdsByAddress()
+                    .putIfAbsent(nodeInfo.address(),
+                                 nodeInfo.id());
                     requestConnection(nodeInfo.id());
                 }
             }
 
             private void requestConnection(NodeId id) {
-                router().route(new NetworkManagementOperation.ConnectNode(id));
+                router()
+                .route(new NetworkManagementOperation.ConnectNode(id));
             }
 
             private void removeNode(NodeId nodeId) {
                 // To avoid reliance on the networking layer behavior, removing is done
                 // atomically and command to drop the connection is sent only once.
-                nodesById().computeIfPresent(nodeId, (_, value) -> {
-                    nodeIdsByAddress.remove(value.address());
-
-                    router().route(new NetworkManagementOperation.DisconnectNode(nodeId));
-                    return null;
-                });
+                nodesById()
+                .computeIfPresent(nodeId,
+                                  (_, value) -> {
+                                      nodeIdsByAddress.remove(value.address());
+                                      router()
+                                      .route(new NetworkManagementOperation.DisconnectNode(nodeId));
+                                      return null;
+                                  });
             }
 
             @Override
@@ -149,7 +161,8 @@ public Option<NodeId> reverseLookup(SocketAddress socketAddress) {
 
             @Override
             public void start() {
-                if (active().compareAndSet(false, true)) {
+                if (active()
+                    .compareAndSet(false, true)) {
                     log.trace("Starting topology manager at {}", config.self());
                     initReconcile();
                 }
@@ -157,24 +170,26 @@ public void start() {
 
             @Override
             public void stop() {
-                active().set(false);
+                active()
+                .set(false);
             }
 
             @Override
             public NodeInfo self() {
-                return nodesById().get(config.self());
+                return nodesById()
+                       .get(config.self());
             }
 
             @Override
             public TimeSpan pingInterval() {
-                return config().pingInterval();
+                return config()
+                       .pingInterval();
             }
         }
-
         return new Manager(new ConcurrentHashMap<>(),
                            new ConcurrentHashMap<>(),
                            router,
                            config,
                            new AtomicBoolean(false));
     }
-}
\ No newline at end of file
+}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
index 4f31259c..e26157d2 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
@@ -9,5 +9,4 @@
 public record TopologyConfig(NodeId self,
                              TimeSpan reconciliationInterval,
                              TimeSpan pingInterval,
-                             List<NodeInfo> coreNodes) {
-}
+                             List<NodeInfo> coreNodes) {}
diff --git a/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java b/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
index 5cfd5ab3..a0c52c07 100644
--- a/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
+++ b/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
@@ -43,11 +43,10 @@ public static <N extends Comparable<N>> ConsistentHashRing<N> create(int virtual
      */
     public synchronized void addNode(N node) {
         if (nodeToVirtualNodes.containsKey(node)) {
-            return; // Already present
+            return;
         }
-
         List<Integer> virtualNodes = new ArrayList<>(virtualNodesPerPhysical);
-        for (int i = 0; i < virtualNodesPerPhysical; i++) {
+        for (int i = 0; i < virtualNodesPerPhysical; i++ ) {
             int hash = hash(node.toString() + "#" + i);
             ring.put(hash, node);
             virtualNodes.add(hash);
@@ -110,26 +109,21 @@ public List<N> nodesFor(byte[] key, int replicaCount) {
         if (replicaCount <= 0) {
             return List.of();
         }
-
         int hash = hash(key);
         Set<N> seen = new LinkedHashSet<>();
-
         // Start from the hash position and walk clockwise
         Integer current = ring.ceilingKey(hash);
         if (current == null) {
             current = ring.firstKey();
         }
-
         while (seen.size() < replicaCount && seen.size() < nodeToVirtualNodes.size()) {
             N node = ring.get(current);
             seen.add(node);
-
             current = ring.higherKey(current);
             if (current == null) {
                 current = ring.firstKey();
             }
         }
-
         return new ArrayList<>(seen);
     }
 
@@ -180,11 +174,11 @@ private static int hash(byte[] data) {
             h *= 0x01000193;
         }
         // Final mix
-        h ^= h >>> 16;
+        h ^= h>>> 16;
         h *= 0x85ebca6b;
-        h ^= h >>> 13;
+        h ^= h>>> 13;
         h *= 0xc2b2ae35;
-        h ^= h >>> 16;
+        h ^= h>>> 16;
         return h;
     }
 
diff --git a/common/src/main/java/org/pragmatica/dht/DHTClient.java b/common/src/main/java/org/pragmatica/dht/DHTClient.java
index 3c6e5a93..5bbce1d0 100644
--- a/common/src/main/java/org/pragmatica/dht/DHTClient.java
+++ b/common/src/main/java/org/pragmatica/dht/DHTClient.java
@@ -17,7 +17,6 @@
  * </ul>
  */
 public interface DHTClient {
-
     /**
      * Get a value by key.
      * Reads from readQuorum nodes and returns the value if found.
@@ -25,12 +24,12 @@ public interface DHTClient {
      * @param key the key to look up
      * @return the value if found, or empty if not present on any replica
      */
-    Promise<Option<byte[]>> get(byte[] key);
+    Promise<Option<byte[] >> get(byte[] key);
 
     /**
      * Get a value by string key.
      */
-    default Promise<Option<byte[]>> get(String key) {
+    default Promise<Option<byte[] >> get(String key) {
         return get(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
     }
 
diff --git a/common/src/main/java/org/pragmatica/dht/DHTConfig.java b/common/src/main/java/org/pragmatica/dht/DHTConfig.java
index 6eb1ff80..ad74f6a5 100644
--- a/common/src/main/java/org/pragmatica/dht/DHTConfig.java
+++ b/common/src/main/java/org/pragmatica/dht/DHTConfig.java
@@ -1,5 +1,4 @@
 package org.pragmatica.dht;
-
 /**
  * Configuration for the distributed hash table.
  *
@@ -9,10 +8,9 @@
  * @param readQuorum        minimum number of successful reads for operation to succeed
  */
 public record DHTConfig(
-    int replicationFactor,
-    int writeQuorum,
-    int readQuorum
-) {
+ int replicationFactor,
+ int writeQuorum,
+ int readQuorum) {
     /**
      * Full replication marker - all nodes store all data.
      */
@@ -81,6 +79,8 @@ public boolean isStronglyConsistent() {
      * For full replication, returns cluster size. Otherwise returns configured value.
      */
     public int effectiveReplicationFactor(int clusterSize) {
-        return isFullReplication() ? clusterSize : Math.min(replicationFactor, clusterSize);
+        return isFullReplication()
+               ? clusterSize
+               : Math.min(replicationFactor, clusterSize);
     }
 }
diff --git a/common/src/main/java/org/pragmatica/dht/DHTMessage.java b/common/src/main/java/org/pragmatica/dht/DHTMessage.java
index 7c9de6f2..8e97de27 100644
--- a/common/src/main/java/org/pragmatica/dht/DHTMessage.java
+++ b/common/src/main/java/org/pragmatica/dht/DHTMessage.java
@@ -7,7 +7,6 @@
  * Messages for DHT operations between nodes.
  */
 public sealed interface DHTMessage extends Message.Wired {
-
     /**
      * Request to get a value.
      */
@@ -16,7 +15,7 @@ record GetRequest(String requestId, byte[] key) implements DHTMessage {}
     /**
      * Response to a get request.
      */
-    record GetResponse(String requestId, Option<byte[]> value) implements DHTMessage {}
+    record GetResponse(String requestId, Option<byte[] > value) implements DHTMessage {}
 
     /**
      * Request to put a value.
diff --git a/common/src/main/java/org/pragmatica/dht/DHTNode.java b/common/src/main/java/org/pragmatica/dht/DHTNode.java
index 6b0facfe..ad04d832 100644
--- a/common/src/main/java/org/pragmatica/dht/DHTNode.java
+++ b/common/src/main/java/org/pragmatica/dht/DHTNode.java
@@ -33,11 +33,10 @@ private DHTNode(N nodeId, StorageEngine storage, ConsistentHashRing<N> ring, DHT
      * @param ring    consistent hash ring for routing
      * @param config  DHT configuration
      */
-    public static <N extends Comparable<N>> DHTNode<N> create(
-            N nodeId,
-            StorageEngine storage,
-            ConsistentHashRing<N> ring,
-            DHTConfig config) {
+    public static <N extends Comparable<N>> DHTNode<N> create(N nodeId,
+                                                              StorageEngine storage,
+                                                              ConsistentHashRing<N> ring,
+                                                              DHTConfig config) {
         return new DHTNode<>(nodeId, storage, ring, config);
     }
 
@@ -65,7 +64,7 @@ public ConsistentHashRing<N> ring() {
     /**
      * Get a value from local storage.
      */
-    public Promise<Option<byte[]>> getLocal(byte[] key) {
+    public Promise<Option<byte[] >> getLocal(byte[] key) {
         return storage.get(key);
     }
 
@@ -101,14 +100,18 @@ public Partition partitionFor(byte[] key) {
      * Check if this node is responsible for a key (as primary or replica).
      */
     public boolean isResponsibleFor(byte[] key) {
-        return ring.nodesFor(key, config.replicationFactor()).contains(nodeId);
+        return ring.nodesFor(key,
+                             config.replicationFactor())
+                   .contains(nodeId);
     }
 
     /**
      * Check if this node is the primary for a key.
      */
     public boolean isPrimaryFor(byte[] key) {
-        return ring.primaryFor(key).map(nodeId::equals).orElse(false);
+        return ring.primaryFor(key)
+                   .map(nodeId::equals)
+                   .orElse(false);
     }
 
     /**
@@ -136,41 +139,47 @@ public Promise<Unit> shutdown() {
      * Handle a get request (for message routing integration).
      */
     public void handleGetRequest(DHTMessage.GetRequest request,
-                                  java.util.function.Consumer<DHTMessage.GetResponse> responseHandler) {
+                                 java.util.function.Consumer<DHTMessage.GetResponse> responseHandler) {
         storage.get(request.key())
-            .onSuccess(value -> responseHandler.accept(
-                new DHTMessage.GetResponse(request.requestId(), value)));
+               .onSuccess(value -> responseHandler.accept(
+        new DHTMessage.GetResponse(request.requestId(),
+                                   value)));
     }
 
     /**
      * Handle a put request (for message routing integration).
      */
     public void handlePutRequest(DHTMessage.PutRequest request,
-                                  java.util.function.Consumer<DHTMessage.PutResponse> responseHandler) {
-        storage.put(request.key(), request.value())
-            .onSuccess(_ -> responseHandler.accept(
-                new DHTMessage.PutResponse(request.requestId(), true)))
-            .onFailure(_ -> responseHandler.accept(
-                new DHTMessage.PutResponse(request.requestId(), false)));
+                                 java.util.function.Consumer<DHTMessage.PutResponse> responseHandler) {
+        storage.put(request.key(),
+                    request.value())
+               .onSuccess(_ -> responseHandler.accept(
+        new DHTMessage.PutResponse(request.requestId(),
+                                   true)))
+               .onFailure(_ -> responseHandler.accept(
+        new DHTMessage.PutResponse(request.requestId(),
+                                   false)));
     }
 
     /**
      * Handle a remove request (for message routing integration).
      */
     public void handleRemoveRequest(DHTMessage.RemoveRequest request,
-                                     java.util.function.Consumer<DHTMessage.RemoveResponse> responseHandler) {
+                                    java.util.function.Consumer<DHTMessage.RemoveResponse> responseHandler) {
         storage.remove(request.key())
-            .onSuccess(found -> responseHandler.accept(
-                new DHTMessage.RemoveResponse(request.requestId(), found)));
+               .onSuccess(found -> responseHandler.accept(
+        new DHTMessage.RemoveResponse(request.requestId(),
+                                      found)));
     }
 
     /**
      * Handle an exists request (for message routing integration).
      */
     public void handleExistsRequest(DHTMessage.ExistsRequest request,
-                                     java.util.function.Consumer<DHTMessage.ExistsResponse> responseHandler) {
+                                    java.util.function.Consumer<DHTMessage.ExistsResponse> responseHandler) {
         storage.exists(request.key())
-            .onSuccess(exists -> responseHandler.accept(
-                new DHTMessage.ExistsResponse(request.requestId(), exists)));
+               .onSuccess(exists -> responseHandler.accept(
+        new DHTMessage.ExistsResponse(request.requestId(),
+                                      exists)));
     }
 }
diff --git a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java b/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
index 86c0447d..d9c866bc 100644
--- a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
+++ b/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
@@ -25,7 +25,7 @@ public static <N extends Comparable<N>> LocalDHTClient<N> create(DHTNode<N> node
     }
 
     @Override
-    public Promise<Option<byte[]>> get(byte[] key) {
+    public Promise<Option<byte[] >> get(byte[] key) {
         return node.getLocal(key);
     }
 
diff --git a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java b/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
index dee044c4..cd4ca72a 100644
--- a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
+++ b/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
@@ -38,14 +38,15 @@ public Promise<List<N>> nodesFor(Partition partition, int replicaCount) {
     @Override
     public Promise<Set<Partition>> partitionsFor(N node) {
         Set<Partition> partitions = new HashSet<>();
-        for (int i = 0; i < Partition.MAX_PARTITIONS; i++) {
+        for (int i = 0; i < Partition.MAX_PARTITIONS; i++ ) {
             Partition partition = Partition.partitionUnsafe(i);
             String partitionKey = "partition:" + i;
-            ring.primaryFor(partitionKey).ifPresent(primary -> {
-                if (primary.equals(node)) {
+            ring.primaryFor(partitionKey)
+                .ifPresent(primary -> {
+                    if (primary.equals(node)) {
                     partitions.add(partition);
                 }
-            });
+                });
         }
         return Promise.success(partitions);
     }
@@ -53,7 +54,7 @@ public Promise<Set<Partition>> partitionsFor(N node) {
     @Override
     public Promise<Set<Partition>> allPartitionsFor(N node, int replicaCount) {
         Set<Partition> partitions = new HashSet<>();
-        for (int i = 0; i < Partition.MAX_PARTITIONS; i++) {
+        for (int i = 0; i < Partition.MAX_PARTITIONS; i++ ) {
             Partition partition = Partition.partitionUnsafe(i);
             String partitionKey = "partition:" + i;
             List<N> nodes = ring.nodesFor(partitionKey, replicaCount);
diff --git a/common/src/main/java/org/pragmatica/dht/Partition.java b/common/src/main/java/org/pragmatica/dht/Partition.java
index f3409da7..baefe222 100644
--- a/common/src/main/java/org/pragmatica/dht/Partition.java
+++ b/common/src/main/java/org/pragmatica/dht/Partition.java
@@ -11,8 +11,7 @@
 public record Partition(int value) implements Comparable<Partition> {
     public static final int MAX_PARTITIONS = 1024;
 
-    private static final Cause INVALID_PARTITION =
-        Causes.cause("Partition must be between 0 and " + (MAX_PARTITIONS - 1));
+    private static final Cause INVALID_PARTITION = Causes.cause("Partition must be between 0 and " + (MAX_PARTITIONS - 1));
 
     public Partition {
         if (value < 0 || value >= MAX_PARTITIONS) {
diff --git a/common/src/main/java/org/pragmatica/dht/PartitionMap.java b/common/src/main/java/org/pragmatica/dht/PartitionMap.java
index 6d343035..06f2fd51 100644
--- a/common/src/main/java/org/pragmatica/dht/PartitionMap.java
+++ b/common/src/main/java/org/pragmatica/dht/PartitionMap.java
@@ -12,7 +12,6 @@
  * @param <N> Node identifier type
  */
 public interface PartitionMap<N> {
-
     /**
      * Get the nodes responsible for a partition.
      * Returns the primary node first, followed by replicas.
@@ -28,7 +27,9 @@ public interface PartitionMap<N> {
      */
     default Promise<N> primaryFor(Partition partition) {
         return nodesFor(partition, 1)
-            .map(nodes -> nodes.isEmpty() ? null : nodes.getFirst());
+               .map(nodes -> nodes.isEmpty()
+                             ? null
+                             : nodes.getFirst());
     }
 
     /**
diff --git a/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java b/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
index 36b325ee..c1978646 100644
--- a/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
+++ b/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
@@ -13,7 +13,7 @@
  * Data is not persisted across restarts.
  */
 public final class MemoryStorageEngine implements StorageEngine {
-    private final ConcurrentHashMap<ByteArrayKey, byte[]> data = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<ByteArrayKey, byte[] > data = new ConcurrentHashMap<>();
 
     private MemoryStorageEngine() {}
 
@@ -22,9 +22,11 @@ public static MemoryStorageEngine create() {
     }
 
     @Override
-    public Promise<Option<byte[]>> get(byte[] key) {
+    public Promise<Option<byte[] >> get(byte[] key) {
         byte[] value = data.get(new ByteArrayKey(key));
-        return Promise.success(value != null ? Option.some(value.clone()) : Option.none());
+        return Promise.success(value != null
+                               ? Option.some(value.clone())
+                               : Option.none());
     }
 
     @Override
@@ -68,7 +70,7 @@ private record ByteArrayKey(byte[] data) {
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
-            if (!(o instanceof ByteArrayKey that)) return false;
+            if (! (o instanceof ByteArrayKey that)) return false;
             return Arrays.equals(data, that.data);
         }
 
diff --git a/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java b/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
index 969c7d88..ecca4b20 100644
--- a/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
+++ b/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
@@ -9,14 +9,13 @@
  * Implementations may use in-memory storage, off-heap memory, or persistent storage.
  */
 public interface StorageEngine {
-
     /**
      * Get a value by key.
      *
      * @param key the key to look up
      * @return the value if present, or empty option
      */
-    Promise<Option<byte[]>> get(byte[] key);
+    Promise<Option<byte[] >> get(byte[] key);
 
     /**
      * Store a value.
diff --git a/common/src/main/java/org/pragmatica/message/Message.java b/common/src/main/java/org/pragmatica/message/Message.java
index ffbbb897..58cd987f 100644
--- a/common/src/main/java/org/pragmatica/message/Message.java
+++ b/common/src/main/java/org/pragmatica/message/Message.java
@@ -1,10 +1,7 @@
 package org.pragmatica.message;
-
 /// Marker interface for all messages circulating inside the system
 public sealed interface Message {
-    non-sealed interface Local extends Message {
-    }
+    non-sealed interface Local extends Message {}
 
-    non-sealed interface Wired extends Message {
-    }
+    non-sealed interface Wired extends Message {}
 }
diff --git a/common/src/main/java/org/pragmatica/message/MessageReceiver.java b/common/src/main/java/org/pragmatica/message/MessageReceiver.java
index 778abf20..303ae11b 100644
--- a/common/src/main/java/org/pragmatica/message/MessageReceiver.java
+++ b/common/src/main/java/org/pragmatica/message/MessageReceiver.java
@@ -8,5 +8,4 @@
 @Retention(RetentionPolicy.SOURCE)
 @Target(ElementType.METHOD)
 @Inherited
-public @interface MessageReceiver {
-}
+public @interface MessageReceiver {}
diff --git a/common/src/main/java/org/pragmatica/message/MessageRouter.java b/common/src/main/java/org/pragmatica/message/MessageRouter.java
index 8a05e206..cb3de096 100644
--- a/common/src/main/java/org/pragmatica/message/MessageRouter.java
+++ b/common/src/main/java/org/pragmatica/message/MessageRouter.java
@@ -5,8 +5,6 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Tuple.Tuple2;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -17,6 +15,9 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.lang.Tuple.tuple;
 
 /// **NOTE**: This implementation assumes that the instance is configured and then used without
@@ -33,28 +34,28 @@ static MutableRouter mutable() {
     }
 
     sealed interface MutableRouter extends MessageRouter {
-        <T extends Message> MessageRouter addRoute(Class<? extends T> messageType, Consumer<? extends T> receiver);
+        <T extends Message> MessageRouter addRoute(Class< ? extends T> messageType, Consumer< ? extends T> receiver);
 
         record SimpleMutableRouter<T extends Message>(
-                ConcurrentMap<Class<T>, List<Consumer<T>>> routingTable) implements
-                                                                         MutableRouter {
-
+        ConcurrentMap<Class<T>, List<Consumer<T>>> routingTable) implements MutableRouter {
             private static final Logger log = LoggerFactory.getLogger(MessageRouter.class);
 
             @Override
             public <R extends Message> void route(R message) {
                 Option.option(routingTable.get(message.getClass()))
                       .onPresent(list -> list.forEach(fn -> fn.accept((T) message)))
-                      .onEmpty(() -> log.warn("No route for message type: {}", message.getClass().getSimpleName()));
+                      .onEmpty(() -> log.warn("No route for message type: {}",
+                                              message.getClass()
+                                                     .getSimpleName()));
             }
 
             @SuppressWarnings("unchecked")
             @Override
-            public <R extends Message> MessageRouter addRoute(Class<? extends R> messageType,
-                                                              Consumer<? extends R> receiver) {
-                routingTable.computeIfAbsent((Class<T>) messageType, _ -> new CopyOnWriteArrayList<>())
+            public <R extends Message> MessageRouter addRoute(Class< ? extends R> messageType,
+                                                              Consumer< ? extends R> receiver) {
+                routingTable.computeIfAbsent((Class<T>) messageType,
+                                             _ -> new CopyOnWriteArrayList<>())
                             .add((Consumer<T>) receiver);
-
                 return this;
             }
         }
@@ -65,41 +66,39 @@ non-sealed interface ImmutableRouter<T extends Message> extends MessageRouter {
 
         @SuppressWarnings("unchecked")
         default <R extends Message> void route(R message) {
-            routingTable().get(message.getClass()).forEach(fn -> fn.accept((T) message));
+            routingTable()
+            .get(message.getClass())
+            .forEach(fn -> fn.accept((T) message));
         }
     }
 
     interface Entry<T extends Message> {
-        Stream<Tuple2<Class<? extends T>, Consumer<? extends T>>> entries();
+        Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries();
 
         Class<T> type();
 
-        Set<Class<?>> validate();
+        Set<Class< ? >> validate();
 
         @SuppressWarnings("unchecked")
         default Result<MessageRouter> asRouter() {
             var validated = validate();
-
             if (!validated.isEmpty()) {
                 var missing = validated.stream()
                                        .map(Class::getSimpleName)
                                        .collect(Collectors.joining(", "));
                 return new InvalidMessageRouterConfiguration("Missing message types: " + missing).result();
             }
-
-            record router<T extends Message>(
-                    Map<Class<T>, List<Consumer<T>>> routingTable) implements ImmutableRouter<T> {}
-
+            record router <T extends Message>(
+            Map<Class<T>, List<Consumer<T>>> routingTable) implements ImmutableRouter<T> {}
             var routingTable = new HashMap<Class<T>, List<Consumer<T>>>();
-
-            entries().forEach(tuple -> routingTable.compute((Class<T>) tuple.first(),
-                                                            (_, oldValue) -> merge(tuple, oldValue)));
-
-            return Result.success(new router<>(routingTable));
+            entries()
+            .forEach(tuple -> routingTable.compute((Class<T>) tuple.first(),
+                                                   (_, oldValue) -> merge(tuple, oldValue)));
+            return Result.success(new router <>(routingTable));
         }
 
         @SuppressWarnings("unchecked")
-        private static <T extends Message> List<Consumer<T>> merge(Tuple2<Class<? extends T>, Consumer<? extends T>> tuple,
+        private static <T extends Message> List<Consumer<T>> merge(Tuple2<Class< ? extends T>, Consumer< ? extends T>> tuple,
                                                                    List<Consumer<T>> oldValue) {
             var list = oldValue == null
                        ? new ArrayList<Consumer<T>>()
@@ -110,11 +109,11 @@ private static <T extends Message> List<Consumer<T>> merge(Tuple2<Class<? extend
 
         interface SealedBuilder<T extends Message> extends Entry<T> {
             static <T extends Message> SealedBuilder<T> from(Class<T> clazz) {
-                record sealedBuilder<T extends Message>(Class<T> type,
-                                                        List<Entry<? extends T>> routes) implements SealedBuilder<T> {
+                record sealedBuilder <T extends Message>(Class<T> type,
+                                                         List<Entry< ? extends T>> routes) implements SealedBuilder<T> {
                     @SuppressWarnings("unchecked")
                     @Override
-                    public Stream<Tuple2<Class<? extends T>, Consumer<? extends T>>> entries() {
+                    public Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries() {
                         return routes.stream()
                                      .map(entry -> (Entry<T>) entry)
                                      .flatMap(Entry::entries);
@@ -123,34 +122,34 @@ public Stream<Tuple2<Class<? extends T>, Consumer<? extends T>>> entries() {
                     @SafeVarargs
                     @Override
                     public final Entry<T> route(Entry<? extends T>... routes) {
-                        routes().addAll(List.of(routes));
-
+                        routes()
+                        .addAll(List.of(routes));
                         return this;
                     }
 
                     @Override
-                    public Set<Class<?>> validate() {
-                        if (!type().isSealed()) {
+                    public Set<Class< ? >> validate() {
+                        if (!type()
+                             .isSealed()) {
                             return mergeSubroutes(new HashSet<>());
                         }
-
-                        var declared = routes().stream()
-                                               .map(Entry::type)
-                                               .collect(Collectors.toSet());
-                        var permitted = new HashSet<>(Set.of(type().getPermittedSubclasses()));
-
+                        var declared = routes()
+                                       .stream()
+                                       .map(Entry::type)
+                                       .collect(Collectors.toSet());
+                        var permitted = new HashSet<>(Set.of(type()
+                                                             .getPermittedSubclasses()));
                         permitted.removeAll(declared);
-
                         return mergeSubroutes(permitted);
                     }
 
-                    private Set<Class<?>> mergeSubroutes(Set<Class<?>> local) {
-                        routes().forEach(route -> local.addAll(route.validate()));
+                    private Set<Class< ? >> mergeSubroutes(Set<Class< ? >> local) {
+                        routes()
+                        .forEach(route -> local.addAll(route.validate()));
                         return local;
                     }
                 }
-
-                return new sealedBuilder<>(clazz, new ArrayList<>());
+                return new sealedBuilder <>(clazz, new ArrayList<>());
             }
 
             @SuppressWarnings("unchecked")
@@ -158,20 +157,18 @@ private Set<Class<?>> mergeSubroutes(Set<Class<?>> local) {
         }
 
         static <T extends Message> Entry<T> route(Class<T> type, Consumer<T> receiver) {
-            record entry<T extends Message>(Class<T> type, Consumer<T> receiver) implements Entry<T> {
-
+            record entry <T extends Message>(Class<T> type, Consumer<T> receiver) implements Entry<T> {
                 @Override
-                public Stream<Tuple2<Class<? extends T>, Consumer<? extends T>>> entries() {
+                public Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries() {
                     return Stream.of(tuple(type(), receiver()));
                 }
 
                 @Override
-                public Set<Class<?>> validate() {
-                    return Set.of(); // Route is always valid
+                public Set<Class< ? >> validate() {
+                    return Set.of();
                 }
             }
-
-            return new entry<>(type, receiver);
+            return new entry <>(type, receiver);
         }
     }
 
diff --git a/common/src/main/java/org/pragmatica/message/RouterConfigurator.java b/common/src/main/java/org/pragmatica/message/RouterConfigurator.java
index 3dd7f231..1d3f1233 100644
--- a/common/src/main/java/org/pragmatica/message/RouterConfigurator.java
+++ b/common/src/main/java/org/pragmatica/message/RouterConfigurator.java
@@ -1,5 +1,4 @@
 package org.pragmatica.message;
-
 public interface RouterConfigurator {
     void configure(MessageRouter router);
 }
diff --git a/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java b/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
index b532896a..a97e28b1 100644
--- a/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
+++ b/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
@@ -8,80 +8,69 @@
 
 public sealed interface HierarchyScanner {
     @SuppressWarnings("unchecked")
-    static <T> Set<Class<? extends T>> concreteSubtypes(Class<T> type) {
-        var result = new HashSet<Class<? extends T>>();
-
+    static <T> Set<Class< ? extends T>> concreteSubtypes(Class<T> type) {
+        var result = new HashSet<Class< ? extends T>>();
         if (!type.isInterface()) {
             result.add(type);
             return result;
         }
-
-        var queue = new LinkedBlockingQueue<Class<?>>();
+        var queue = new LinkedBlockingQueue<Class< ? >>();
         queue.offer(type);
-
         while (!queue.isEmpty()) {
             var currentInterface = queue.poll();
-
             if (!currentInterface.isSealed()) {
                 continue;
             }
-
             for (var clazz : currentInterface.getPermittedSubclasses()) {
                 if (clazz.isInterface()) {
                     queue.offer(clazz);
-                } else {
-                    result.add((Class<? extends T>) clazz);
+                }else {
+                    result.add((Class< ? extends T>) clazz);
                 }
             }
         }
         return result;
     }
 
-    static <T> Set<Class<? extends T>> walkUpTheTree(Collection<Class<? extends T>> classes) {
-        var interfaces = new HashSet<Class<?>>();
-        var collected = new HashSet<Class<? extends T>>();
-
+    static <T> Set<Class< ? extends T>> walkUpTheTree(Collection<Class< ? extends T>> classes) {
+        var interfaces = new HashSet<Class< ? >>();
+        var collected = new HashSet<Class< ? extends T>>();
         for (var clazz : classes) {
             scanSingle(clazz, collected, interfaces);
         }
-
         return collected;
     }
 
     @SuppressWarnings("unchecked")
-    private static <T> void scanSingle(Class<? extends T> clazz,
-                                       Set<Class<? extends T>> result,
-                                       Set<Class<?>> interfaces) {
-        var queue = new LinkedBlockingQueue<Class<?>>();
-
+    private static <T> void scanSingle(Class< ? extends T> clazz,
+                                       Set<Class< ? extends T>> result,
+                                       Set<Class< ? >> interfaces) {
+        var queue = new LinkedBlockingQueue<Class< ? >>();
         if (clazz.isInterface()) {
             if (interfaces.add(clazz)) {
                 queue.offer(clazz);
             }
-        } else {
+        }else {
             result.add(clazz);
             Stream.of(clazz.getInterfaces())
                   .forEach(e -> {
                       if (interfaces.add(e)) {
-                          queue.offer(e);
-                      }
+                      queue.offer(e);
+                  }
                   });
         }
-
         while (!queue.isEmpty()) {
-            Class<?> type = queue.poll();
-
+            Class< ? > type = queue.poll();
             Stream.of(clazz.getInterfaces())
                   .forEach(e -> {
                       if (interfaces.add(e)) {
-                          queue.offer(e);
-                      }
+                      queue.offer(e);
+                  }
                   });
-
             concreteSubtypes(type)
-                    .stream()
-                    .map(cls -> (Class<? extends T>) cls)
-                    .forEach(result::add);
+            .stream()
+            .map(cls -> (Class< ? extends T>) cls)
+            .forEach(result::add);
         }
     }
 
diff --git a/common/src/main/java/org/pragmatica/utility/IdGenerator.java b/common/src/main/java/org/pragmatica/utility/IdGenerator.java
index b76ec2aa..45463894 100644
--- a/common/src/main/java/org/pragmatica/utility/IdGenerator.java
+++ b/common/src/main/java/org/pragmatica/utility/IdGenerator.java
@@ -3,9 +3,10 @@
 import java.util.Locale;
 
 public sealed interface IdGenerator {
-
     static String generate(String prefix) {
-        return prefix + "_" + ULID.randomULID().encoded().toLowerCase(Locale.ROOT);
+        return prefix + "_" + ULID.randomULID()
+                                 .encoded()
+                                 .toLowerCase(Locale.ROOT);
     }
 
     @SuppressWarnings("unused")
diff --git a/common/src/main/java/org/pragmatica/utility/Sleep.java b/common/src/main/java/org/pragmatica/utility/Sleep.java
index 5bcac835..79cde753 100644
--- a/common/src/main/java/org/pragmatica/utility/Sleep.java
+++ b/common/src/main/java/org/pragmatica/utility/Sleep.java
@@ -4,10 +4,11 @@
 
 public sealed interface Sleep {
     static void sleep(TimeSpan span) {
-        try {
+        try{
             Thread.sleep(span.millis());
         } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
diff --git a/common/src/main/java/org/pragmatica/utility/ULID.java b/common/src/main/java/org/pragmatica/utility/ULID.java
index 8b1189db..d9b3d2cb 100644
--- a/common/src/main/java/org/pragmatica/utility/ULID.java
+++ b/common/src/main/java/org/pragmatica/utility/ULID.java
@@ -47,78 +47,75 @@ public final class ULID implements Comparable<ULID> {
     private static final long OFFSET = System.currentTimeMillis() * 1000_000;
 
     // Base32 characters mapping
-    private static final char[] C = new char[]{
-            0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37,
-            0X38, 0X39, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46,
-            0X47, 0X48, 0X4A, 0X4B, 0X4D, 0X4E, 0X50, 0X51,
-            0X52, 0X53, 0X54, 0X56, 0X57, 0X58, 0X59, 0X5A};
-
-    private static final byte[] V = new byte[]{
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0X00, (byte) 0X01, (byte) 0X02, (byte) 0X03,
-            (byte) 0X04, (byte) 0X05, (byte) 0X06, (byte) 0X07,
-            (byte) 0X08, (byte) 0X09, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
-            (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
-            (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
-            (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
-            (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
-            (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
-            (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
-            (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
-            (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
-            (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
-            (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
-            (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
-            (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-            (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF
-    };
+    private static final char[] C = new char[]{0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37,
+    0X38, 0X39, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46,
+    0X47, 0X48, 0X4A, 0X4B, 0X4D, 0X4E, 0X50, 0X51,
+    0X52, 0X53, 0X54, 0X56, 0X57, 0X58, 0X59, 0X5A};
+
+    private static final byte[] V = new byte[]{(byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0X00, (byte) 0X01, (byte) 0X02, (byte) 0X03,
+    (byte) 0X04, (byte) 0X05, (byte) 0X06, (byte) 0X07,
+    (byte) 0X08, (byte) 0X09, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
+    (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
+    (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
+    (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
+    (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
+    (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
+    (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
+    (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
+    (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
+    (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
+    (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
+    (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
+    (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
+    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF};
 
     private final String representation;
     private final long timestamp;
@@ -138,43 +135,39 @@ private ULID(final String representation, final long timestamp, final byte[] ent
     public static ULID randomULID() {
         final var entropy = new byte[10];
         SECURE.nextBytes(entropy);
-
         return generate(System.nanoTime() + OFFSET, entropy);
     }
 
     private static ULID generate(final long timestamp, final byte[] entropy) {
         final var chars = new char[ULID_LENGTH];
-
         // time
-        chars[0] = C[(byte) (timestamp >>> 45) & 0x1F];
-        chars[1] = C[(byte) (timestamp >>> 40) & 0x1F];
-        chars[2] = C[(byte) (timestamp >>> 35) & 0x1F];
-        chars[3] = C[(byte) (timestamp >>> 30) & 0x1F];
-        chars[4] = C[(byte) (timestamp >>> 25) & 0x1F];
-        chars[5] = C[(byte) (timestamp >>> 20) & 0x1F];
-        chars[6] = C[(byte) (timestamp >>> 15) & 0x1F];
-        chars[7] = C[(byte) (timestamp >>> 10) & 0x1F];
-        chars[8] = C[(byte) (timestamp >>> 5) & 0x1F];
-        chars[9] = C[((byte) (timestamp)) & 0x1F];
-
+        chars[0] = C[(byte)(timestamp>>> 45) & 0x1F];
+        chars[1] = C[(byte)(timestamp>>> 40) & 0x1F];
+        chars[2] = C[(byte)(timestamp>>> 35) & 0x1F];
+        chars[3] = C[(byte)(timestamp>>> 30) & 0x1F];
+        chars[4] = C[(byte)(timestamp>>> 25) & 0x1F];
+        chars[5] = C[(byte)(timestamp>>> 20) & 0x1F];
+        chars[6] = C[(byte)(timestamp>>> 15) & 0x1F];
+        chars[7] = C[(byte)(timestamp>>> 10) & 0x1F];
+        chars[8] = C[(byte)(timestamp>>> 5) & 0x1F];
+        chars[9] = C[((byte)(timestamp)) & 0x1F];
         // entropy
-        chars[10] = C[(byte) ((entropy[0] & 0xFF) >>> 3)];
-        chars[11] = C[(byte) ((entropy[0] << 2 | ((entropy[1] & 0xFF) >>> 6)) & 0x1F)];
-        chars[12] = C[(byte) ((entropy[1] & 0xFF) >>> 1 & 0x1F)];
-        chars[13] = C[(byte) ((entropy[1] << 4 | ((entropy[2] & 0xFF) >>> 4)) & 0x1F)];
-        chars[14] = C[(byte) ((entropy[2] << 5 | ((entropy[3] & 0xFF) >>> 7)) & 0x1F)];
-        chars[15] = C[(byte) ((entropy[3] & 0xFF) >>> 2 & 0x1F)];
-        chars[16] = C[(byte) ((entropy[3] << 3 | ((entropy[4] & 0xFF) >>> 5)) & 0x1F)];
-        chars[17] = C[(byte) (entropy[4] & 0x1F)];
-        chars[18] = C[(byte) ((entropy[5] & 0xFF) >>> 3)];
-        chars[19] = C[(byte) ((entropy[5] << 2 | ((entropy[6] & 0xFF) >>> 6)) & 0x1F)];
-        chars[20] = C[(byte) ((entropy[6] & 0xFF) >>> 1 & 0x1F)];
-        chars[21] = C[(byte) ((entropy[6] << 4 | ((entropy[7] & 0xFF) >>> 4)) & 0x1F)];
-        chars[22] = C[(byte) ((entropy[7] << 5 | ((entropy[8] & 0xFF) >>> 7)) & 0x1F)];
-        chars[23] = C[(byte) ((entropy[8] & 0xFF) >>> 2 & 0x1F)];
-        chars[24] = C[(byte) ((entropy[8] << 3 | ((entropy[9] & 0xFF) >>> 5)) & 0x1F)];
-        chars[25] = C[(byte) (entropy[9] & 0x1F)];
-
+        chars[10] = C[(byte)((entropy[0] & 0xFF)>>> 3)];
+        chars[11] = C[(byte)((entropy[0]<< 2 | ((entropy[1] & 0xFF)>>> 6)) & 0x1F)];
+        chars[12] = C[(byte)((entropy[1] & 0xFF)>>> 1 & 0x1F)];
+        chars[13] = C[(byte)((entropy[1]<< 4 | ((entropy[2] & 0xFF)>>> 4)) & 0x1F)];
+        chars[14] = C[(byte)((entropy[2]<< 5 | ((entropy[3] & 0xFF)>>> 7)) & 0x1F)];
+        chars[15] = C[(byte)((entropy[3] & 0xFF)>>> 2 & 0x1F)];
+        chars[16] = C[(byte)((entropy[3]<< 3 | ((entropy[4] & 0xFF)>>> 5)) & 0x1F)];
+        chars[17] = C[(byte)(entropy[4] & 0x1F)];
+        chars[18] = C[(byte)((entropy[5] & 0xFF)>>> 3)];
+        chars[19] = C[(byte)((entropy[5]<< 2 | ((entropy[6] & 0xFF)>>> 6)) & 0x1F)];
+        chars[20] = C[(byte)((entropy[6] & 0xFF)>>> 1 & 0x1F)];
+        chars[21] = C[(byte)((entropy[6]<< 4 | ((entropy[7] & 0xFF)>>> 4)) & 0x1F)];
+        chars[22] = C[(byte)((entropy[7]<< 5 | ((entropy[8] & 0xFF)>>> 7)) & 0x1F)];
+        chars[23] = C[(byte)((entropy[8] & 0xFF)>>> 2 & 0x1F)];
+        chars[24] = C[(byte)((entropy[8]<< 3 | ((entropy[9] & 0xFF)>>> 5)) & 0x1F)];
+        chars[25] = C[(byte)(entropy[9] & 0x1F)];
         return new ULID(new String(chars), timestamp, entropy);
     }
 
diff --git a/example-slice/src/main/java/org/pragmatica/aether/example/StringProcessorSlice.java b/example-slice/src/main/java/org/pragmatica/aether/example/StringProcessorSlice.java
index bc90edf0..22e57082 100644
--- a/example-slice/src/main/java/org/pragmatica/aether/example/StringProcessorSlice.java
+++ b/example-slice/src/main/java/org/pragmatica/aether/example/StringProcessorSlice.java
@@ -13,9 +13,8 @@
  * which return successfully resolved Promise instances.
  */
 public record StringProcessorSlice() implements Slice {
-
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of();
     }
-}
\ No newline at end of file
+}
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/ForgeApiHandler.java b/forge/src/main/java/org/pragmatica/aether/forge/ForgeApiHandler.java
index c74f86f7..cf0a6301 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/ForgeApiHandler.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/ForgeApiHandler.java
@@ -1,11 +1,5 @@
 package org.pragmatica.aether.forge;
 
-import io.netty.buffer.Unpooled;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandler.Sharable;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.handler.codec.http.*;
 import org.pragmatica.aether.forge.ForgeCluster.ClusterStatus;
 import org.pragmatica.aether.forge.ForgeMetrics.MetricsSnapshot;
 import org.pragmatica.aether.forge.simulator.BackendSimulation;
@@ -15,8 +9,7 @@
 import org.pragmatica.aether.forge.simulator.SimulatorMode;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
+import org.pragmatica.aether.forge.simulator.DataGenerator;
 
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
@@ -27,7 +20,14 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentLinkedDeque;
 
-import org.pragmatica.aether.forge.simulator.DataGenerator;
+import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler.Sharable;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.handler.codec.http.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import static io.netty.handler.codec.http.HttpResponseStatus.*;
 import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
@@ -58,7 +58,10 @@ public final class ForgeApiHandler extends SimpleChannelInboundHandler<FullHttpR
     private volatile long simulatedReleases = 0;
     private volatile long simulatedStockOuts = 0;
 
-    private ForgeApiHandler(ForgeCluster cluster, LoadGenerator loadGenerator, ForgeMetrics metrics, LocalSliceInvoker sliceInvoker) {
+    private ForgeApiHandler(ForgeCluster cluster,
+                            LoadGenerator loadGenerator,
+                            ForgeMetrics metrics,
+                            LocalSliceInvoker sliceInvoker) {
         this.cluster = cluster;
         this.loadGenerator = loadGenerator;
         this.metrics = metrics;
@@ -66,7 +69,10 @@ private ForgeApiHandler(ForgeCluster cluster, LoadGenerator loadGenerator, Forge
         this.chaosController = ChaosController.chaosController(this::executeChaosEvent);
     }
 
-    public static ForgeApiHandler forgeApiHandler(ForgeCluster cluster, LoadGenerator loadGenerator, ForgeMetrics metrics, LocalSliceInvoker sliceInvoker) {
+    public static ForgeApiHandler forgeApiHandler(ForgeCluster cluster,
+                                                  LoadGenerator loadGenerator,
+                                                  ForgeMetrics metrics,
+                                                  LocalSliceInvoker sliceInvoker) {
         return new ForgeApiHandler(cluster, loadGenerator, metrics, sliceInvoker);
     }
 
@@ -80,16 +86,14 @@ private void executeChaosEvent(ChaosEvent event) {
                 cluster.crashNode(kill.nodeId());
             }
             case ChaosEvent.LatencySpike spike -> {
-                addEvent("CHAOS", "Adding " + spike.latencyMs() + "ms latency to " + spike.nodeId());
-                // Latency injection would be implemented via BackendSimulation config update
+                addEvent("CHAOS",
+                         "Adding " + spike.latencyMs() + "ms latency to " + spike.nodeId());
             }
             case ChaosEvent.SliceCrash crash -> {
                 addEvent("CHAOS", "Crashing slice " + crash.sliceArtifact());
-                // Slice crash would trigger slice deactivation
             }
             case ChaosEvent.InvocationFailure failure -> {
                 addEvent("CHAOS", "Injecting " + (int)(failure.failureRate() * 100) + "% failure rate");
-                // Would update simulation config
             }
             default -> addEvent("CHAOS", "Executing: " + event.description());
         }
@@ -103,85 +107,95 @@ public int sliceCount() {
     protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
         var path = request.uri();
         var method = request.method();
-
         log.debug("API request: {} {}", method, path);
-
-        try {
+        try{
             if (path.equals("/api/status") && method == HttpMethod.GET) {
                 handleStatus(ctx);
-            } else if (path.equals("/api/add-node") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/add-node") && method == HttpMethod.POST) {
                 handleAddNode(ctx);
-            } else if (path.startsWith("/api/kill/") && method == HttpMethod.POST) {
-                handleKillNode(ctx, path.substring("/api/kill/".length()));
-            } else if (path.startsWith("/api/crash/") && method == HttpMethod.POST) {
-                handleCrashNode(ctx, path.substring("/api/crash/".length()));
-            } else if (path.equals("/api/rolling-restart") && method == HttpMethod.POST) {
+            }else if (path.startsWith("/api/kill/") && method == HttpMethod.POST) {
+                handleKillNode(ctx,
+                               path.substring("/api/kill/".length()));
+            }else if (path.startsWith("/api/crash/") && method == HttpMethod.POST) {
+                handleCrashNode(ctx,
+                                path.substring("/api/crash/".length()));
+            }else if (path.equals("/api/rolling-restart") && method == HttpMethod.POST) {
                 handleRollingRestart(ctx);
-            } else if (path.startsWith("/api/load/set/") && method == HttpMethod.POST) {
-                handleSetLoad(ctx, path.substring("/api/load/set/".length()));
-            } else if (path.equals("/api/load/ramp") && method == HttpMethod.POST) {
+            }else if (path.startsWith("/api/load/set/") && method == HttpMethod.POST) {
+                handleSetLoad(ctx,
+                              path.substring("/api/load/set/".length()));
+            }else if (path.equals("/api/load/ramp") && method == HttpMethod.POST) {
                 handleRampLoad(ctx, request);
-            } else if (path.equals("/api/events") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/events") && method == HttpMethod.GET) {
                 handleEvents(ctx);
-            } else if (path.equals("/api/reset-metrics") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/reset-metrics") && method == HttpMethod.POST) {
                 handleResetMetrics(ctx);
-            } else if (path.equals("/api/node-metrics") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/node-metrics") && method == HttpMethod.GET) {
                 handleNodeMetrics(ctx);
-            } else if (path.equals("/api/orders") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/orders") && method == HttpMethod.POST) {
                 handlePlaceOrder(ctx, request);
-            } else if (path.startsWith("/api/orders/") && method == HttpMethod.GET) {
-                handleGetOrderStatus(ctx, path.substring("/api/orders/".length()));
-            } else if (path.startsWith("/api/orders/") && method == HttpMethod.DELETE) {
-                handleCancelOrder(ctx, path.substring("/api/orders/".length()), request);
-            } else if (path.startsWith("/api/inventory/") && method == HttpMethod.GET) {
-                handleCheckStock(ctx, path.substring("/api/inventory/".length()));
-            } else if (path.startsWith("/api/pricing/") && method == HttpMethod.GET) {
-                handleGetPrice(ctx, path.substring("/api/pricing/".length()));
-            } else if (path.equals("/api/simulator/metrics") && method == HttpMethod.GET) {
+            }else if (path.startsWith("/api/orders/") && method == HttpMethod.GET) {
+                handleGetOrderStatus(ctx,
+                                     path.substring("/api/orders/".length()));
+            }else if (path.startsWith("/api/orders/") && method == HttpMethod.DELETE) {
+                handleCancelOrder(ctx,
+                                  path.substring("/api/orders/".length()),
+                                  request);
+            }else if (path.startsWith("/api/inventory/") && method == HttpMethod.GET) {
+                handleCheckStock(ctx,
+                                 path.substring("/api/inventory/".length()));
+            }else if (path.startsWith("/api/pricing/") && method == HttpMethod.GET) {
+                handleGetPrice(ctx,
+                               path.substring("/api/pricing/".length()));
+            }else if (path.equals("/api/simulator/metrics") && method == HttpMethod.GET) {
                 handleSimulatorMetrics(ctx);
-            } else if (path.startsWith("/api/simulator/rate/") && method == HttpMethod.POST) {
-                handleSimulatorRate(ctx, path.substring("/api/simulator/rate/".length()), request);
-            } else if (path.equals("/api/simulator/entrypoints") && method == HttpMethod.GET) {
+            }else if (path.startsWith("/api/simulator/rate/") && method == HttpMethod.POST) {
+                handleSimulatorRate(ctx,
+                                    path.substring("/api/simulator/rate/".length()),
+                                    request);
+            }else if (path.equals("/api/simulator/entrypoints") && method == HttpMethod.GET) {
                 handleSimulatorEntryPoints(ctx);
-            } else if (path.equals("/api/simulator/config") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/simulator/config") && method == HttpMethod.GET) {
                 handleGetConfig(ctx);
-            } else if (path.equals("/api/simulator/config") && method == HttpMethod.PUT) {
+            }else if (path.equals("/api/simulator/config") && method == HttpMethod.PUT) {
                 handlePutConfig(ctx, request);
-            } else if (path.equals("/api/simulator/config/multiplier") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/simulator/config/multiplier") && method == HttpMethod.POST) {
                 handleSetMultiplier(ctx, request);
-            } else if (path.equals("/api/simulator/config/enabled") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/simulator/config/enabled") && method == HttpMethod.POST) {
                 handleSetEnabled(ctx, request);
-            } else if (path.equals("/api/inventory/mode") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/inventory/mode") && method == HttpMethod.GET) {
                 handleGetInventoryMode(ctx);
-            } else if (path.equals("/api/inventory/mode") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/inventory/mode") && method == HttpMethod.POST) {
                 handleSetInventoryMode(ctx, request);
-            } else if (path.equals("/api/inventory/metrics") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/inventory/metrics") && method == HttpMethod.GET) {
                 handleInventoryMetrics(ctx);
-            } else if (path.equals("/api/inventory/stock") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/inventory/stock") && method == HttpMethod.GET) {
                 handleInventoryStock(ctx);
-            } else if (path.equals("/api/inventory/reset") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/inventory/reset") && method == HttpMethod.POST) {
                 handleInventoryReset(ctx);
-            } else if (path.equals("/api/chaos/status") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/chaos/status") && method == HttpMethod.GET) {
                 handleChaosStatus(ctx);
-            } else if (path.equals("/api/chaos/enable") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/chaos/enable") && method == HttpMethod.POST) {
                 handleChaosEnable(ctx, request);
-            } else if (path.equals("/api/chaos/inject") && method == HttpMethod.POST) {
+            }else if (path.equals("/api/chaos/inject") && method == HttpMethod.POST) {
                 handleChaosInject(ctx, request);
-            } else if (path.startsWith("/api/chaos/stop/") && method == HttpMethod.POST) {
-                handleChaosStop(ctx, path.substring("/api/chaos/stop/".length()));
-            } else if (path.equals("/api/chaos/stop-all") && method == HttpMethod.POST) {
+            }else if (path.startsWith("/api/chaos/stop/") && method == HttpMethod.POST) {
+                handleChaosStop(ctx,
+                                path.substring("/api/chaos/stop/".length()));
+            }else if (path.equals("/api/chaos/stop-all") && method == HttpMethod.POST) {
                 handleChaosStopAll(ctx);
-            } else if (path.equals("/api/simulator/mode") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/simulator/mode") && method == HttpMethod.GET) {
                 handleGetMode(ctx);
-            } else if (path.equals("/api/simulator/modes") && method == HttpMethod.GET) {
+            }else if (path.equals("/api/simulator/modes") && method == HttpMethod.GET) {
                 handleGetModes(ctx);
-            } else if (path.startsWith("/api/simulator/mode/") && method == HttpMethod.PUT) {
-                handleSetMode(ctx, path.substring("/api/simulator/mode/".length()));
-            } else if (path.startsWith("/repository/") && method == HttpMethod.GET) {
+            }else if (path.startsWith("/api/simulator/mode/") && method == HttpMethod.PUT) {
+                handleSetMode(ctx,
+                              path.substring("/api/simulator/mode/".length()));
+            }else if (path.startsWith("/repository/") && method == HttpMethod.GET) {
                 handleRepositoryGet(ctx, path);
-            } else if (path.startsWith("/repository/") && (method == HttpMethod.PUT || method == HttpMethod.POST)) {
+            }else if (path.startsWith("/repository/") && (method == HttpMethod.PUT || method == HttpMethod.POST)) {
                 handleRepositoryPut(ctx, path, request);
-            } else {
+            }else {
                 sendResponse(ctx, NOT_FOUND, "{\"error\": \"Not found\"}");
             }
         } catch (Exception e) {
@@ -194,79 +208,102 @@ private void handleStatus(ChannelHandlerContext ctx) {
         var clusterStatus = cluster.status();
         var metricsSnapshot = metrics.currentMetrics();
         var loadStatus = new LoadStatus(
-                loadGenerator.currentRate(),
-                loadGenerator.targetRate(),
-                loadGenerator.isRunning()
-        );
-
-        var response = new StatusResponse(clusterStatus, metricsSnapshot, loadStatus, uptimeSeconds(), sliceInvoker.sliceCount());
+        loadGenerator.currentRate(), loadGenerator.targetRate(), loadGenerator.isRunning());
+        var response = new StatusResponse(clusterStatus,
+                                          metricsSnapshot,
+                                          loadStatus,
+                                          uptimeSeconds(),
+                                          sliceInvoker.sliceCount());
         sendResponse(ctx, OK, toJson(response));
     }
 
     private void handleAddNode(ChannelHandlerContext ctx) {
         addEvent("ADD_NODE", "Adding new node to cluster");
-
         cluster.addNode()
                .onSuccess(nodeId -> {
-                   addEvent("NODE_JOINED", "Node " + nodeId.id() + " joined the cluster");
-                   sendResponse(ctx, OK, "{\"success\": true, \"nodeId\": \"" + nodeId.id() + "\", \"state\": \"joining\"}");
-               })
+                              addEvent("NODE_JOINED",
+                                       "Node " + nodeId.id() + " joined the cluster");
+                              sendResponse(ctx,
+                                           OK,
+                                           "{\"success\": true, \"nodeId\": \"" + nodeId.id()
+                                           + "\", \"state\": \"joining\"}");
+                          })
                .onFailure(cause -> {
-                   addEvent("ADD_NODE_FAILED", "Failed to add node: " + cause.message());
-                   sendResponse(ctx, INTERNAL_SERVER_ERROR, "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
-               });
+                              addEvent("ADD_NODE_FAILED",
+                                       "Failed to add node: " + cause.message());
+                              sendResponse(ctx,
+                                           INTERNAL_SERVER_ERROR,
+                                           "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
+                          });
     }
 
     private void handleKillNode(ChannelHandlerContext ctx, String nodeId) {
-        var wasLeader = cluster.currentLeader().fold(() -> false, l -> l.equals(nodeId));
-
-        addEvent("KILL_NODE", "Killing node " + nodeId + (wasLeader ? " (leader)" : ""));
-
+        var wasLeader = cluster.currentLeader()
+                               .fold(() -> false,
+                                     l -> l.equals(nodeId));
+        addEvent("KILL_NODE", "Killing node " + nodeId + (wasLeader
+                                                          ? " (leader)"
+                                                          : ""));
         cluster.killNode(nodeId)
                .onSuccess(_ -> {
-                   var newLeader = cluster.currentLeader().fold(() -> "none", l -> l);
-                   addEvent("NODE_KILLED", "Node " + nodeId + " killed" + (wasLeader ? ", new leader: " + newLeader : ""));
-                   sendResponse(ctx, OK, "{\"success\": true, \"newLeader\": \"" + newLeader + "\"}");
-               })
+                              var newLeader = cluster.currentLeader()
+                                                     .fold(() -> "none",
+                                                           l -> l);
+                              addEvent("NODE_KILLED",
+                                       "Node " + nodeId + " killed" + (wasLeader
+                                                                       ? ", new leader: " + newLeader
+                                                                       : ""));
+                              sendResponse(ctx, OK, "{\"success\": true, \"newLeader\": \"" + newLeader + "\"}");
+                          })
                .onFailure(cause -> {
-                   addEvent("KILL_FAILED", "Failed to kill node " + nodeId);
-                   sendResponse(ctx, INTERNAL_SERVER_ERROR, "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
-               });
+                              addEvent("KILL_FAILED", "Failed to kill node " + nodeId);
+                              sendResponse(ctx,
+                                           INTERNAL_SERVER_ERROR,
+                                           "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
+                          });
     }
 
     private void handleCrashNode(ChannelHandlerContext ctx, String nodeId) {
-        var wasLeader = cluster.currentLeader().fold(() -> false, l -> l.equals(nodeId));
-
-        addEvent("CRASH_NODE", "Crashing node " + nodeId + " abruptly" + (wasLeader ? " (leader)" : ""));
-
+        var wasLeader = cluster.currentLeader()
+                               .fold(() -> false,
+                                     l -> l.equals(nodeId));
+        addEvent("CRASH_NODE", "Crashing node " + nodeId + " abruptly" + (wasLeader
+                                                                          ? " (leader)"
+                                                                          : ""));
         cluster.crashNode(nodeId)
                .onSuccess(_ -> {
-                   var newLeader = cluster.currentLeader().fold(() -> "none", l -> l);
-                   addEvent("NODE_CRASHED", "Node " + nodeId + " crashed");
-                   sendResponse(ctx, OK, "{\"success\": true, \"newLeader\": \"" + newLeader + "\"}");
-               })
+                              var newLeader = cluster.currentLeader()
+                                                     .fold(() -> "none",
+                                                           l -> l);
+                              addEvent("NODE_CRASHED", "Node " + nodeId + " crashed");
+                              sendResponse(ctx, OK, "{\"success\": true, \"newLeader\": \"" + newLeader + "\"}");
+                          })
                .onFailure(cause -> {
-                   addEvent("CRASH_FAILED", "Failed to crash node " + nodeId);
-                   sendResponse(ctx, INTERNAL_SERVER_ERROR, "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
-               });
+                              addEvent("CRASH_FAILED", "Failed to crash node " + nodeId);
+                              sendResponse(ctx,
+                                           INTERNAL_SERVER_ERROR,
+                                           "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
+                          });
     }
 
     private void handleRollingRestart(ChannelHandlerContext ctx) {
         addEvent("ROLLING_RESTART", "Starting rolling restart of all nodes");
-
         cluster.rollingRestart()
                .onSuccess(_ -> {
-                   addEvent("ROLLING_RESTART_COMPLETE", "Rolling restart completed successfully");
-                   sendResponse(ctx, OK, "{\"success\": true}");
-               })
+                              addEvent("ROLLING_RESTART_COMPLETE", "Rolling restart completed successfully");
+                              sendResponse(ctx, OK, "{\"success\": true}");
+                          })
                .onFailure(cause -> {
-                   addEvent("ROLLING_RESTART_FAILED", "Rolling restart failed: " + cause.message());
-                   sendResponse(ctx, INTERNAL_SERVER_ERROR, "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
-               });
+                              addEvent("ROLLING_RESTART_FAILED",
+                                       "Rolling restart failed: " + cause.message());
+                              sendResponse(ctx,
+                                           INTERNAL_SERVER_ERROR,
+                                           "{\"success\": false, \"error\": \"" + escapeJson(cause.message()) + "\"}");
+                          });
     }
 
     private void handleSetLoad(ChannelHandlerContext ctx, String rateStr) {
-        try {
+        try{
             var rate = Integer.parseInt(rateStr);
             loadGenerator.setRate(rate);
             addEvent("LOAD_SET", "Load set to " + rate + " req/sec");
@@ -277,15 +314,17 @@ private void handleSetLoad(ChannelHandlerContext ctx, String rateStr) {
     }
 
     private void handleRampLoad(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             // Simple parsing - expect {"targetRate": 5000, "durationMs": 30000}
             var targetRate = extractInt(body, "targetRate", 5000);
             var durationMs = extractLong(body, "durationMs", 30000);
-
             loadGenerator.rampUp(targetRate, durationMs);
             addEvent("LOAD_RAMP", "Ramping load to " + targetRate + " req/sec over " + (durationMs / 1000) + "s");
-            sendResponse(ctx, OK, "{\"success\": true, \"targetRate\": " + targetRate + ", \"durationMs\": " + durationMs + "}");
+            sendResponse(ctx,
+                         OK,
+                         "{\"success\": true, \"targetRate\": " + targetRate + ", \"durationMs\": " + durationMs + "}");
         } catch (Exception e) {
             sendResponse(ctx, BAD_REQUEST, "{\"success\": false, \"error\": \"" + escapeJson(e.getMessage()) + "\"}");
         }
@@ -298,9 +337,15 @@ private void handleEvents(ChannelHandlerContext ctx) {
             if (!first) eventsJson.append(",");
             first = false;
             eventsJson.append("{")
-                      .append("\"timestamp\":\"").append(event.timestamp).append("\",")
-                      .append("\"type\":\"").append(event.type).append("\",")
-                      .append("\"message\":\"").append(escapeJson(event.message)).append("\"")
+                      .append("\"timestamp\":\"")
+                      .append(event.timestamp)
+                      .append("\",")
+                      .append("\"type\":\"")
+                      .append(event.type)
+                      .append("\",")
+                      .append("\"message\":\"")
+                      .append(escapeJson(event.message))
+                      .append("\"")
                       .append("}");
         }
         eventsJson.append("]");
@@ -322,11 +367,21 @@ private void handleNodeMetrics(ChannelHandlerContext ctx) {
             if (!first) json.append(",");
             first = false;
             json.append("{")
-                .append("\"nodeId\":\"").append(m.nodeId()).append("\",")
-                .append("\"isLeader\":").append(m.isLeader()).append(",")
-                .append("\"cpuUsage\":").append(String.format("%.3f", m.cpuUsage())).append(",")
-                .append("\"heapUsedMb\":").append(m.heapUsedMb()).append(",")
-                .append("\"heapMaxMb\":").append(m.heapMaxMb())
+                .append("\"nodeId\":\"")
+                .append(m.nodeId())
+                .append("\",")
+                .append("\"isLeader\":")
+                .append(m.isLeader())
+                .append(",")
+                .append("\"cpuUsage\":")
+                .append(String.format("%.3f",
+                                      m.cpuUsage()))
+                .append(",")
+                .append("\"heapUsedMb\":")
+                .append(m.heapUsedMb())
+                .append(",")
+                .append("\"heapMaxMb\":")
+                .append(m.heapMaxMb())
                 .append("}");
         }
         json.append("]");
@@ -337,7 +392,8 @@ private void handleNodeMetrics(ChannelHandlerContext ctx) {
      * Handle simulator metrics request - returns per-entry-point metrics.
      */
     private void handleSimulatorMetrics(ChannelHandlerContext ctx) {
-        var snapshots = loadGenerator.entryPointMetrics().snapshot();
+        var snapshots = loadGenerator.entryPointMetrics()
+                                     .snapshot();
         var json = new StringBuilder("{\"entryPoints\":[");
         var first = true;
         for (var snapshot : snapshots) {
@@ -355,15 +411,14 @@ private void handleSimulatorMetrics(ChannelHandlerContext ctx) {
      * Body: {"rate": 500}
      */
     private void handleSimulatorRate(ChannelHandlerContext ctx, String entryPoint, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
-            var rate = extractInt(body, "rate", -1);
-
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
+            var rate = extractInt(body, "rate", - 1);
             if (rate < 0) {
                 sendResponse(ctx, BAD_REQUEST, "{\"success\":false,\"error\":\"Missing or invalid rate\"}");
                 return;
             }
-
             loadGenerator.setRate(entryPoint, rate);
             addEvent("RATE_SET", "Set " + entryPoint + " rate to " + rate + " req/sec");
             sendResponse(ctx, OK, "{\"success\":true,\"entryPoint\":\"" + entryPoint + "\",\"rate\":" + rate + "}");
@@ -383,7 +438,11 @@ private void handleSimulatorEntryPoints(ChannelHandlerContext ctx) {
             if (!first) json.append(",");
             first = false;
             var rate = loadGenerator.currentRate(ep);
-            json.append("{\"name\":\"").append(ep).append("\",\"rate\":").append(rate).append("}");
+            json.append("{\"name\":\"")
+                .append(ep)
+                .append("\",\"rate\":")
+                .append(rate)
+                .append("}");
         }
         json.append("]}");
         sendResponse(ctx, OK, json.toString());
@@ -400,12 +459,12 @@ private void handleGetConfig(ChannelHandlerContext ctx) {
      * Handle replace simulator config.
      */
     private void handlePutConfig(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             var newConfig = SimulatorConfig.parseJson(body);
             config = newConfig;
             applyLoadGeneratorSettings(newConfig);
-
             addEvent("CONFIG_UPDATE", "Simulator configuration updated");
             sendResponse(ctx, OK, "{\"success\":true}");
         } catch (Exception e) {
@@ -417,8 +476,9 @@ private void handlePutConfig(ChannelHandlerContext ctx, FullHttpRequest request)
      * Handle set global rate multiplier.
      */
     private void handleSetMultiplier(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             var pattern = java.util.regex.Pattern.compile("\"multiplier\"\\s*:\\s*([\\d.]+)");
             var matcher = pattern.matcher(body);
             if (matcher.find()) {
@@ -426,10 +486,9 @@ private void handleSetMultiplier(ChannelHandlerContext ctx, FullHttpRequest requ
                 var newConfig = config.withGlobalMultiplier(multiplier);
                 config = newConfig;
                 applyLoadGeneratorSettings(newConfig);
-
                 addEvent("MULTIPLIER_SET", "Global rate multiplier set to " + multiplier);
                 sendResponse(ctx, OK, "{\"success\":true,\"multiplier\":" + multiplier + "}");
-            } else {
+            }else {
                 sendResponse(ctx, BAD_REQUEST, "{\"success\":false,\"error\":\"Missing multiplier\"}");
             }
         } catch (Exception e) {
@@ -441,8 +500,9 @@ private void handleSetMultiplier(ChannelHandlerContext ctx, FullHttpRequest requ
      * Handle enable/disable load generator.
      */
     private void handleSetEnabled(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             var pattern = java.util.regex.Pattern.compile("\"enabled\"\\s*:\\s*(true|false)");
             var matcher = pattern.matcher(body);
             if (matcher.find()) {
@@ -450,10 +510,11 @@ private void handleSetEnabled(ChannelHandlerContext ctx, FullHttpRequest request
                 var newConfig = config.withLoadGeneratorEnabled(enabled);
                 config = newConfig;
                 applyLoadGeneratorSettings(newConfig);
-
-                addEvent("LOAD_GENERATOR", "Load generator " + (enabled ? "enabled" : "disabled"));
+                addEvent("LOAD_GENERATOR", "Load generator " + (enabled
+                                                                ? "enabled"
+                                                                : "disabled"));
                 sendResponse(ctx, OK, "{\"success\":true,\"enabled\":" + enabled + "}");
-            } else {
+            }else {
                 sendResponse(ctx, BAD_REQUEST, "{\"success\":false,\"error\":\"Missing enabled\"}");
             }
         } catch (Exception e) {
@@ -465,7 +526,9 @@ private void handleSetEnabled(ChannelHandlerContext ctx, FullHttpRequest request
      * Handle get inventory mode - simulated.
      */
     private void handleGetInventoryMode(ChannelHandlerContext ctx) {
-        sendResponse(ctx, OK, "{\"mode\":\"" + (infiniteInventoryMode ? "infinite" : "realistic") + "\"}");
+        sendResponse(ctx, OK, "{\"mode\":\"" + (infiniteInventoryMode
+                                                ? "infinite"
+                                                : "realistic") + "\"}");
     }
 
     /**
@@ -473,16 +536,23 @@ private void handleGetInventoryMode(ChannelHandlerContext ctx) {
      * Body: {"mode": "infinite"} or {"mode": "realistic"}
      */
     private void handleSetInventoryMode(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             var pattern = java.util.regex.Pattern.compile("\"mode\"\\s*:\\s*\"(\\w+)\"");
             var matcher = pattern.matcher(body);
             if (matcher.find()) {
                 var mode = matcher.group(1);
                 infiniteInventoryMode = "infinite".equalsIgnoreCase(mode);
-                addEvent("INVENTORY_MODE", "Inventory mode set to " + (infiniteInventoryMode ? "infinite" : "realistic"));
-                sendResponse(ctx, OK, "{\"success\":true,\"mode\":\"" + (infiniteInventoryMode ? "infinite" : "realistic") + "\"}");
-            } else {
+                addEvent("INVENTORY_MODE", "Inventory mode set to " + (infiniteInventoryMode
+                                                                       ? "infinite"
+                                                                       : "realistic"));
+                sendResponse(ctx,
+                             OK,
+                             "{\"success\":true,\"mode\":\"" + (infiniteInventoryMode
+                                                                ? "infinite"
+                                                                : "realistic") + "\"}");
+            }else {
                 sendResponse(ctx, BAD_REQUEST, "{\"success\":false,\"error\":\"Missing mode\"}");
             }
         } catch (Exception e) {
@@ -495,10 +565,12 @@ private void handleSetInventoryMode(ChannelHandlerContext ctx, FullHttpRequest r
      */
     private void handleInventoryMetrics(ChannelHandlerContext ctx) {
         var json = String.format(
-            "{\"totalReservations\":%d,\"totalReleases\":%d,\"stockOuts\":%d,\"infiniteMode\":%b,\"refillRate\":%d}",
-            simulatedReservations, simulatedReleases, simulatedStockOuts,
-            infiniteInventoryMode, 100
-        );
+        "{\"totalReservations\":%d,\"totalReleases\":%d,\"stockOuts\":%d,\"infiniteMode\":%b,\"refillRate\":%d}",
+        simulatedReservations,
+        simulatedReleases,
+        simulatedStockOuts,
+        infiniteInventoryMode,
+        100);
         sendResponse(ctx, OK, json);
     }
 
@@ -523,22 +595,29 @@ private void handleInventoryReset(ChannelHandlerContext ctx) {
     }
 
     // ==================== Chaos API Handlers ====================
-
     /**
      * Get chaos controller status.
      */
     private void handleChaosStatus(ChannelHandlerContext ctx) {
-        sendResponse(ctx, OK, chaosController.status().toJson());
+        sendResponse(ctx,
+                     OK,
+                     chaosController.status()
+                                    .toJson());
     }
 
     /**
      * Enable or disable chaos injection.
      */
     private void handleChaosEnable(ChannelHandlerContext ctx, FullHttpRequest request) {
-        var body = request.content().toString(StandardCharsets.UTF_8);
+        var body = request.content()
+                          .toString(StandardCharsets.UTF_8);
         var enabled = extractBoolean(body, "enabled", false);
         chaosController.setEnabled(enabled);
-        addEvent("CHAOS_" + (enabled ? "ENABLED" : "DISABLED"), "Chaos controller " + (enabled ? "enabled" : "disabled"));
+        addEvent("CHAOS_" + (enabled
+                             ? "ENABLED"
+                             : "DISABLED"), "Chaos controller " + (enabled
+                                                                   ? "enabled"
+                                                                   : "disabled"));
         sendResponse(ctx, OK, "{\"success\":true,\"enabled\":" + enabled + "}");
     }
 
@@ -547,21 +626,21 @@ private void handleChaosEnable(ChannelHandlerContext ctx, FullHttpRequest reques
      * Body format: {"type":"NODE_KILL","nodeId":"node-1","durationSeconds":30}
      */
     private void handleChaosInject(ChannelHandlerContext ctx, FullHttpRequest request) {
-        try {
-            var body = request.content().toString(StandardCharsets.UTF_8);
+        try{
+            var body = request.content()
+                              .toString(StandardCharsets.UTF_8);
             var type = extractString(body, "type", "");
             var durationSeconds = extractLong(body, "durationSeconds", 60);
             var duration = Duration.ofSeconds(durationSeconds);
-
             ChaosEvent event = switch (type.toUpperCase()) {
-                case "NODE_KILL" -> {
+                case"NODE_KILL" -> {
                     var nodeId = extractString(body, "nodeId", null);
                     if (nodeId == null || nodeId.isBlank()) {
                         throw new IllegalArgumentException("nodeId is required for NODE_KILL");
                     }
                     yield ChaosEvent.NodeKill.kill(nodeId, duration);
                 }
-                case "LATENCY_SPIKE" -> {
+                case"LATENCY_SPIKE" -> {
                     var nodeId = extractString(body, "nodeId", null);
                     if (nodeId == null || nodeId.isBlank()) {
                         throw new IllegalArgumentException("nodeId is required for LATENCY_SPIKE");
@@ -569,7 +648,7 @@ private void handleChaosInject(ChannelHandlerContext ctx, FullHttpRequest reques
                     var latencyMs = extractLong(body, "latencyMs", 500);
                     yield ChaosEvent.LatencySpike.addLatency(nodeId, latencyMs, duration);
                 }
-                case "SLICE_CRASH" -> {
+                case"SLICE_CRASH" -> {
                     var artifact = extractString(body, "artifact", null);
                     if (artifact == null || artifact.isBlank()) {
                         throw new IllegalArgumentException("artifact is required for SLICE_CRASH");
@@ -577,12 +656,12 @@ private void handleChaosInject(ChannelHandlerContext ctx, FullHttpRequest reques
                     var nodeId = extractString(body, "nodeId", null);
                     yield ChaosEvent.SliceCrash.crashSlice(artifact, nodeId, duration);
                 }
-                case "INVOCATION_FAILURE" -> {
+                case"INVOCATION_FAILURE" -> {
                     var artifact = extractString(body, "artifact", null);
                     var failureRate = extractDouble(body, "failureRate", 0.5);
                     yield ChaosEvent.InvocationFailure.forSlice(artifact, failureRate, duration);
                 }
-                case "CPU_SPIKE" -> {
+                case"CPU_SPIKE" -> {
                     var nodeId = extractString(body, "nodeId", null);
                     if (nodeId == null || nodeId.isBlank()) {
                         throw new IllegalArgumentException("nodeId is required for CPU_SPIKE");
@@ -590,7 +669,7 @@ private void handleChaosInject(ChannelHandlerContext ctx, FullHttpRequest reques
                     var level = extractDouble(body, "level", 0.8);
                     yield ChaosEvent.CpuSpike.onNode(nodeId, level, duration);
                 }
-                case "MEMORY_PRESSURE" -> {
+                case"MEMORY_PRESSURE" -> {
                     var nodeId = extractString(body, "nodeId", null);
                     if (nodeId == null || nodeId.isBlank()) {
                         throw new IllegalArgumentException("nodeId is required for MEMORY_PRESSURE");
@@ -600,16 +679,17 @@ private void handleChaosInject(ChannelHandlerContext ctx, FullHttpRequest reques
                 }
                 default -> throw new IllegalArgumentException("Unknown chaos type: " + type);
             };
-
             chaosController.injectChaos(event)
-                .onSuccess(eventId -> sendResponse(ctx, OK,
-                    "{\"success\":true,\"eventId\":\"" + eventId + "\",\"type\":\"" + type + "\"}"))
-                .onFailure(cause -> sendResponse(ctx, BAD_REQUEST,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}"));
-
+                           .onSuccess(eventId -> sendResponse(ctx,
+                                                              OK,
+                                                              "{\"success\":true,\"eventId\":\"" + eventId
+                                                              + "\",\"type\":\"" + type + "\"}"))
+                           .onFailure(cause -> sendResponse(ctx,
+                                                            BAD_REQUEST,
+                                                            "{\"success\":false,\"error\":\"" + escapeJson(cause.message())
+                                                            + "\"}"));
         } catch (Exception e) {
-            sendResponse(ctx, BAD_REQUEST,
-                "{\"success\":false,\"error\":\"" + escapeJson(e.getMessage()) + "\"}");
+            sendResponse(ctx, BAD_REQUEST, "{\"success\":false,\"error\":\"" + escapeJson(e.getMessage()) + "\"}");
         }
     }
 
@@ -632,7 +712,6 @@ private void handleChaosStopAll(ChannelHandlerContext ctx) {
     }
 
     // ==================== Mode API Handlers ====================
-
     /**
      * Get current simulator mode.
      */
@@ -652,9 +731,11 @@ private void handleGetModes(ChannelHandlerContext ctx) {
      */
     private void handleSetMode(ChannelHandlerContext ctx, String modeName) {
         SimulatorMode.simulatorMode(modeName)
-            .onSuccess(newMode -> applyMode(ctx, newMode))
-            .onFailure(cause -> sendResponse(ctx, BAD_REQUEST,
-                "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}"));
+                     .onSuccess(newMode -> applyMode(ctx, newMode))
+                     .onFailure(cause -> sendResponse(ctx,
+                                                      BAD_REQUEST,
+                                                      "{\"success\":false,\"error\":\"" + escapeJson(cause.message())
+                                                      + "\"}"));
     }
 
     /**
@@ -663,7 +744,6 @@ private void handleSetMode(ChannelHandlerContext ctx, String modeName) {
     private void applyMode(ChannelHandlerContext ctx, SimulatorMode newMode) {
         String oldModeName;
         SimulatorConfig newConfig;
-
         // Synchronized update of mode and config
         synchronized (modeLock) {
             oldModeName = currentMode.name();
@@ -671,44 +751,40 @@ private void applyMode(ChannelHandlerContext ctx, SimulatorMode newMode) {
             newConfig = newMode.applyTo(config);
             config = newConfig;
         }
-
         // These operations are idempotent and can be outside the lock
         chaosController.setEnabled(newMode.chaosEnabled());
         applyLoadGeneratorSettings(newConfig);
-
         addEvent("MODE_CHANGED", "Simulator mode changed from " + oldModeName + " to " + newMode.displayName());
-        sendResponse(ctx, OK, String.format(
-            "{\"success\":true,\"previousMode\":\"%s\",\"currentMode\":\"%s\"}",
-            oldModeName, newMode.name()
-        ));
+        sendResponse(ctx,
+                     OK,
+                     String.format(
+        "{\"success\":true,\"previousMode\":\"%s\",\"currentMode\":\"%s\"}", oldModeName, newMode.name()));
     }
 
     // ==================== Simulated Order API Handlers ====================
     // These handlers return simulated responses for load testing when no slices are loaded
-
     /**
      * Handle order placement - returns simulated response.
      */
     private void handlePlaceOrder(ChannelHandlerContext ctx, FullHttpRequest request) {
         applySimulation("place-order")
-            .onSuccess(_ -> {
-                var random = java.util.concurrent.ThreadLocalRandom.current();
-                var orderId = String.format("ORD-%08d", random.nextInt(100_000_000));
-
-                // Track order ID for subsequent queries
-                DataGenerator.OrderIdGenerator.trackOrderId(orderId);
-
-                var total = 10.00 + random.nextDouble() * 990.00;  // $10-$1000
-                var json = String.format(
-                    "{\"success\":true,\"orderId\":\"%s\",\"status\":\"CONFIRMED\",\"total\":\"USD %.2f\"}",
-                    orderId, total
-                );
-                sendResponse(ctx, OK, json);
-            })
-            .onFailure(cause -> {
-                sendResponse(ctx, INTERNAL_SERVER_ERROR,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
-            });
+        .onSuccess(_ -> {
+                       var random = java.util.concurrent.ThreadLocalRandom.current();
+                       var orderId = String.format("ORD-%08d",
+                                                   random.nextInt(100_000_000));
+                       // Track order ID for subsequent queries
+        DataGenerator.OrderIdGenerator.trackOrderId(orderId);
+                       var total = 10.00 + random.nextDouble() * 990.00;
+                       // $10-$1000
+        var json = String.format(
+        "{\"success\":true,\"orderId\":\"%s\",\"status\":\"CONFIRMED\",\"total\":\"USD %.2f\"}", orderId, total);
+                       sendResponse(ctx, OK, json);
+                   })
+        .onFailure(cause -> {
+                       sendResponse(ctx,
+                                    INTERNAL_SERVER_ERROR,
+                                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
+                   });
     }
 
     /**
@@ -716,44 +792,47 @@ private void handlePlaceOrder(ChannelHandlerContext ctx, FullHttpRequest request
      */
     private void handleGetOrderStatus(ChannelHandlerContext ctx, String orderId) {
         applySimulation("get-order-status")
-            .onSuccess(_ -> {
-                var random = java.util.concurrent.ThreadLocalRandom.current();
-                var statuses = List.of("CONFIRMED", "PROCESSING", "SHIPPED", "DELIVERED");
-                var status = statuses.get(random.nextInt(statuses.size()));
-                var total = 10.00 + random.nextDouble() * 990.00;
-                var itemCount = 1 + random.nextInt(5);
-
-                var json = String.format(
-                    "{\"success\":true,\"orderId\":\"%s\",\"status\":\"%s\",\"total\":\"USD %.2f\",\"itemCount\":%d}",
-                    orderId, status, total, itemCount
-                );
-                sendResponse(ctx, OK, json);
-            })
-            .onFailure(cause -> {
-                sendResponse(ctx, NOT_FOUND,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
-            });
+        .onSuccess(_ -> {
+                       var random = java.util.concurrent.ThreadLocalRandom.current();
+                       var statuses = List.of("CONFIRMED", "PROCESSING", "SHIPPED", "DELIVERED");
+                       var status = statuses.get(random.nextInt(statuses.size()));
+                       var total = 10.00 + random.nextDouble() * 990.00;
+                       var itemCount = 1 + random.nextInt(5);
+                       var json = String.format(
+        "{\"success\":true,\"orderId\":\"%s\",\"status\":\"%s\",\"total\":\"USD %.2f\",\"itemCount\":%d}",
+        orderId,
+        status,
+        total,
+        itemCount);
+                       sendResponse(ctx, OK, json);
+                   })
+        .onFailure(cause -> {
+                       sendResponse(ctx,
+                                    NOT_FOUND,
+                                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
+                   });
     }
 
     /**
      * Handle cancel order - returns simulated response.
      */
     private void handleCancelOrder(ChannelHandlerContext ctx, String orderId, FullHttpRequest request) {
-        var body = request.content().toString(StandardCharsets.UTF_8);
+        var body = request.content()
+                          .toString(StandardCharsets.UTF_8);
         var reason = extractString(body, "reason", "User requested cancellation");
-
         applySimulation("cancel-order")
-            .onSuccess(_ -> {
-                var json = String.format(
-                    "{\"success\":true,\"orderId\":\"%s\",\"status\":\"CANCELLED\",\"reason\":\"%s\"}",
-                    orderId, escapeJson(reason)
-                );
-                sendResponse(ctx, OK, json);
-            })
-            .onFailure(cause -> {
-                sendResponse(ctx, BAD_REQUEST,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
-            });
+        .onSuccess(_ -> {
+                       var json = String.format(
+        "{\"success\":true,\"orderId\":\"%s\",\"status\":\"CANCELLED\",\"reason\":\"%s\"}",
+        orderId,
+        escapeJson(reason));
+                       sendResponse(ctx, OK, json);
+                   })
+        .onFailure(cause -> {
+                       sendResponse(ctx,
+                                    BAD_REQUEST,
+                                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
+                   });
     }
 
     /**
@@ -761,19 +840,21 @@ orderId, escapeJson(reason)
      */
     private void handleCheckStock(ChannelHandlerContext ctx, String productId) {
         applySimulation("inventory-service")
-            .onSuccess(_ -> {
-                var random = java.util.concurrent.ThreadLocalRandom.current();
-                var available = random.nextInt(1000);
-                var json = String.format(
-                    "{\"success\":true,\"productId\":\"%s\",\"available\":%d,\"sufficient\":%b}",
-                    productId, available, available > 0
-                );
-                sendResponse(ctx, OK, json);
-            })
-            .onFailure(cause -> {
-                sendResponse(ctx, NOT_FOUND,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
-            });
+        .onSuccess(_ -> {
+                       var random = java.util.concurrent.ThreadLocalRandom.current();
+                       var available = random.nextInt(1000);
+                       var json = String.format(
+        "{\"success\":true,\"productId\":\"%s\",\"available\":%d,\"sufficient\":%b}",
+        productId,
+        available,
+        available > 0);
+                       sendResponse(ctx, OK, json);
+                   })
+        .onFailure(cause -> {
+                       sendResponse(ctx,
+                                    NOT_FOUND,
+                                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
+                   });
     }
 
     /**
@@ -781,19 +862,19 @@ private void handleCheckStock(ChannelHandlerContext ctx, String productId) {
      */
     private void handleGetPrice(ChannelHandlerContext ctx, String productId) {
         applySimulation("pricing-service")
-            .onSuccess(_ -> {
-                var random = java.util.concurrent.ThreadLocalRandom.current();
-                var price = 5.00 + random.nextDouble() * 495.00;  // $5-$500
-                var json = String.format(
-                    "{\"success\":true,\"productId\":\"%s\",\"price\":\"USD %.2f\"}",
-                    productId, price
-                );
-                sendResponse(ctx, OK, json);
-            })
-            .onFailure(cause -> {
-                sendResponse(ctx, NOT_FOUND,
-                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
-            });
+        .onSuccess(_ -> {
+                       var random = java.util.concurrent.ThreadLocalRandom.current();
+                       var price = 5.00 + random.nextDouble() * 495.00;
+                       // $5-$500
+        var json = String.format(
+        "{\"success\":true,\"productId\":\"%s\",\"price\":\"USD %.2f\"}", productId, price);
+                       sendResponse(ctx, OK, json);
+                   })
+        .onFailure(cause -> {
+                       sendResponse(ctx,
+                                    NOT_FOUND,
+                                    "{\"success\":false,\"error\":\"" + escapeJson(cause.message()) + "\"}");
+                   });
     }
 
     /**
@@ -801,7 +882,8 @@ private void handleGetPrice(ChannelHandlerContext ctx, String productId) {
      */
     private Promise<Unit> applySimulation(String sliceName) {
         var sliceConfig = config.sliceConfig(sliceName);
-        return sliceConfig.buildSimulation().apply();
+        return sliceConfig.buildSimulation()
+                          .apply();
     }
 
     /**
@@ -810,13 +892,14 @@ private Promise<Unit> applySimulation(String sliceName) {
      */
     private void applyLoadGeneratorSettings(SimulatorConfig cfg) {
         for (var entryPoint : loadGenerator.entryPoints()) {
-            var rate = cfg.loadGeneratorEnabled() ? cfg.effectiveRate(entryPoint) : 0;
+            var rate = cfg.loadGeneratorEnabled()
+                       ? cfg.effectiveRate(entryPoint)
+                       : 0;
             loadGenerator.setRate(entryPoint, rate);
         }
     }
 
     // ==================== Repository API Handlers ====================
-
     /**
      * Handle GET /repository/** - retrieve artifact from DHT.
      */
@@ -827,24 +910,34 @@ private void handleRepositoryGet(ChannelHandlerContext ctx, String path) {
             return;
         }
         var node = nodes.getFirst();
-        node.mavenProtocolHandler().handleGet(path)
+        node.mavenProtocolHandler()
+            .handleGet(path)
             .onSuccess(response -> {
-                if (response.statusCode() == 200) {
-                    var content = Unpooled.wrappedBuffer(response.content());
-                    var httpResponse = new DefaultFullHttpResponse(HTTP_1_1, OK, content);
-                    httpResponse.headers().set(HttpHeaderNames.CONTENT_TYPE, response.contentType());
-                    httpResponse.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().length);
-                    httpResponse.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
-                    ctx.writeAndFlush(httpResponse).addListener(ChannelFutureListener.CLOSE);
-                } else if (response.statusCode() == 404) {
-                    sendResponse(ctx, NOT_FOUND, "{\"error\": \"Artifact not found\"}");
-                } else {
-                    sendResponse(ctx, HttpResponseStatus.valueOf(response.statusCode()),
-                        new String(response.content(), StandardCharsets.UTF_8));
-                }
-            })
-            .onFailure(cause -> sendResponse(ctx, INTERNAL_SERVER_ERROR,
-                "{\"error\": \"" + escapeJson(cause.message()) + "\"}"));
+                           if (response.statusCode() == 200) {
+                           var content = Unpooled.wrappedBuffer(response.content());
+                           var httpResponse = new DefaultFullHttpResponse(HTTP_1_1, OK, content);
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_TYPE,
+                                            response.contentType());
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.CONTENT_LENGTH,
+                                            response.content().length);
+                           httpResponse.headers()
+                                       .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
+                           ctx.writeAndFlush(httpResponse)
+                              .addListener(ChannelFutureListener.CLOSE);
+                       }else if (response.statusCode() == 404) {
+                           sendResponse(ctx, NOT_FOUND, "{\"error\": \"Artifact not found\"}");
+                       }else {
+                           sendResponse(ctx,
+                                        HttpResponseStatus.valueOf(response.statusCode()),
+                                        new String(response.content(),
+                                                   StandardCharsets.UTF_8));
+                       }
+                       })
+            .onFailure(cause -> sendResponse(ctx,
+                                             INTERNAL_SERVER_ERROR,
+                                             "{\"error\": \"" + escapeJson(cause.message()) + "\"}"));
     }
 
     /**
@@ -860,27 +953,31 @@ private void handleRepositoryPut(ChannelHandlerContext ctx, String path, FullHtt
         var byteBuf = request.content();
         var content = new byte[byteBuf.readableBytes()];
         byteBuf.readBytes(content);
-
-        node.mavenProtocolHandler().handlePut(path, content)
+        node.mavenProtocolHandler()
+            .handlePut(path, content)
             .onSuccess(response -> {
-                var json = String.format("{\"success\":true,\"path\":\"%s\",\"size\":%d}",
-                    escapeJson(path), content.length);
-                sendResponse(ctx, OK, json);
-                addEvent("ARTIFACT_DEPLOYED", "Deployed " + path + " (" + content.length + " bytes)");
-            })
-            .onFailure(cause -> sendResponse(ctx, INTERNAL_SERVER_ERROR,
-                "{\"error\": \"" + escapeJson(cause.message()) + "\"}"));
+                           var json = String.format("{\"success\":true,\"path\":\"%s\",\"size\":%d}",
+                                                    escapeJson(path),
+                                                    content.length);
+                           sendResponse(ctx, OK, json);
+                           addEvent("ARTIFACT_DEPLOYED",
+                                    "Deployed " + path + " (" + content.length + " bytes)");
+                       })
+            .onFailure(cause -> sendResponse(ctx,
+                                             INTERNAL_SERVER_ERROR,
+                                             "{\"error\": \"" + escapeJson(cause.message()) + "\"}"));
     }
 
     public void addEvent(String type, String message) {
-        var event = new ForgeEvent(Instant.now().toString(), type, message);
+        var event = new ForgeEvent(Instant.now()
+                                          .toString(),
+                                   type,
+                                   message);
         events.addLast(event);
-
         // Trim in a thread-safe manner - over-deletion is acceptable
         while (events.size() > MAX_EVENTS) {
             events.pollFirst();
         }
-
         log.info("[EVENT] {}: {}", type, message);
     }
 
@@ -891,13 +988,19 @@ private long uptimeSeconds() {
     private void sendResponse(ChannelHandlerContext ctx, HttpResponseStatus status, String json) {
         var content = Unpooled.copiedBuffer(json, StandardCharsets.UTF_8);
         var response = new DefaultFullHttpResponse(HTTP_1_1, status, content);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json");
-        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
-        response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
-        response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, DELETE, OPTIONS");
-        response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type");
-
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, "application/json");
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_LENGTH,
+                     content.readableBytes());
+        response.headers()
+                .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
+        response.headers()
+                .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, DELETE, OPTIONS");
+        response.headers()
+                .set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type");
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     private String toJson(StatusResponse response) {
@@ -907,35 +1010,30 @@ private String toJson(StatusResponse response) {
             if (!first) nodes.append(",");
             first = false;
             nodes.append("{")
-                 .append("\"id\":\"").append(node.id()).append("\",")
-                 .append("\"port\":").append(node.port()).append(",")
-                 .append("\"state\":\"").append(node.state()).append("\",")
-                 .append("\"isLeader\":").append(node.isLeader())
+                 .append("\"id\":\"")
+                 .append(node.id())
+                 .append("\",")
+                 .append("\"port\":")
+                 .append(node.port())
+                 .append(",")
+                 .append("\"state\":\"")
+                 .append(node.state())
+                 .append("\",")
+                 .append("\"isLeader\":")
+                 .append(node.isLeader())
                  .append("}");
         }
         nodes.append("]");
-
-        return "{" +
-               "\"cluster\":{" +
-               "\"nodes\":" + nodes + "," +
-               "\"leaderId\":\"" + response.cluster.leaderId() + "\"," +
-               "\"nodeCount\":" + response.cluster.nodes().size() +
-               "}," +
-               "\"metrics\":{" +
-               "\"requestsPerSecond\":" + String.format("%.1f", response.metrics.requestsPerSecond()) + "," +
-               "\"successRate\":" + String.format("%.2f", response.metrics.successRate()) + "," +
-               "\"avgLatencyMs\":" + String.format("%.2f", response.metrics.avgLatencyMs()) + "," +
-               "\"totalSuccess\":" + response.metrics.totalSuccess() + "," +
-               "\"totalFailures\":" + response.metrics.totalFailures() +
-               "}," +
-               "\"load\":{" +
-               "\"currentRate\":" + response.load.currentRate + "," +
-               "\"targetRate\":" + response.load.targetRate + "," +
-               "\"running\":" + response.load.running +
-               "}," +
-               "\"uptimeSeconds\":" + response.uptimeSeconds + "," +
-               "\"sliceCount\":" + response.sliceCount +
-               "}";
+        return "{" + "\"cluster\":{" + "\"nodes\":" + nodes + "," + "\"leaderId\":\"" + response.cluster.leaderId()
+               + "\"," + "\"nodeCount\":" + response.cluster.nodes()
+                                                    .size() + "}," + "\"metrics\":{" + "\"requestsPerSecond\":" + String.format("%.1f",
+                                                                                                                                response.metrics.requestsPerSecond())
+               + "," + "\"successRate\":" + String.format("%.2f", response.metrics.successRate()) + ","
+               + "\"avgLatencyMs\":" + String.format("%.2f", response.metrics.avgLatencyMs()) + ","
+               + "\"totalSuccess\":" + response.metrics.totalSuccess() + "," + "\"totalFailures\":" + response.metrics.totalFailures()
+               + "}," + "\"load\":{" + "\"currentRate\":" + response.load.currentRate + "," + "\"targetRate\":" + response.load.targetRate
+               + "," + "\"running\":" + response.load.running + "}," + "\"uptimeSeconds\":" + response.uptimeSeconds
+               + "," + "\"sliceCount\":" + response.sliceCount + "}";
     }
 
     private String escapeJson(String str) {
@@ -949,7 +1047,8 @@ private String escapeJson(String str) {
 
     private int extractInt(String json, String key, int defaultValue) {
         var pattern = "\"" + key + "\"\\s*:\\s*(\\d+)";
-        var matcher = java.util.regex.Pattern.compile(pattern).matcher(json);
+        var matcher = java.util.regex.Pattern.compile(pattern)
+                          .matcher(json);
         if (matcher.find()) {
             return Integer.parseInt(matcher.group(1));
         }
@@ -958,7 +1057,8 @@ private int extractInt(String json, String key, int defaultValue) {
 
     private long extractLong(String json, String key, long defaultValue) {
         var pattern = "\"" + key + "\"\\s*:\\s*(\\d+)";
-        var matcher = java.util.regex.Pattern.compile(pattern).matcher(json);
+        var matcher = java.util.regex.Pattern.compile(pattern)
+                          .matcher(json);
         if (matcher.find()) {
             return Long.parseLong(matcher.group(1));
         }
@@ -967,7 +1067,8 @@ private long extractLong(String json, String key, long defaultValue) {
 
     private String extractString(String json, String key, String defaultValue) {
         var pattern = "\"" + key + "\"\\s*:\\s*\"([^\"]*)\"";
-        var matcher = java.util.regex.Pattern.compile(pattern).matcher(json);
+        var matcher = java.util.regex.Pattern.compile(pattern)
+                          .matcher(json);
         if (matcher.find()) {
             return matcher.group(1);
         }
@@ -976,7 +1077,8 @@ private String extractString(String json, String key, String defaultValue) {
 
     private boolean extractBoolean(String json, String key, boolean defaultValue) {
         var pattern = "\"" + key + "\"\\s*:\\s*(true|false)";
-        var matcher = java.util.regex.Pattern.compile(pattern).matcher(json);
+        var matcher = java.util.regex.Pattern.compile(pattern)
+                          .matcher(json);
         if (matcher.find()) {
             return Boolean.parseBoolean(matcher.group(1));
         }
@@ -985,7 +1087,8 @@ private boolean extractBoolean(String json, String key, boolean defaultValue) {
 
     private double extractDouble(String json, String key, double defaultValue) {
         var pattern = "\"" + key + "\"\\s*:\\s*([\\d.]+)";
-        var matcher = java.util.regex.Pattern.compile(pattern).matcher(json);
+        var matcher = java.util.regex.Pattern.compile(pattern)
+                          .matcher(json);
         if (matcher.find()) {
             return Double.parseDouble(matcher.group(1));
         }
@@ -998,7 +1101,13 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         ctx.close();
     }
 
-    private record StatusResponse(ClusterStatus cluster, MetricsSnapshot metrics, LoadStatus load, long uptimeSeconds, int sliceCount) {}
+    private record StatusResponse(ClusterStatus cluster,
+                                  MetricsSnapshot metrics,
+                                  LoadStatus load,
+                                  long uptimeSeconds,
+                                  int sliceCount) {}
+
     private record LoadStatus(int currentRate, int targetRate, boolean running) {}
+
     private record ForgeEvent(String timestamp, String type, String message) {}
 }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java b/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
index daa494d7..a19cbc8a 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
@@ -9,8 +9,6 @@
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.io.TimeSpan;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -18,6 +16,9 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.cluster.net.NodeId.nodeId;
 import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
 import static org.pragmatica.net.NodeAddress.nodeAddress;
@@ -30,7 +31,8 @@ public final class ForgeCluster {
     private static final Logger log = LoggerFactory.getLogger(ForgeCluster.class);
 
     private static final int BASE_PORT = 5050;
-    private static final TimeSpan NODE_TIMEOUT = TimeSpan.timeSpan(10).seconds();
+    private static final TimeSpan NODE_TIMEOUT = TimeSpan.timeSpan(10)
+                                                        .seconds();
 
     private final Map<String, AetherNode> nodes = new ConcurrentHashMap<>();
     private final Map<String, NodeInfo> nodeInfos = new ConcurrentHashMap<>();
@@ -54,10 +56,9 @@ public static ForgeCluster forgeCluster(int initialSize) {
      */
     public Promise<Unit> start() {
         log.info("Starting Forge cluster with {} nodes", initialClusterSize);
-
         // Create node infos for initial cluster
         var initialNodes = new ArrayList<NodeInfo>();
-        for (int i = 1; i <= initialClusterSize; i++) {
+        for (int i = 1; i <= initialClusterSize; i++ ) {
             var nodeId = nodeId("node-" + i);
             var port = BASE_PORT + i - 1;
             var info = nodeInfo(nodeId, nodeAddress("localhost", port));
@@ -65,16 +66,16 @@ public Promise<Unit> start() {
             nodeInfos.put(nodeId.id(), info);
         }
         nodeCounter.set(initialClusterSize);
-
         // Create and start all nodes
         var startPromises = new ArrayList<Promise<Unit>>();
-        for (int i = 0; i < initialClusterSize; i++) {
+        for (int i = 0; i < initialClusterSize; i++ ) {
             var nodeInfo = initialNodes.get(i);
             var node = createNode(nodeInfo.id(), BASE_PORT + i, initialNodes);
-            nodes.put(nodeInfo.id().id(), node);
+            nodes.put(nodeInfo.id()
+                              .id(),
+                      node);
             startPromises.add(node.start());
         }
-
         return Promise.allOf(startPromises)
                       .map(_ -> Unit.unit())
                       .onSuccess(_ -> log.info("Forge cluster started with {} nodes", initialClusterSize));
@@ -85,12 +86,11 @@ public Promise<Unit> start() {
      */
     public Promise<Unit> stop() {
         log.info("Stopping Forge cluster");
-
         var stopPromises = nodes.values()
                                 .stream()
-                                .map(node -> node.stop().timeout(NODE_TIMEOUT))
+                                .map(node -> node.stop()
+                                                 .timeout(NODE_TIMEOUT))
                                 .toList();
-
         return Promise.allOf(stopPromises)
                       .map(_ -> Unit.unit())
                       .onSuccess(_ -> {
@@ -109,20 +109,16 @@ public Promise<NodeId> addNode() {
         var nodeId = nodeId("node-" + nodeNum);
         var port = BASE_PORT + nodeNum - 1;
         var info = nodeInfo(nodeId, nodeAddress("localhost", port));
-
         log.info("Adding new node {} on port {}", nodeId.id(), port);
-
         nodeInfos.put(nodeId.id(), info);
-
         // Get current topology including the new node
         var allNodes = new ArrayList<>(nodeInfos.values());
-
         var node = createNode(nodeId, port, allNodes);
         nodes.put(nodeId.id(), node);
-
         return node.start()
                    .map(_ -> nodeId)
-                   .onSuccess(_ -> log.info("Node {} joined the cluster", nodeId.id()));
+                   .onSuccess(_ -> log.info("Node {} joined the cluster",
+                                            nodeId.id()));
     }
 
     /**
@@ -134,9 +130,7 @@ public Promise<Unit> killNode(String nodeIdStr) {
             log.warn("Node {} not found", nodeIdStr);
             return Promise.success(Unit.unit());
         }
-
         log.info("Killing node {}", nodeIdStr);
-
         return node.stop()
                    .timeout(NODE_TIMEOUT)
                    .map(_ -> {
@@ -156,13 +150,12 @@ public Promise<Unit> crashNode(String nodeIdStr) {
             log.warn("Node {} not found", nodeIdStr);
             return Promise.success(Unit.unit());
         }
-
         log.info("Crashing node {} abruptly", nodeIdStr);
-
         // For crash simulation, we still call stop() but don't wait long
         return node.stop()
-                   .timeout(TimeSpan.timeSpan(1).seconds())
-                   .recover(_ -> Unit.unit())  // Ignore timeout errors
+                   .timeout(TimeSpan.timeSpan(1)
+                                    .seconds())
+                   .recover(_ -> Unit.unit())
                    .map(_ -> {
                        nodes.remove(nodeIdStr);
                        nodeInfos.remove(nodeIdStr);
@@ -177,42 +170,41 @@ public Promise<Unit> crashNode(String nodeIdStr) {
      */
     public Promise<Unit> rollingRestart() {
         log.info("Starting rolling restart");
-
         var nodeIds = new ArrayList<>(nodes.keySet());
         var currentTopology = new ArrayList<>(nodeInfos.values());
-
         // Chain restarts sequentially
         Promise<Unit> chain = Promise.success(Unit.unit());
-
         for (var nodeIdStr : nodeIds) {
             var nodeInfo = nodeInfos.get(nodeIdStr);
             if (nodeInfo == null) continue;
-
             chain = chain.flatMap(_ -> restartNode(nodeIdStr, nodeInfo, currentTopology));
         }
-
         return chain.onSuccess(_ -> log.info("Rolling restart completed"));
     }
 
     private Promise<Unit> restartNode(String nodeIdStr, NodeInfo nodeInfo, List<NodeInfo> topology) {
         log.info("Rolling restart: restarting {}", nodeIdStr);
-
         var node = nodes.get(nodeIdStr);
         if (node == null) {
             return Promise.success(Unit.unit());
         }
-
         return node.stop()
                    .timeout(NODE_TIMEOUT)
-                   .flatMap(_ -> Promise.promise(TimeSpan.timeSpan(300).millis(), () -> Result.success(Unit.unit())))
+                   .flatMap(_ -> Promise.promise(TimeSpan.timeSpan(300)
+                                                         .millis(),
+                                                 () -> Result.success(Unit.unit())))
                    .flatMap(_ -> {
-                       var port = nodeInfo.address().port();
-                       var newNode = createNode(nodeInfo.id(), port, topology);
-                       nodes.put(nodeIdStr, newNode);
-
-                       return newNode.start();
-                   })
-                   .flatMap(_ -> Promise.promise(TimeSpan.timeSpan(500).millis(), () -> Result.success(Unit.unit())))
+                                var port = nodeInfo.address()
+                                                   .port();
+                                var newNode = createNode(nodeInfo.id(),
+                                                         port,
+                                                         topology);
+                                nodes.put(nodeIdStr, newNode);
+                                return newNode.start();
+                            })
+                   .flatMap(_ -> Promise.promise(TimeSpan.timeSpan(500)
+                                                         .millis(),
+                                                 () -> Result.success(Unit.unit())))
                    .onSuccess(_ -> log.info("Node {} restarted", nodeIdStr));
     }
 
@@ -224,13 +216,11 @@ public Option<String> currentLeader() {
         if (nodes.isEmpty()) {
             return Option.none();
         }
-
         // Take snapshot and sort to ensure consistent leader detection
         var sortedNodes = nodeInfos.keySet()
                                    .stream()
                                    .sorted()
                                    .toList();
-
         return sortedNodes.isEmpty()
                ? Option.none()
                : Option.option(sortedNodes.getFirst());
@@ -243,17 +233,18 @@ public ClusterStatus status() {
         var nodeStatuses = nodes.entrySet()
                                 .stream()
                                 .map(entry -> new NodeStatus(
-                                        entry.getKey(),
-                                        nodeInfos.get(entry.getKey()).address().port(),
-                                        "healthy",
-                                        currentLeader().fold(
-                                                () -> false,
-                                                leaderId -> leaderId.equals(entry.getKey())
-                                        )
-                                ))
+        entry.getKey(),
+        nodeInfos.get(entry.getKey())
+                 .address()
+                 .port(),
+        "healthy",
+        currentLeader()
+        .fold(() -> false,
+              leaderId -> leaderId.equals(entry.getKey()))))
                                 .toList();
-
-        return new ClusterStatus(nodeStatuses, currentLeader().fold(() -> "none", leader -> leader));
+        return new ClusterStatus(nodeStatuses, currentLeader()
+                                              .fold(() -> "none",
+                                                    leader -> leader));
     }
 
     /**
@@ -286,24 +277,25 @@ private AetherNode createNode(NodeId nodeId, int port, List<NodeInfo> coreNodes)
      * Get per-node metrics for all nodes.
      */
     public List<NodeMetrics> nodeMetrics() {
-        return nodes.entrySet().stream()
+        return nodes.entrySet()
+                    .stream()
                     .map(entry -> {
-                        var nodeId = entry.getKey();
-                        var node = entry.getValue();
-                        var metrics = node.metricsCollector().collectLocal();
-
-                        var cpuUsage = metrics.getOrDefault("cpu.usage", 0.0);
-                        var heapUsed = metrics.getOrDefault("heap.used", 0.0);
-                        var heapMax = metrics.getOrDefault("heap.max", 1.0);
-
-                        return new NodeMetrics(
-                                nodeId,
-                                currentLeader().fold(() -> false, l -> l.equals(nodeId)),
-                                cpuUsage,
-                                (long) (heapUsed / 1024 / 1024),
-                                (long) (heapMax / 1024 / 1024)
-                        );
-                    })
+                             var nodeId = entry.getKey();
+                             var node = entry.getValue();
+                             var metrics = node.metricsCollector()
+                                               .collectLocal();
+                             var cpuUsage = metrics.getOrDefault("cpu.usage", 0.0);
+                             var heapUsed = metrics.getOrDefault("heap.used", 0.0);
+                             var heapMax = metrics.getOrDefault("heap.max", 1.0);
+                             return new NodeMetrics(
+        nodeId,
+        currentLeader()
+        .fold(() -> false,
+              l -> l.equals(nodeId)),
+        cpuUsage,
+        (long)(heapUsed / 1024 / 1024),
+        (long)(heapMax / 1024 / 1024));
+                         })
                     .toList();
     }
 
@@ -311,28 +303,25 @@ public List<NodeMetrics> nodeMetrics() {
      * Status of a single node.
      */
     public record NodeStatus(
-            String id,
-            int port,
-            String state,
-            boolean isLeader
-    ) {}
+    String id,
+    int port,
+    String state,
+    boolean isLeader) {}
 
     /**
      * Status of the entire cluster.
      */
     public record ClusterStatus(
-            List<NodeStatus> nodes,
-            String leaderId
-    ) {}
+    List<NodeStatus> nodes,
+    String leaderId) {}
 
     /**
      * Per-node metrics for dashboard display.
      */
     public record NodeMetrics(
-            String nodeId,
-            boolean isLeader,
-            double cpuUsage,
-            long heapUsedMb,
-            long heapMaxMb
-    ) {}
+    String nodeId,
+    boolean isLeader,
+    double cpuUsage,
+    long heapUsedMb,
+    long heapMaxMb) {}
 }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/ForgeMetrics.java b/forge/src/main/java/org/pragmatica/aether/forge/ForgeMetrics.java
index 234820fb..280fcd22 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/ForgeMetrics.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/ForgeMetrics.java
@@ -8,7 +8,6 @@
  * Thread-safe and designed for high-frequency updates.
  */
 public final class ForgeMetrics {
-
     // Rolling window counters (reset every second)
     private final LongAdder successCount = new LongAdder();
     private final LongAdder failureCount = new LongAdder();
@@ -63,34 +62,27 @@ public void snapshot() {
         var now = System.currentTimeMillis();
         var elapsed = now - lastSnapshotTime;
         if (elapsed <= 0) elapsed = 1;
-
         var currentSuccess = totalSuccess.get();
         var currentFailure = totalFailures.get();
-
         var successDelta = currentSuccess - lastSuccessSnapshot;
         var failureDelta = currentFailure - lastFailureSnapshot;
         var totalDelta = successDelta + failureDelta;
-
         // Calculate rates
         requestsPerSecond = (totalDelta * 1000.0) / elapsed;
-
         if (totalDelta > 0) {
             successRate = (successDelta * 100.0) / totalDelta;
-        } else {
+        }else {
             successRate = 100.0;
         }
-
         // Calculate average latency from recent requests
         var count = requestCount.sumThenReset();
         var latency = totalLatencyNanos.sumThenReset();
         if (count > 0) {
             avgLatencyMs = (latency / count) / 1_000_000.0;
         }
-
         // Reset window counters
         successCount.reset();
         failureCount.reset();
-
         // Update snapshot markers
         lastSuccessSnapshot = currentSuccess;
         lastFailureSnapshot = currentFailure;
@@ -102,12 +94,7 @@ public void snapshot() {
      */
     public MetricsSnapshot currentMetrics() {
         return new MetricsSnapshot(
-                requestsPerSecond,
-                successRate,
-                avgLatencyMs,
-                totalSuccess.get(),
-                totalFailures.get()
-        );
+        requestsPerSecond, successRate, avgLatencyMs, totalSuccess.get(), totalFailures.get());
     }
 
     /**
@@ -132,12 +119,11 @@ public void reset() {
      * Metrics snapshot for dashboard.
      */
     public record MetricsSnapshot(
-            double requestsPerSecond,
-            double successRate,
-            double avgLatencyMs,
-            long totalSuccess,
-            long totalFailures
-    ) {
+    double requestsPerSecond,
+    double successRate,
+    double avgLatencyMs,
+    long totalSuccess,
+    long totalFailures) {
         public long totalRequests() {
             return totalSuccess + totalFailures;
         }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/LoadGenerator.java b/forge/src/main/java/org/pragmatica/aether/forge/LoadGenerator.java
index ce3f65b9..f007aa92 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/LoadGenerator.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/LoadGenerator.java
@@ -3,8 +3,6 @@
 import org.pragmatica.aether.forge.simulator.DataGenerator;
 import org.pragmatica.aether.forge.simulator.EntryPointMetrics;
 import org.pragmatica.aether.forge.simulator.SimulatorConfig;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.net.URI;
 import java.net.http.HttpClient;
@@ -22,6 +20,9 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Generates continuous HTTP load against the cluster for demo purposes.
  * Supports per-entry-point rate control and metrics tracking.
@@ -52,12 +53,14 @@ private LoadGenerator(int port, ForgeMetrics metrics, EntryPointMetrics entryPoi
                                     .connectTimeout(REQUEST_TIMEOUT)
                                     .executor(Executors.newVirtualThreadPerTaskExecutor())
                                     .build();
-
         // Initialize entry points from config
         initializeEntryPoints(config);
     }
 
-    public static LoadGenerator loadGenerator(int port, ForgeMetrics metrics, EntryPointMetrics entryPointMetrics, SimulatorConfig config) {
+    public static LoadGenerator loadGenerator(int port,
+                                              ForgeMetrics metrics,
+                                              EntryPointMetrics entryPointMetrics,
+                                              SimulatorConfig config) {
         return new LoadGenerator(port, metrics, entryPointMetrics, config);
     }
 
@@ -75,48 +78,29 @@ public static LoadGenerator loadGenerator(int port, ForgeMetrics metrics) {
     private void initializeEntryPoints(SimulatorConfig config) {
         // POST /api/orders - place order
         var placeOrderConfig = config.entryPointConfig("placeOrder");
-        generators.put("placeOrder", new EntryPointGenerator(
-            "placeOrder",
-            placeOrderConfig.buildGenerator("placeOrder"),
-            "POST",
-            "/api/orders"
-        ));
-
+        generators.put("placeOrder",
+                       new EntryPointGenerator(
+        "placeOrder", placeOrderConfig.buildGenerator("placeOrder"), "POST", "/api/orders"));
         // GET /api/orders/{id} - get order status
         var getOrderConfig = config.entryPointConfig("getOrderStatus");
-        generators.put("getOrderStatus", new EntryPointGenerator(
-            "getOrderStatus",
-            getOrderConfig.buildGenerator("getOrderStatus"),
-            "GET",
-            "/api/orders/{id}"
-        ));
-
+        generators.put("getOrderStatus",
+                       new EntryPointGenerator(
+        "getOrderStatus", getOrderConfig.buildGenerator("getOrderStatus"), "GET", "/api/orders/{id}"));
         // DELETE /api/orders/{id} - cancel order
         var cancelConfig = config.entryPointConfig("cancelOrder");
-        generators.put("cancelOrder", new EntryPointGenerator(
-            "cancelOrder",
-            cancelConfig.buildGenerator("cancelOrder"),
-            "DELETE",
-            "/api/orders/{id}"
-        ));
-
+        generators.put("cancelOrder",
+                       new EntryPointGenerator(
+        "cancelOrder", cancelConfig.buildGenerator("cancelOrder"), "DELETE", "/api/orders/{id}"));
         // GET /api/inventory/{productId} - check stock
         var checkStockConfig = config.entryPointConfig("checkStock");
-        generators.put("checkStock", new EntryPointGenerator(
-            "checkStock",
-            checkStockConfig.buildGenerator("checkStock"),
-            "GET",
-            "/api/inventory/{id}"
-        ));
-
+        generators.put("checkStock",
+                       new EntryPointGenerator(
+        "checkStock", checkStockConfig.buildGenerator("checkStock"), "GET", "/api/inventory/{id}"));
         // GET /api/pricing/{productId} - get price
         var getPriceConfig = config.entryPointConfig("getPrice");
-        generators.put("getPrice", new EntryPointGenerator(
-            "getPrice",
-            getPriceConfig.buildGenerator("getPrice"),
-            "GET",
-            "/api/pricing/{id}"
-        ));
+        generators.put("getPrice",
+                       new EntryPointGenerator(
+        "getPrice", getPriceConfig.buildGenerator("getPrice"), "GET", "/api/pricing/{id}"));
     }
 
     /**
@@ -125,11 +109,11 @@ private void initializeEntryPoints(SimulatorConfig config) {
     public void updateConfig(SimulatorConfig newConfig) {
         this.config.set(newConfig);
         initializeEntryPoints(newConfig);
-
         // Update rates from new config
         for (var entry : generators.entrySet()) {
             var rate = newConfig.effectiveRate(entry.getKey());
-            entry.getValue().setRate(rate);
+            entry.getValue()
+                 .setRate(rate);
             entryPointMetrics.setRate(entry.getKey(), rate);
         }
     }
@@ -149,20 +133,15 @@ public void start(int defaultRequestsPerSecond) {
             log.warn("Load generator already running");
             return;
         }
-
         // Set default rate for placeOrder (main entry point)
         setRate("placeOrder", defaultRequestsPerSecond);
-
         log.info("Starting load generator at {} req/sec (placeOrder)", defaultRequestsPerSecond);
-
         scheduler = Executors.newScheduledThreadPool(generators.size() + 1);
-
         // Start a generation thread for each entry point
         for (var generator : generators.values()) {
             var thread = new Thread(() -> generateLoad(generator), "load-" + generator.name);
             thread.start();
         }
-
         // Rate sync scheduler (sync rates to metrics)
         scheduler.scheduleAtFixedRate(this::syncRatesToMetrics, 100, 100, TimeUnit.MILLISECONDS);
     }
@@ -173,13 +152,13 @@ public void start(int defaultRequestsPerSecond) {
     public void stop() {
         log.info("Stopping load generator");
         running.set(false);
-
         if (scheduler != null) {
             scheduler.shutdownNow();
-            try {
+            try{
                 scheduler.awaitTermination(2, TimeUnit.SECONDS);
             } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
+                Thread.currentThread()
+                      .interrupt();
             }
         }
     }
@@ -193,7 +172,7 @@ public void setRate(String entryPoint, int requestsPerSecond) {
             log.info("Setting {} rate to {} req/sec", entryPoint, requestsPerSecond);
             generator.setRate(requestsPerSecond);
             entryPointMetrics.setRate(entryPoint, requestsPerSecond);
-        } else {
+        }else {
             log.warn("Unknown entry point: {}", entryPoint);
         }
     }
@@ -221,7 +200,9 @@ public void rampUp(int targetRateValue, long durationMillis) {
      */
     public int currentRate() {
         var generator = generators.get("placeOrder");
-        return generator != null ? generator.currentRate() : 0;
+        return generator != null
+               ? generator.currentRate()
+               : 0;
     }
 
     /**
@@ -229,7 +210,9 @@ public int currentRate() {
      */
     public int currentRate(String entryPoint) {
         var generator = generators.get(entryPoint);
-        return generator != null ? generator.currentRate() : 0;
+        return generator != null
+               ? generator.currentRate()
+               : 0;
     }
 
     /**
@@ -237,7 +220,9 @@ public int currentRate(String entryPoint) {
      */
     public int targetRate() {
         var generator = generators.get("placeOrder");
-        return generator != null ? generator.targetRate() : 0;
+        return generator != null
+               ? generator.targetRate()
+               : 0;
     }
 
     /**
@@ -263,28 +248,25 @@ public EntryPointMetrics entryPointMetrics() {
 
     private void generateLoad(EntryPointGenerator generator) {
         while (running.get()) {
-            try {
+            try{
                 var rate = generator.currentRate();
                 if (rate <= 0) {
                     Thread.sleep(100);
                     continue;
                 }
-
                 var intervalMicros = 1_000_000 / rate;
                 var startNanos = System.nanoTime();
-
                 sendRequest(generator);
-
                 // Sleep for remaining interval
                 var elapsedMicros = (System.nanoTime() - startNanos) / 1000;
                 var sleepMicros = intervalMicros - elapsedMicros;
                 if (sleepMicros > 0) {
-                    Thread.sleep(sleepMicros / 1000, (int) ((sleepMicros % 1000) * 1000));
+                    Thread.sleep(sleepMicros / 1000, (int)((sleepMicros % 1000) * 1000));
                 }
-
                 generator.adjustRate();
             } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
+                Thread.currentThread()
+                      .interrupt();
                 break;
             } catch (Exception e) {
                 log.debug("Error generating load for {}: {}", generator.name, e.getMessage());
@@ -295,37 +277,34 @@ private void generateLoad(EntryPointGenerator generator) {
     private void sendRequest(EntryPointGenerator generator) {
         var startTime = System.nanoTime();
         var requestData = generator.generateRequest();
-
         var uri = URI.create("http://localhost:" + port + requestData.path());
         var requestBuilder = HttpRequest.newBuilder()
                                         .uri(uri)
                                         .timeout(REQUEST_TIMEOUT);
-
         switch (generator.method) {
-            case "POST" -> requestBuilder
-                .header("Content-Type", "application/json")
-                .POST(HttpRequest.BodyPublishers.ofString(requestData.body()));
-            case "DELETE" -> requestBuilder.DELETE();
+            case"POST" -> requestBuilder.header("Content-Type", "application/json")
+                                        .POST(HttpRequest.BodyPublishers.ofString(requestData.body()));
+            case"DELETE" -> requestBuilder.DELETE();
             default -> requestBuilder.GET();
         }
-
-        httpClient.sendAsync(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
+        httpClient.sendAsync(requestBuilder.build(),
+                             HttpResponse.BodyHandlers.ofString())
                   .thenAccept(response -> {
-                      var latencyNanos = System.nanoTime() - startTime;
-                      if (response.statusCode() >= 200 && response.statusCode() < 300) {
-                          metrics.recordSuccess(latencyNanos);
-                          entryPointMetrics.recordSuccess(generator.name, latencyNanos);
-                      } else {
-                          metrics.recordFailure(latencyNanos);
-                          entryPointMetrics.recordFailure(generator.name, latencyNanos);
-                      }
-                  })
+                                  var latencyNanos = System.nanoTime() - startTime;
+                                  if (response.statusCode() >= 200 && response.statusCode() < 300) {
+                                  metrics.recordSuccess(latencyNanos);
+                                  entryPointMetrics.recordSuccess(generator.name, latencyNanos);
+                              }else {
+                                  metrics.recordFailure(latencyNanos);
+                                  entryPointMetrics.recordFailure(generator.name, latencyNanos);
+                              }
+                              })
                   .exceptionally(e -> {
-                      var latencyNanos = System.nanoTime() - startTime;
-                      metrics.recordFailure(latencyNanos);
-                      entryPointMetrics.recordFailure(generator.name, latencyNanos);
-                      return null;
-                  });
+                                     var latencyNanos = System.nanoTime() - startTime;
+                                     metrics.recordFailure(latencyNanos);
+                                     entryPointMetrics.recordFailure(generator.name, latencyNanos);
+                                     return null;
+                                 });
     }
 
     private void syncRatesToMetrics() {
@@ -364,28 +343,21 @@ private static final class EntryPointGenerator {
         RequestData generateRequest() {
             var random = ThreadLocalRandom.current();
             var data = dataGenerator.generate(random);
-
             return switch (data) {
                 case DataGenerator.OrderRequestGenerator.OrderRequestData order ->
-                    new RequestData("/api/orders", order.toJson());
-
+                new RequestData("/api/orders", order.toJson());
                 case String orderId when name.equals("getOrderStatus") ->
-                    new RequestData("/api/orders/" + orderId, "");
-
+                new RequestData("/api/orders/" + orderId, "");
                 case String orderId when name.equals("cancelOrder") ->
-                    new RequestData("/api/orders/" + orderId, "");
-
+                new RequestData("/api/orders/" + orderId, "");
                 case DataGenerator.StockCheckGenerator.StockCheckData stock ->
-                    new RequestData("/api/inventory/" + stock.productId(), "");
-
+                new RequestData("/api/inventory/" + stock.productId(), "");
                 case DataGenerator.PriceCheckGenerator.PriceCheckData price ->
-                    new RequestData("/api/pricing/" + price.productId(), "");
-
+                new RequestData("/api/pricing/" + price.productId(), "");
                 case String productId ->
-                    new RequestData(pathPattern.replace("{id}", productId), "");
-
+                new RequestData(pathPattern.replace("{id}", productId), "");
                 default ->
-                    new RequestData(pathPattern, "");
+                new RequestData(pathPattern, "");
             };
         }
 
@@ -396,7 +368,6 @@ void setRate(int rate) {
 
         void rampUp(int target, long durationMs) {
             targetRate.set(target);
-            // Rate adjustment happens in adjustRate()
         }
 
         int currentRate() {
@@ -410,22 +381,20 @@ int targetRate() {
         void adjustRate() {
             var current = currentRate.get();
             var target = targetRate.get();
-
             if (current == target) {
                 return;
             }
-
             // Adjust by 10% toward target
             var delta = (target - current) / 10;
             if (delta == 0) {
-                delta = target > current ? 1 : -1;
+                delta = target > current
+                        ? 1
+                        : - 1;
             }
-
             var newRate = current + delta;
             if ((delta > 0 && newRate > target) || (delta < 0 && newRate < target)) {
                 newRate = target;
             }
-
             currentRate.set(newRate);
         }
     }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/LocalSliceInvoker.java b/forge/src/main/java/org/pragmatica/aether/forge/LocalSliceInvoker.java
index 755588dc..0586e8af 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/LocalSliceInvoker.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/LocalSliceInvoker.java
@@ -10,12 +10,13 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.lang.Unit.unit;
 
 /**
@@ -26,7 +27,7 @@ public final class LocalSliceInvoker implements SliceInvoker {
     private static final Logger log = LoggerFactory.getLogger(LocalSliceInvoker.class);
 
     private final Map<Artifact, Slice> slices = new ConcurrentHashMap<>();
-    private final Map<String, SliceMethod<?, ?>> methodCache = new ConcurrentHashMap<>();
+    private final Map<String, SliceMethod< ? , ? >> methodCache = new ConcurrentHashMap<>();
 
     public static LocalSliceInvoker localSliceInvoker() {
         return new LocalSliceInvoker();
@@ -35,7 +36,8 @@ public static LocalSliceInvoker localSliceInvoker() {
     public void register(Artifact artifact, Slice slice) {
         slices.put(artifact, slice);
         for (var method : slice.methods()) {
-            var key = artifact.asString() + ":" + method.name().name();
+            var key = artifact.asString() + ":" + method.name()
+                                                       .name();
             methodCache.put(key, method);
         }
         log.info("Registered slice: {}", artifact.asString());
@@ -44,7 +46,7 @@ public void register(Artifact artifact, Slice slice) {
     @Override
     public Promise<Unit> invoke(Artifact slice, MethodName method, Object request) {
         return invokeAndWait(slice, method, request, Object.class)
-            .map(_ -> unit());
+               .map(_ -> unit());
     }
 
     @Override
@@ -52,22 +54,26 @@ public Promise<Unit> invoke(Artifact slice, MethodName method, Object request) {
     public <R> Promise<R> invokeAndWait(Artifact slice, MethodName method, Object request, Class<R> responseType) {
         var key = slice.asString() + ":" + method.name();
         var sliceMethod = (SliceMethod<R, Object>) methodCache.get(key);
-
         if (sliceMethod == null) {
             log.warn("Slice method not found: {}.{}", slice.asString(), method.name());
-            return Causes.cause("Slice method not found: " + slice.asString() + "." + method.name()).promise();
+            return Causes.cause("Slice method not found: " + slice.asString() + "." + method.name())
+                         .promise();
         }
-
-        try {
+        try{
             return sliceMethod.apply(request);
         } catch (Exception e) {
             log.error("Error invoking {}.{}: {}", slice.asString(), method.name(), e.getMessage());
-            return Causes.fromThrowable(e).promise();
+            return Causes.fromThrowable(e)
+                         .promise();
         }
     }
 
     @Override
-    public <R> Promise<R> invokeWithRetry(Artifact slice, MethodName method, Object request, Class<R> responseType, int maxRetries) {
+    public <R> Promise<R> invokeWithRetry(Artifact slice,
+                                          MethodName method,
+                                          Object request,
+                                          Class<R> responseType,
+                                          int maxRetries) {
         // No retry needed for local calls
         return invokeAndWait(slice, method, request, responseType);
     }
@@ -78,9 +84,7 @@ public <R> Promise<R> invokeLocal(Artifact slice, MethodName method, Object requ
     }
 
     @Override
-    public void onInvokeResponse(InvokeResponse response) {
-        // Not used for local invocations
-    }
+    public void onInvokeResponse(InvokeResponse response) {}
 
     @Override
     public Promise<Unit> stop() {
@@ -91,7 +95,7 @@ public Promise<Unit> stop() {
 
     @Override
     public int pendingCount() {
-        return 0; // Local invocations are synchronous
+        return 0;
     }
 
     public int sliceCount() {
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/StaticFileHandler.java b/forge/src/main/java/org/pragmatica/aether/forge/StaticFileHandler.java
index 2b9ba878..3300709c 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/StaticFileHandler.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/StaticFileHandler.java
@@ -1,5 +1,11 @@
 package org.pragmatica.aether.forge;
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URLDecoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandler.Sharable;
@@ -9,12 +15,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.net.URLDecoder;
-import java.nio.charset.StandardCharsets;
-import java.util.Map;
-
 import static io.netty.handler.codec.http.HttpResponseStatus.*;
 import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
 
@@ -26,15 +26,21 @@ public final class StaticFileHandler extends SimpleChannelInboundHandler<FullHtt
     private static final Logger log = LoggerFactory.getLogger(StaticFileHandler.class);
 
     private static final String STATIC_PREFIX = "static/";
-    private static final Map<String, String> CONTENT_TYPES = Map.of(
-            ".html", "text/html; charset=utf-8",
-            ".css", "text/css; charset=utf-8",
-            ".js", "application/javascript; charset=utf-8",
-            ".json", "application/json; charset=utf-8",
-            ".png", "image/png",
-            ".svg", "image/svg+xml",
-            ".ico", "image/x-icon"
-    );
+    private static final Map<String, String>CONTENT_TYPES = Map.of(
+    ".html",
+    "text/html; charset=utf-8",
+    ".css",
+    "text/css; charset=utf-8",
+    ".js",
+    "application/javascript; charset=utf-8",
+    ".json",
+    "application/json; charset=utf-8",
+    ".png",
+    "image/png",
+    ".svg",
+    "image/svg+xml",
+    ".ico",
+    "image/x-icon");
 
     private StaticFileHandler() {}
 
@@ -45,52 +51,52 @@ public static StaticFileHandler staticFileHandler() {
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
         var path = request.uri();
-
         // Handle root path
         if (path.equals("/") || path.equals("/index.html")) {
             path = "/index.html";
         }
-
         // Remove query string
         var queryIdx = path.indexOf('?');
         if (queryIdx >= 0) {
             path = path.substring(0, queryIdx);
         }
-
         // Decode URL before security check to prevent bypass via percent-encoding
         path = URLDecoder.decode(path, StandardCharsets.UTF_8);
-
         // Security: prevent directory traversal
         if (path.contains("..")) {
             sendError(ctx, FORBIDDEN, "Invalid path");
             return;
         }
-
         // Load from classpath
-        var resourcePath = STATIC_PREFIX + (path.startsWith("/") ? path.substring(1) : path);
+        var resourcePath = STATIC_PREFIX + (path.startsWith("/")
+                                            ? path.substring(1)
+                                            : path);
         var content = loadResource(resourcePath);
-
         if (content == null) {
             log.debug("Static file not found: {}", resourcePath);
             sendError(ctx, NOT_FOUND, "File not found: " + path);
             return;
         }
-
         // Determine content type
         var contentType = getContentType(path);
-
         // Send response
         var buffer = Unpooled.wrappedBuffer(content);
         var response = new DefaultFullHttpResponse(HTTP_1_1, OK, buffer);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType);
-        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, buffer.readableBytes());
-        response.headers().set(HttpHeaderNames.CACHE_CONTROL, "no-cache");
-
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, contentType);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_LENGTH,
+                     buffer.readableBytes());
+        response.headers()
+                .set(HttpHeaderNames.CACHE_CONTROL, "no-cache");
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     private byte[] loadResource(String path) {
-        try (InputStream is = getClass().getClassLoader().getResourceAsStream(path)) {
+        try (InputStream is = getClass()
+                              .getClassLoader()
+                              .getResourceAsStream(path)) {
             if (is == null) {
                 return null;
             }
@@ -113,9 +119,13 @@ private String getContentType(String path) {
     private void sendError(ChannelHandlerContext ctx, HttpResponseStatus status, String message) {
         var content = Unpooled.copiedBuffer(message, StandardCharsets.UTF_8);
         var response = new DefaultFullHttpResponse(HTTP_1_1, status, content);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=utf-8");
-        response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=utf-8");
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_LENGTH,
+                     content.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     @Override
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/BackendSimulation.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/BackendSimulation.java
index 62fc19dd..3bfe78b4 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/BackendSimulation.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/BackendSimulation.java
@@ -16,7 +16,6 @@
  * Used to test system resilience and behavior under various conditions.
  */
 public sealed interface BackendSimulation {
-
     /**
      * Thread counter for unique naming.
      */
@@ -25,24 +24,27 @@ public sealed interface BackendSimulation {
     /**
      * Shared scheduler for latency simulation.
      */
-    ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(2, r -> {
-        var t = new Thread(r, "backend-simulation-" + THREAD_COUNTER.incrementAndGet());
-        t.setDaemon(true);
-        return t;
-    });
+    ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(2,
+                                                                          r -> {
+                                                                              var t = new Thread(r,
+                                                                                                 "backend-simulation-" + THREAD_COUNTER.incrementAndGet());
+                                                                              t.setDaemon(true);
+                                                                              return t;
+                                                                          });
 
     /**
      * Shutdown the scheduler. Should be called on application shutdown.
      */
     static void shutdown() {
         SCHEDULER.shutdown();
-        try {
+        try{
             if (!SCHEDULER.awaitTermination(5, TimeUnit.SECONDS)) {
                 SCHEDULER.shutdownNow();
             }
         } catch (InterruptedException e) {
             SCHEDULER.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
@@ -69,12 +71,10 @@ public Promise<Unit> apply() {
      * Simulates network/processing latency with optional jitter and spikes.
      */
     record LatencySimulation(
-        long baseLatencyMs,
-        long jitterMs,
-        double spikeChance,
-        long spikeLatencyMs
-    ) implements BackendSimulation {
-
+    long baseLatencyMs,
+    long jitterMs,
+    double spikeChance,
+    long spikeLatencyMs) implements BackendSimulation {
         public LatencySimulation {
             if (baseLatencyMs < 0) {
                 throw new IllegalArgumentException("baseLatencyMs must be >= 0");
@@ -94,27 +94,20 @@ record LatencySimulation(
         public Promise<Unit> apply() {
             var random = ThreadLocalRandom.current();
             var delay = baseLatencyMs;
-
             if (jitterMs > 0) {
                 delay += random.nextLong(jitterMs);
             }
-
             if (spikeChance > 0 && random.nextDouble() < spikeChance) {
                 delay += spikeLatencyMs;
             }
-
             if (delay <= 0) {
                 return Promise.success(Unit.unit());
             }
-
             final var finalDelay = delay;
-            return Promise.<Unit>promise(p ->
-                SCHEDULER.schedule(
-                    () -> p.succeed(Unit.unit()),
-                    finalDelay,
-                    TimeUnit.MILLISECONDS
-                )
-            );
+            return Promise.<Unit>promise(p -> SCHEDULER.schedule(
+            () -> p.succeed(Unit.unit()),
+            finalDelay,
+            TimeUnit.MILLISECONDS));
         }
 
         public static LatencySimulation fixed(long latencyMs) {
@@ -134,10 +127,8 @@ public static LatencySimulation withSpikes(long baseMs, long jitterMs, double sp
      * Simulates random failures at a configurable rate.
      */
     record FailureInjection(
-        double failureRate,
-        List<SimulatedError> errorTypes
-    ) implements BackendSimulation {
-
+    double failureRate,
+    List<SimulatedError> errorTypes) implements BackendSimulation {
         public FailureInjection {
             if (failureRate < 0 || failureRate > 1) {
                 throw new IllegalArgumentException("failureRate must be between 0 and 1");
@@ -151,12 +142,10 @@ record FailureInjection(
         @Override
         public Promise<Unit> apply() {
             var random = ThreadLocalRandom.current();
-
             if (random.nextDouble() < failureRate) {
                 var error = errorTypes.get(random.nextInt(errorTypes.size()));
                 return error.promise();
             }
-
             return Promise.success(Unit.unit());
         }
 
@@ -170,7 +159,6 @@ public static FailureInjection withRate(double rate, SimulatedError... errors) {
      * Latency simulations are applied sequentially (delays add up).
      */
     record Composite(List<BackendSimulation> simulations) implements BackendSimulation {
-
         public Composite {
             if (simulations == null || simulations.isEmpty()) {
                 throw new IllegalArgumentException("simulations cannot be null or empty");
@@ -181,11 +169,9 @@ record Composite(List<BackendSimulation> simulations) implements BackendSimulati
         @Override
         public Promise<Unit> apply() {
             var result = Promise.success(Unit.unit());
-
             for (var simulation : simulations) {
                 result = result.flatMap(_ -> simulation.apply());
             }
-
             return result;
         }
 
@@ -198,7 +184,6 @@ public static Composite of(BackendSimulation... simulations) {
      * Simulated error types for failure injection.
      */
     sealed interface SimulatedError extends Cause {
-
         record ServiceUnavailable(String serviceName) implements SimulatedError {
             @Override
             public String message() {
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosController.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosController.java
index c27b4207..e2b1e347 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosController.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosController.java
@@ -2,8 +2,6 @@
 
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.time.Duration;
 import java.time.Instant;
@@ -14,6 +12,9 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Controller for chaos engineering experiments.
  * Injects failures and disruptions to test system resilience.
@@ -24,17 +25,17 @@ public final class ChaosController {
 
     private final AtomicBoolean enabled = new AtomicBoolean(false);
     private final Map<String, ActiveChaosEvent> activeEvents = new ConcurrentHashMap<>();
-    private final Map<String, ScheduledFuture<?>> scheduledTasks = new ConcurrentHashMap<>();
+    private final Map<String, ScheduledFuture< ? >> scheduledTasks = new ConcurrentHashMap<>();
     private final ScheduledExecutorService scheduler;
     private final Consumer<ChaosEvent> eventExecutor;
 
     private ChaosController(Consumer<ChaosEvent> eventExecutor) {
         this.eventExecutor = eventExecutor;
         this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-            var t = new Thread(r, "chaos-controller");
-            t.setDaemon(true);
-            return t;
-        });
+                                                                        var t = new Thread(r, "chaos-controller");
+                                                                        t.setDaemon(true);
+                                                                        return t;
+                                                                    });
     }
 
     public static ChaosController chaosController(Consumer<ChaosEvent> eventExecutor) {
@@ -46,8 +47,9 @@ public static ChaosController chaosController(Consumer<ChaosEvent> eventExecutor
      */
     public void setEnabled(boolean enabled) {
         this.enabled.set(enabled);
-        log.info("Chaos controller {}", enabled ? "enabled" : "disabled");
-
+        log.info("Chaos controller {}", enabled
+                                       ? "enabled"
+                                       : "disabled");
         if (!enabled) {
             stopAllChaos();
         }
@@ -68,38 +70,37 @@ public Promise<String> injectChaos(ChaosEvent event) {
             log.warn("Chaos injection attempted but controller is disabled");
             return Promise.success("disabled");
         }
-
-        var eventId = UUID.randomUUID().toString().substring(0, EVENT_ID_LENGTH);
+        var eventId = UUID.randomUUID()
+                          .toString()
+                          .substring(0, EVENT_ID_LENGTH);
         var activeEvent = new ActiveChaosEvent(eventId, event, Instant.now());
-
         // Use putIfAbsent and verify still enabled after insertion (race condition fix)
         if (activeEvents.putIfAbsent(eventId, activeEvent) != null) {
             return Promise.success("disabled");
         }
-
         // Double-check enabled after map insertion
         if (!enabled.get()) {
             activeEvents.remove(eventId);
             return Promise.success("disabled");
         }
-
         log.info("Injecting chaos event {}: {}", eventId, event.description());
-
-        try {
+        try{
             eventExecutor.accept(event);
         } catch (Exception e) {
             log.error("Failed to execute chaos event {}: {}", eventId, e.getMessage());
             activeEvents.remove(eventId);
             return ChaosError.ExecutionFailed.INSTANCE.promise();
         }
-
         // Schedule removal after duration, track the future for cancellation
-        if (event.duration() != null && !event.duration().isZero() && !event.duration().isNegative()) {
+        if (event.duration() != null && !event.duration()
+                                              .isZero() && !event.duration()
+                                                                 .isNegative()) {
             var future = scheduler.schedule(() -> stopChaos(eventId),
-                event.duration().toMillis(), TimeUnit.MILLISECONDS);
+                                            event.duration()
+                                                 .toMillis(),
+                                            TimeUnit.MILLISECONDS);
             scheduledTasks.put(eventId, future);
         }
-
         return Promise.success(eventId);
     }
 
@@ -113,7 +114,10 @@ public Promise<Unit> stopChaos(String eventId) {
             future.cancel(false);
         }
         if (event != null) {
-            log.info("Stopping chaos event {}: {}", eventId, event.event().description());
+            log.info("Stopping chaos event {}: {}",
+                     eventId,
+                     event.event()
+                          .description());
         }
         return Promise.success(Unit.unit());
     }
@@ -136,12 +140,11 @@ public String scheduleChaos(ChaosEvent event, Duration delay) {
             log.warn("Chaos scheduling attempted but controller is disabled");
             return "disabled";
         }
-
-        var scheduleId = "SCH-" + UUID.randomUUID().toString().substring(0, EVENT_ID_LENGTH);
+        var scheduleId = "SCH-" + UUID.randomUUID()
+                                     .toString()
+                                     .substring(0, EVENT_ID_LENGTH);
         log.info("Scheduling chaos event {} in {}: {}", scheduleId, delay, event.description());
-
         scheduler.schedule(() -> injectChaos(event), delay.toMillis(), TimeUnit.MILLISECONDS);
-
         return scheduleId;
     }
 
@@ -156,7 +159,9 @@ public List<ActiveChaosEvent> activeEvents() {
      * Get chaos controller status.
      */
     public ChaosStatus status() {
-        return new ChaosStatus(enabled.get(), activeEvents.size(), List.copyOf(activeEvents.values()));
+        return new ChaosStatus(enabled.get(),
+                               activeEvents.size(),
+                               List.copyOf(activeEvents.values()));
     }
 
     /**
@@ -165,13 +170,14 @@ public ChaosStatus status() {
     public void shutdown() {
         stopAllChaos();
         scheduler.shutdown();
-        try {
+        try{
             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                 scheduler.shutdownNow();
             }
         } catch (InterruptedException e) {
             scheduler.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
@@ -179,19 +185,20 @@ public void shutdown() {
      * Active chaos event with metadata.
      */
     public record ActiveChaosEvent(
-        String eventId,
-        ChaosEvent event,
-        Instant startedAt
-    ) {
+    String eventId,
+    ChaosEvent event,
+    Instant startedAt) {
         public String toJson() {
             return String.format(
-                "{\"eventId\":\"%s\",\"type\":\"%s\",\"description\":\"%s\",\"startedAt\":\"%s\",\"duration\":\"%s\"}",
-                eventId,
-                event.type(),
-                event.description(),
-                startedAt,
-                event.duration() != null ? event.duration().toSeconds() + "s" : "indefinite"
-            );
+            "{\"eventId\":\"%s\",\"type\":\"%s\",\"description\":\"%s\",\"startedAt\":\"%s\",\"duration\":\"%s\"}",
+            eventId,
+            event.type(),
+            event.description(),
+            startedAt,
+            event.duration() != null
+            ? event.duration()
+                   .toSeconds() + "s"
+            : "indefinite");
         }
     }
 
@@ -199,10 +206,9 @@ public String toJson() {
      * Chaos controller status.
      */
     public record ChaosStatus(
-        boolean enabled,
-        int activeEventCount,
-        List<ActiveChaosEvent> activeEvents
-    ) {
+    boolean enabled,
+    int activeEventCount,
+    List<ActiveChaosEvent> activeEvents) {
         public String toJson() {
             var eventsJson = new StringBuilder("[");
             var first = true;
@@ -212,11 +218,8 @@ public String toJson() {
                 eventsJson.append(event.toJson());
             }
             eventsJson.append("]");
-
             return String.format(
-                "{\"enabled\":%b,\"activeEventCount\":%d,\"activeEvents\":%s}",
-                enabled, activeEventCount, eventsJson
-            );
+            "{\"enabled\":%b,\"activeEventCount\":%d,\"activeEvents\":%s}", enabled, activeEventCount, eventsJson);
         }
     }
 
@@ -226,6 +229,7 @@ public String toJson() {
     public sealed interface ChaosError extends org.pragmatica.lang.Cause {
         record ExecutionFailed() implements ChaosError {
             public static final ExecutionFailed INSTANCE = new ExecutionFailed();
+
             @Override
             public String message() {
                 return "Failed to execute chaos event";
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosEvent.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosEvent.java
index f13b0679..a524583e 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosEvent.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/ChaosEvent.java
@@ -7,7 +7,6 @@
  * Chaos events that can be injected into the system for resilience testing.
  */
 public sealed interface ChaosEvent {
-
     /**
      * Type identifier for the event.
      */
@@ -122,7 +121,9 @@ public String type() {
 
         @Override
         public String description() {
-            var target = nodeId != null ? " on node " + nodeId : " on all nodes";
+            var target = nodeId != null
+                         ? " on node " + nodeId
+                         : " on all nodes";
             return "Crash slice " + sliceArtifact + target;
         }
 
@@ -208,7 +209,9 @@ public String type() {
 
         @Override
         public String description() {
-            var target = sliceArtifact != null ? sliceArtifact : "all slices";
+            var target = sliceArtifact != null
+                         ? sliceArtifact
+                         : "all slices";
             return String.format("Inject %.0f%% failure rate for %s", failureRate * 100, target);
         }
 
@@ -241,7 +244,9 @@ public String type() {
 
         @Override
         public String description() {
-            return description != null ? description : name;
+            return description != null
+                   ? description
+                   : name;
         }
 
         public static CustomChaos custom(String name, String description, Runnable action, Duration duration) {
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/DataGenerator.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/DataGenerator.java
index 2f8d08d1..50b24d97 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/DataGenerator.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/DataGenerator.java
@@ -11,7 +11,6 @@
  * Each generator produces data appropriate for a specific entry point type.
  */
 public sealed interface DataGenerator {
-
     /**
      * Generate test data.
      *
@@ -100,11 +99,9 @@ public static CustomerIdGenerator withDefaults() {
      * Generates order request data for placeOrder entry point.
      */
     record OrderRequestGenerator(
-        ProductIdGenerator productGenerator,
-        CustomerIdGenerator customerGenerator,
-        IntRange quantityRange
-    ) implements DataGenerator {
-
+    ProductIdGenerator productGenerator,
+    CustomerIdGenerator customerGenerator,
+    IntRange quantityRange) implements DataGenerator {
         public OrderRequestGenerator {
             if (productGenerator == null || customerGenerator == null || quantityRange == null) {
                 throw new IllegalArgumentException("All generators must be non-null");
@@ -114,18 +111,12 @@ record OrderRequestGenerator(
         @Override
         public OrderRequestData generate(Random random) {
             return new OrderRequestData(
-                customerGenerator.generate(random),
-                productGenerator.generate(random),
-                quantityRange.random(random)
-            );
+            customerGenerator.generate(random), productGenerator.generate(random), quantityRange.random(random));
         }
 
         public static OrderRequestGenerator withDefaults() {
             return new OrderRequestGenerator(
-                ProductIdGenerator.withDefaults(),
-                CustomerIdGenerator.withDefaults(),
-                IntRange.of(1, 5)
-            );
+            ProductIdGenerator.withDefaults(), CustomerIdGenerator.withDefaults(), IntRange.of(1, 5));
         }
 
         /**
@@ -134,9 +125,10 @@ public static OrderRequestGenerator withDefaults() {
         public record OrderRequestData(String customerId, String productId, int quantity) {
             public String toJson() {
                 return String.format(
-                    "{\"customerId\":\"%s\",\"items\":[{\"productId\":\"%s\",\"quantity\":%d}]}",
-                    customerId, productId, quantity
-                );
+                "{\"customerId\":\"%s\",\"items\":[{\"productId\":\"%s\",\"quantity\":%d}]}",
+                customerId,
+                productId,
+                quantity);
             }
         }
     }
@@ -147,7 +139,7 @@ public String toJson() {
      * Thread-safe for concurrent load generation.
      */
     record OrderIdGenerator(Queue<String> orderIdPool, int maxPoolSize) implements DataGenerator {
-        private static final Queue<String> SHARED_POOL = new ConcurrentLinkedQueue<>();
+        private static final Queue<String>SHARED_POOL = new ConcurrentLinkedQueue<>();
         private static final int DEFAULT_MAX_POOL_SIZE = 1000;
 
         public OrderIdGenerator {
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/EntryPointMetrics.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/EntryPointMetrics.java
index c3ead291..7e56fb27 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/EntryPointMetrics.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/EntryPointMetrics.java
@@ -14,7 +14,6 @@
  * Designed for high-throughput concurrent access.
  */
 public final class EntryPointMetrics {
-
     /**
      * Histogram bucket boundaries in milliseconds.
      */
@@ -33,21 +32,24 @@ public static EntryPointMetrics entryPointMetrics() {
      * Record a successful invocation.
      */
     public void recordSuccess(String entryPoint, long latencyNanos) {
-        getOrCreate(entryPoint).recordSuccess(latencyNanos);
+        getOrCreate(entryPoint)
+        .recordSuccess(latencyNanos);
     }
 
     /**
      * Record a failed invocation.
      */
     public void recordFailure(String entryPoint, long latencyNanos) {
-        getOrCreate(entryPoint).recordFailure(latencyNanos);
+        getOrCreate(entryPoint)
+        .recordFailure(latencyNanos);
     }
 
     /**
      * Set the current rate for an entry point.
      */
     public void setRate(String entryPoint, int callsPerSecond) {
-        getOrCreate(entryPoint).currentRate.set(callsPerSecond);
+        getOrCreate(entryPoint).currentRate
+        .set(callsPerSecond);
     }
 
     /**
@@ -57,7 +59,6 @@ public List<EntryPointSnapshot> snapshotAndReset() {
         var now = System.currentTimeMillis();
         var elapsedMs = now - lastSnapshotTime;
         lastSnapshotTime = now;
-
         var result = new ArrayList<EntryPointSnapshot>();
         stats.forEach((name, stat) -> result.add(stat.snapshotAndReset(name, elapsedMs)));
         return result;
@@ -69,7 +70,6 @@ public List<EntryPointSnapshot> snapshotAndReset() {
     public List<EntryPointSnapshot> snapshot() {
         var now = System.currentTimeMillis();
         var elapsedMs = now - lastSnapshotTime;
-
         var result = new ArrayList<EntryPointSnapshot>();
         stats.forEach((name, stat) -> result.add(stat.snapshot(name, elapsedMs)));
         return result;
@@ -79,7 +79,8 @@ public List<EntryPointSnapshot> snapshot() {
      * Reset all metrics.
      */
     public void reset() {
-        stats.values().forEach(EntryPointStats::reset);
+        stats.values()
+             .forEach(EntryPointStats::reset);
         lastSnapshotTime = System.currentTimeMillis();
     }
 
@@ -105,7 +106,7 @@ private static final class EntryPointStats {
         final AtomicLong[] histogram = new AtomicLong[BUCKET_BOUNDARIES_MS.length + 1];
 
         EntryPointStats() {
-            for (int i = 0; i < histogram.length; i++) {
+            for (int i = 0; i < histogram.length; i++ ) {
                 histogram[i] = new AtomicLong();
             }
         }
@@ -135,7 +136,7 @@ private void recordLatency(long latencyNanos) {
         }
 
         private int findBucket(long latencyMs) {
-            for (int i = 0; i < BUCKET_BOUNDARIES_MS.length; i++) {
+            for (int i = 0; i < BUCKET_BOUNDARIES_MS.length; i++ ) {
                 if (latencyMs <= BUCKET_BOUNDARIES_MS[i]) {
                     return i;
                 }
@@ -157,29 +158,32 @@ EntryPointSnapshot snapshot(String name, long elapsedMs) {
             var windowCnt = windowCount.get();
             var windowLatency = windowLatencyNanos.get();
             var rate = currentRate.get();
-
-            var successRate = total > 0 ? (success * 100.0 / total) : 100.0;
-            var avgLatencyMs = windowCnt > 0 ? (windowLatency / windowCnt) / 1_000_000.0 : 0.0;
-            var rps = elapsedMs > 0 ? (windowCnt * 1000.0 / elapsedMs) : 0.0;
+            var successRate = total > 0
+                              ? (success * 100.0 / total)
+                              : 100.0;
+            var avgLatencyMs = windowCnt > 0
+                               ? (windowLatency / windowCnt) / 1_000_000.0
+                               : 0.0;
+            var rps = elapsedMs > 0
+                      ? (windowCnt * 1000.0 / elapsedMs)
+                      : 0.0;
             var p50 = estimatePercentile(50, total);
             var p99 = estimatePercentile(99, total);
-
             return new EntryPointSnapshot(
-                name, rate, total, success, failure, successRate, avgLatencyMs, rps, p50, p99
-            );
+            name, rate, total, success, failure, successRate, avgLatencyMs, rps, p50, p99);
         }
 
         private double estimatePercentile(int percentile, long total) {
             if (total == 0) return 0.0;
-
-            var targetCount = (long) (total * percentile / 100.0);
+            var targetCount = (long)(total * percentile / 100.0);
             long cumulative = 0;
-
-            for (int i = 0; i < histogram.length; i++) {
+            for (int i = 0; i < histogram.length; i++ ) {
                 cumulative += histogram[i].get();
                 if (cumulative >= targetCount) {
                     // Return bucket upper boundary
-                    return i < BUCKET_BOUNDARIES_MS.length ? BUCKET_BOUNDARIES_MS[i] : 10000.0;
+                    return i < BUCKET_BOUNDARIES_MS.length
+                           ? BUCKET_BOUNDARIES_MS[i]
+                           : 10000.0;
                 }
             }
             return 10000.0;
@@ -202,25 +206,31 @@ void reset() {
      * Snapshot of entry point metrics.
      */
     public record EntryPointSnapshot(
-        String name,
-        int rate,
-        long totalCalls,
-        long successCalls,
-        long failureCalls,
-        double successRate,
-        double avgLatencyMs,
-        double requestsPerSecond,
-        double p50LatencyMs,
-        double p99LatencyMs
-    ) {
+    String name,
+    int rate,
+    long totalCalls,
+    long successCalls,
+    long failureCalls,
+    double successRate,
+    double avgLatencyMs,
+    double requestsPerSecond,
+    double p50LatencyMs,
+    double p99LatencyMs) {
         public String toJson() {
             return String.format(
-                "{\"name\":\"%s\",\"rate\":%d,\"totalCalls\":%d,\"successCalls\":%d," +
-                "\"failureCalls\":%d,\"successRate\":%.2f,\"avgLatencyMs\":%.2f," +
-                "\"requestsPerSecond\":%.1f,\"p50LatencyMs\":%.1f,\"p99LatencyMs\":%.1f}",
-                name, rate, totalCalls, successCalls, failureCalls, successRate,
-                avgLatencyMs, requestsPerSecond, p50LatencyMs, p99LatencyMs
-            );
+            "{\"name\":\"%s\",\"rate\":%d,\"totalCalls\":%d,\"successCalls\":%d,"
+            + "\"failureCalls\":%d,\"successRate\":%.2f,\"avgLatencyMs\":%.2f,"
+            + "\"requestsPerSecond\":%.1f,\"p50LatencyMs\":%.1f,\"p99LatencyMs\":%.1f}",
+            name,
+            rate,
+            totalCalls,
+            successCalls,
+            failureCalls,
+            successRate,
+            avgLatencyMs,
+            requestsPerSecond,
+            p50LatencyMs,
+            p99LatencyMs);
         }
     }
 }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorConfig.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorConfig.java
index 1dc9e878..214a5716 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorConfig.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorConfig.java
@@ -3,8 +3,6 @@
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -14,6 +12,9 @@
 import java.util.Map;
 import java.util.regex.Pattern;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Configuration for the simulator.
  * <p>
@@ -21,11 +22,10 @@
  * Can be loaded from JSON file or constructed programmatically.
  */
 public record SimulatorConfig(
-    Map<String, EntryPointConfig> entryPoints,
-    Map<String, SliceConfig> slices,
-    boolean loadGeneratorEnabled,
-    double globalRateMultiplier
-) {
+ Map<String, EntryPointConfig> entryPoints,
+ Map<String, SliceConfig> slices,
+ boolean loadGeneratorEnabled,
+ double globalRateMultiplier) {
     private static final Logger log = LoggerFactory.getLogger(SimulatorConfig.class);
 
     /**
@@ -47,14 +47,13 @@ public record SimulatorConfig(
      * Configuration for a single entry point.
      */
     public record EntryPointConfig(
-        int callsPerSecond,
-        boolean enabled,
-        List<String> products,
-        List<String> customerIds,
-        int minQuantity,
-        int maxQuantity
-    ) {
-        private static final List<String> DEFAULT_PRODUCTS = List.of("PROD-ABC123", "PROD-DEF456", "PROD-GHI789");
+    int callsPerSecond,
+    boolean enabled,
+    List<String> products,
+    List<String> customerIds,
+    int minQuantity,
+    int maxQuantity) {
+        private static final List<String>DEFAULT_PRODUCTS = List.of("PROD-ABC123", "PROD-DEF456", "PROD-GHI789");
 
         public static EntryPointConfig defaultConfig() {
             return new EntryPointConfig(0, true, List.of(), List.of(), 1, 5);
@@ -68,7 +67,9 @@ public static EntryPointConfig withRate(int callsPerSecond) {
          * Get products list, using defaults if empty.
          */
         public List<String> effectiveProducts() {
-            return products.isEmpty() ? DEFAULT_PRODUCTS : products;
+            return products.isEmpty()
+                   ? DEFAULT_PRODUCTS
+                   : products;
         }
 
         /**
@@ -76,29 +77,39 @@ public List<String> effectiveProducts() {
          */
         public DataGenerator buildGenerator(String entryPointName) {
             var productGen = new DataGenerator.ProductIdGenerator(effectiveProducts());
-
             return switch (entryPointName) {
-                case "placeOrder" -> new DataGenerator.OrderRequestGenerator(
-                    productGen,
-                    DataGenerator.CustomerIdGenerator.withDefaults(),
-                    DataGenerator.IntRange.of(minQuantity, maxQuantity)
-                );
-                case "getOrderStatus", "cancelOrder" -> DataGenerator.OrderIdGenerator.withSharedPool();
-                case "checkStock" -> new DataGenerator.StockCheckGenerator(productGen);
-                case "getPrice" -> new DataGenerator.PriceCheckGenerator(productGen);
+                case"placeOrder" -> new DataGenerator.OrderRequestGenerator(
+                productGen,
+                DataGenerator.CustomerIdGenerator.withDefaults(),
+                DataGenerator.IntRange.of(minQuantity, maxQuantity));
+                case"getOrderStatus", "cancelOrder" -> DataGenerator.OrderIdGenerator.withSharedPool();
+                case"checkStock" -> new DataGenerator.StockCheckGenerator(productGen);
+                case"getPrice" -> new DataGenerator.PriceCheckGenerator(productGen);
                 default -> productGen;
             };
         }
 
         public String toJson() {
-            var productsJson = products.isEmpty() ? "[]" :
-                "[" + String.join(",", products.stream().map(p -> "\"" + p + "\"").toList()) + "]";
-            var customerIdsJson = customerIds.isEmpty() ? "[]" :
-                "[" + String.join(",", customerIds.stream().map(c -> "\"" + c + "\"").toList()) + "]";
+            var productsJson = products.isEmpty()
+                               ? "[]"
+                               : "[" + String.join(",",
+                                                   products.stream()
+                                                           .map(p -> "\"" + p + "\"")
+                                                           .toList()) + "]";
+            var customerIdsJson = customerIds.isEmpty()
+                                  ? "[]"
+                                  : "[" + String.join(",",
+                                                      customerIds.stream()
+                                                                 .map(c -> "\"" + c + "\"")
+                                                                 .toList()) + "]";
             return String.format(
-                "{\"callsPerSecond\":%d,\"enabled\":%b,\"products\":%s,\"customerIds\":%s,\"minQuantity\":%d,\"maxQuantity\":%d}",
-                callsPerSecond, enabled, productsJson, customerIdsJson, minQuantity, maxQuantity
-            );
+            "{\"callsPerSecond\":%d,\"enabled\":%b,\"products\":%s,\"customerIds\":%s,\"minQuantity\":%d,\"maxQuantity\":%d}",
+            callsPerSecond,
+            enabled,
+            productsJson,
+            customerIdsJson,
+            minQuantity,
+            maxQuantity);
         }
     }
 
@@ -106,14 +117,14 @@ public String toJson() {
      * Configuration for a slice.
      */
     public record SliceConfig(
-        String stockMode,  // "infinite" or "realistic"
-        int refillRate,
-        int baseLatencyMs,
-        int jitterMs,
-        double failureRate,
-        double spikeChance,
-        int spikeLatencyMs
-    ) {
+    String stockMode,
+    // "infinite" or "realistic"
+    int refillRate,
+    int baseLatencyMs,
+    int jitterMs,
+    double failureRate,
+    double spikeChance,
+    int spikeLatencyMs) {
         public SliceConfig {
             if (stockMode == null || (!stockMode.equals("infinite") && !stockMode.equals("realistic"))) {
                 throw new IllegalArgumentException("stockMode must be 'infinite' or 'realistic'");
@@ -145,38 +156,36 @@ public static SliceConfig defaultConfig() {
         public BackendSimulation buildSimulation() {
             var hasLatency = baseLatencyMs > 0 || jitterMs > 0;
             var hasFailure = failureRate > 0;
-
             if (!hasLatency && !hasFailure) {
                 return BackendSimulation.NoOp.INSTANCE;
             }
-
             if (hasLatency && hasFailure) {
                 return BackendSimulation.Composite.of(
-                    new BackendSimulation.LatencySimulation(baseLatencyMs, jitterMs, spikeChance, spikeLatencyMs),
-                    BackendSimulation.FailureInjection.withRate(
-                        failureRate,
-                        new BackendSimulation.SimulatedError.ServiceUnavailable("backend"),
-                        new BackendSimulation.SimulatedError.Timeout("operation", 5000)
-                    )
-                );
+                new BackendSimulation.LatencySimulation(baseLatencyMs, jitterMs, spikeChance, spikeLatencyMs),
+                BackendSimulation.FailureInjection.withRate(
+                failureRate,
+                new BackendSimulation.SimulatedError.ServiceUnavailable("backend"),
+                new BackendSimulation.SimulatedError.Timeout("operation", 5000)));
             }
-
             if (hasLatency) {
                 return new BackendSimulation.LatencySimulation(baseLatencyMs, jitterMs, spikeChance, spikeLatencyMs);
             }
-
             return BackendSimulation.FailureInjection.withRate(
-                failureRate,
-                new BackendSimulation.SimulatedError.ServiceUnavailable("backend"),
-                new BackendSimulation.SimulatedError.Timeout("operation", 5000)
-            );
+            failureRate,
+            new BackendSimulation.SimulatedError.ServiceUnavailable("backend"),
+            new BackendSimulation.SimulatedError.Timeout("operation", 5000));
         }
 
         public String toJson() {
             return String.format(
-                "{\"stockMode\":\"%s\",\"refillRate\":%d,\"baseLatencyMs\":%d,\"jitterMs\":%d,\"failureRate\":%.4f,\"spikeChance\":%.4f,\"spikeLatencyMs\":%d}",
-                stockMode, refillRate, baseLatencyMs, jitterMs, failureRate, spikeChance, spikeLatencyMs
-            );
+            "{\"stockMode\":\"%s\",\"refillRate\":%d,\"baseLatencyMs\":%d,\"jitterMs\":%d,\"failureRate\":%.4f,\"spikeChance\":%.4f,\"spikeLatencyMs\":%d}",
+            stockMode,
+            refillRate,
+            baseLatencyMs,
+            jitterMs,
+            failureRate,
+            spikeChance,
+            spikeLatencyMs);
         }
     }
 
@@ -185,20 +194,16 @@ public String toJson() {
      */
     public static SimulatorConfig defaultConfig() {
         var entryPoints = new HashMap<String, EntryPointConfig>();
-        entryPoints.put("placeOrder", new EntryPointConfig(
-            500, true,
-            List.of("PROD-ABC123", "PROD-DEF456", "PROD-GHI789"),
-            List.of(), 1, 5
-        ));
+        entryPoints.put("placeOrder",
+                        new EntryPointConfig(
+        500, true, List.of("PROD-ABC123", "PROD-DEF456", "PROD-GHI789"), List.of(), 1, 5));
         entryPoints.put("getOrderStatus", EntryPointConfig.withRate(0));
         entryPoints.put("cancelOrder", EntryPointConfig.withRate(0));
         entryPoints.put("checkStock", EntryPointConfig.withRate(0));
         entryPoints.put("getPrice", EntryPointConfig.withRate(0));
-
         var slices = new HashMap<String, SliceConfig>();
         slices.put("inventory-service", SliceConfig.defaultConfig());
         slices.put("pricing-service", SliceConfig.defaultConfig());
-
         return new SimulatorConfig(entryPoints, slices, true, 1.0);
     }
 
@@ -222,7 +227,7 @@ public SliceConfig sliceConfig(String name) {
     public int effectiveRate(String entryPoint) {
         var config = entryPointConfig(entryPoint);
         if (!config.enabled()) return 0;
-        return (int) (config.callsPerSecond() * globalRateMultiplier);
+        return (int)(config.callsPerSecond() * globalRateMultiplier);
     }
 
     /**
@@ -231,10 +236,14 @@ public int effectiveRate(String entryPoint) {
     public SimulatorConfig withEntryPointRate(String entryPoint, int rate) {
         var newEntryPoints = new HashMap<>(entryPoints);
         var existing = entryPointConfig(entryPoint);
-        newEntryPoints.put(entryPoint, new EntryPointConfig(
-            rate, existing.enabled(), existing.products(), existing.customerIds(),
-            existing.minQuantity(), existing.maxQuantity()
-        ));
+        newEntryPoints.put(entryPoint,
+                           new EntryPointConfig(
+        rate,
+        existing.enabled(),
+        existing.products(),
+        existing.customerIds(),
+        existing.minQuantity(),
+        existing.maxQuantity()));
         return new SimulatorConfig(newEntryPoints, slices, loadGeneratorEnabled, globalRateMultiplier);
     }
 
@@ -258,27 +267,32 @@ public SimulatorConfig withLoadGeneratorEnabled(boolean enabled) {
     public String toJson() {
         var sb = new StringBuilder();
         sb.append("{\"entryPoints\":{");
-
         var first = true;
         for (var entry : entryPoints.entrySet()) {
             if (!first) sb.append(",");
             first = false;
-            sb.append("\"").append(entry.getKey()).append("\":").append(entry.getValue().toJson());
+            sb.append("\"")
+              .append(entry.getKey())
+              .append("\":")
+              .append(entry.getValue()
+                           .toJson());
         }
-
         sb.append("},\"slices\":{");
-
         first = true;
         for (var entry : slices.entrySet()) {
             if (!first) sb.append(",");
             first = false;
-            sb.append("\"").append(entry.getKey()).append("\":").append(entry.getValue().toJson());
+            sb.append("\"")
+              .append(entry.getKey())
+              .append("\":")
+              .append(entry.getValue()
+                           .toJson());
         }
-
-        sb.append("},\"loadGeneratorEnabled\":").append(loadGeneratorEnabled);
-        sb.append(",\"globalRateMultiplier\":").append(globalRateMultiplier);
+        sb.append("},\"loadGeneratorEnabled\":")
+          .append(loadGeneratorEnabled);
+        sb.append(",\"globalRateMultiplier\":")
+          .append(globalRateMultiplier);
         sb.append("}");
-
         return sb.toString();
     }
 
@@ -287,9 +301,7 @@ public String toJson() {
      */
     public static Result<SimulatorConfig> loadFromFile(Path path) {
         return Result.lift(
-            Causes.forOneValue("Failed to load config from " + path),
-            () -> parseJson(Files.readString(path))
-        );
+        Causes.forOneValue("Failed to load config from " + path), () -> parseJson(Files.readString(path)));
     }
 
     /**
@@ -300,10 +312,11 @@ public static SimulatorConfig loadOrDefault(Path path) {
             log.info("Config file not found at {}, using defaults", path);
             return defaultConfig();
         }
-
         return loadFromFile(path)
-            .onFailure(cause -> log.warn("Failed to load config: {}, using defaults", cause.message()))
-            .fold(_ -> defaultConfig(), config -> config);
+               .onFailure(cause -> log.warn("Failed to load config: {}, using defaults",
+                                            cause.message()))
+               .fold(_ -> defaultConfig(),
+                     config -> config);
     }
 
     /**
@@ -313,23 +326,24 @@ public static SimulatorConfig parseJson(String json) {
         var config = defaultConfig();
         var entryPoints = new HashMap<>(config.entryPoints());
         var slices = new HashMap<>(config.slices());
-
         // Parse entry point rates using regex (simple approach)
         var entryPointPattern = Pattern.compile("\"(\\w+)\"\\s*:\\s*\\{[^}]*\"callsPerSecond\"\\s*:\\s*(\\d+)");
         var matcher = entryPointPattern.matcher(json);
-
         while (matcher.find()) {
             var name = matcher.group(1);
             var rate = Integer.parseInt(matcher.group(2));
             if (entryPoints.containsKey(name)) {
                 var existing = entryPoints.get(name);
-                entryPoints.put(name, new EntryPointConfig(
-                    rate, existing.enabled(), existing.products(), existing.customerIds(),
-                    existing.minQuantity(), existing.maxQuantity()
-                ));
+                entryPoints.put(name,
+                                new EntryPointConfig(
+                rate,
+                existing.enabled(),
+                existing.products(),
+                existing.customerIds(),
+                existing.minQuantity(),
+                existing.maxQuantity()));
             }
         }
-
         // Parse global settings
         var multiplierPattern = Pattern.compile("\"globalRateMultiplier\"\\s*:\\s*([\\d.]+)");
         var multiplierMatcher = multiplierPattern.matcher(json);
@@ -337,14 +351,12 @@ public static SimulatorConfig parseJson(String json) {
         if (multiplierMatcher.find()) {
             multiplier = Double.parseDouble(multiplierMatcher.group(1));
         }
-
         var enabledPattern = Pattern.compile("\"loadGeneratorEnabled\"\\s*:\\s*(true|false)");
         var enabledMatcher = enabledPattern.matcher(json);
         boolean enabled = config.loadGeneratorEnabled();
         if (enabledMatcher.find()) {
             enabled = Boolean.parseBoolean(enabledMatcher.group(1));
         }
-
         return new SimulatorConfig(entryPoints, slices, enabled, multiplier);
     }
 
@@ -353,11 +365,10 @@ public static SimulatorConfig parseJson(String json) {
      */
     public Result<Void> saveToFile(Path path) {
         return Result.lift(
-            Causes.forOneValue("Failed to save config to " + path),
-            () -> {
-                Files.writeString(path, toJson());
-                return null;
-            }
-        );
+        Causes.forOneValue("Failed to save config to " + path),
+        () -> {
+            Files.writeString(path, toJson());
+            return null;
+        });
     }
 }
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorMode.java b/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorMode.java
index 95bd1dc9..cbfbf2eb 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorMode.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/simulator/SimulatorMode.java
@@ -13,60 +13,52 @@ public enum SimulatorMode {
      * Load generator disabled, no latency, no chaos.
      */
     DEVELOPMENT("Development", false, false, false, 0.0),
-
     /**
      * Load test mode - high throughput, metrics focus.
      * Load generator enabled at full rate, minimal latency, no chaos.
      */
     LOAD_TEST("Load Test", true, false, false, 1.0),
-
     /**
      * Chaos test mode - failure injection enabled.
      * Load generator at reduced rate, realistic latency, chaos enabled.
      */
     CHAOS_TEST("Chaos Test", true, true, true, 0.5),
-
     /**
      * Integration mode - realistic backends, no chaos.
      * Load generator at low rate, realistic latency, no chaos.
      */
     INTEGRATION("Integration", true, true, false, 0.1);
-
     private final String displayName;
     private final boolean loadGeneratorEnabled;
     private final boolean realisticLatency;
     private final boolean chaosEnabled;
     private final double rateMultiplier;
-
-    SimulatorMode(String displayName, boolean loadGeneratorEnabled, boolean realisticLatency,
-                  boolean chaosEnabled, double rateMultiplier) {
+    SimulatorMode(String displayName,
+                  boolean loadGeneratorEnabled,
+                  boolean realisticLatency,
+                  boolean chaosEnabled,
+                  double rateMultiplier) {
         this.displayName = displayName;
         this.loadGeneratorEnabled = loadGeneratorEnabled;
         this.realisticLatency = realisticLatency;
         this.chaosEnabled = chaosEnabled;
         this.rateMultiplier = rateMultiplier;
     }
-
     public String displayName() {
         return displayName;
     }
-
     public boolean loadGeneratorEnabled() {
         return loadGeneratorEnabled;
     }
-
     public boolean realisticLatency() {
         return realisticLatency;
     }
-
     public boolean chaosEnabled() {
         return chaosEnabled;
     }
-
     public double rateMultiplier() {
         return rateMultiplier;
     }
-
     /**
      * Get the default backend simulation for this mode.
      */
@@ -76,24 +68,24 @@ public BackendSimulation defaultBackendSimulation() {
         }
         return BackendSimulation.LatencySimulation.withSpikes(10, 5, 0.01, 100);
     }
-
     /**
      * Create a SimulatorConfig for this mode based on a template config.
      */
     public SimulatorConfig applyTo(SimulatorConfig template) {
-        return template
-            .withLoadGeneratorEnabled(loadGeneratorEnabled)
-            .withGlobalMultiplier(rateMultiplier);
+        return template.withLoadGeneratorEnabled(loadGeneratorEnabled)
+                       .withGlobalMultiplier(rateMultiplier);
     }
-
     public String toJson() {
         return String.format(
-            "{\"mode\":\"%s\",\"displayName\":\"%s\",\"loadGeneratorEnabled\":%b," +
-            "\"realisticLatency\":%b,\"chaosEnabled\":%b,\"rateMultiplier\":%.2f}",
-            name(), displayName, loadGeneratorEnabled, realisticLatency, chaosEnabled, rateMultiplier
-        );
+        "{\"mode\":\"%s\",\"displayName\":\"%s\",\"loadGeneratorEnabled\":%b,"
+        + "\"realisticLatency\":%b,\"chaosEnabled\":%b,\"rateMultiplier\":%.2f}",
+        name(),
+        displayName,
+        loadGeneratorEnabled,
+        realisticLatency,
+        chaosEnabled,
+        rateMultiplier);
     }
-
     /**
      * Parse mode from string, case-insensitive.
      * Returns Result for proper error handling per JBCT patterns.
@@ -102,13 +94,14 @@ public static Result<SimulatorMode> simulatorMode(String value) {
         if (value == null || value.isBlank()) {
             return ModeError.Empty.INSTANCE.result();
         }
-        try {
-            return Result.success(valueOf(value.toUpperCase().replace("-", "_").replace(" ", "_")));
+        try{
+            return Result.success(valueOf(value.toUpperCase()
+                                               .replace("-", "_")
+                                               .replace(" ", "_")));
         } catch (IllegalArgumentException e) {
             return new ModeError.Unknown(value).result();
         }
     }
-
     /**
      * Get all modes as JSON array.
      */
@@ -123,13 +116,13 @@ public static String allModesJson() {
         sb.append("]");
         return sb.toString();
     }
-
     /**
      * Mode parsing errors.
      */
     public sealed interface ModeError extends Cause {
         record Empty() implements ModeError {
             public static final Empty INSTANCE = new Empty();
+
             @Override
             public String message() {
                 return "Mode name cannot be empty";
diff --git a/http-server/pom.xml b/http-server/pom.xml
deleted file mode 100644
index 4ae9c5ad..00000000
--- a/http-server/pom.xml
+++ /dev/null
@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <parent>
-        <groupId>org.pragmatica-lite.aether</groupId>
-        <artifactId>aether</artifactId>
-        <version>0.6.3</version>
-    </parent>
-
-    <artifactId>http-server</artifactId>
-    <name>Pragmatica HTTP Server</name>
-    <description>Minimal HTTP server based on Netty, following Pragmatica Lite patterns</description>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>core</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.netty</groupId>
-            <artifactId>netty-all</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-        </dependency>
-
-        <!-- Test -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>
diff --git a/http-server/src/main/java/org/pragmatica/http/server/HttpMethod.java b/http-server/src/main/java/org/pragmatica/http/server/HttpMethod.java
deleted file mode 100644
index 4f8c38b2..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/HttpMethod.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.pragmatica.http.server;
-
-/**
- * HTTP request methods.
- */
-public enum HttpMethod {
-    GET,
-    POST,
-    PUT,
-    DELETE,
-    PATCH,
-    HEAD,
-    OPTIONS,
-    TRACE,
-    CONNECT;
-
-    /**
-     * Parse HTTP method from string.
-     */
-    public static HttpMethod from(String method) {
-        return switch (method.toUpperCase()) {
-            case "GET" -> GET;
-            case "POST" -> POST;
-            case "PUT" -> PUT;
-            case "DELETE" -> DELETE;
-            case "PATCH" -> PATCH;
-            case "HEAD" -> HEAD;
-            case "OPTIONS" -> OPTIONS;
-            case "TRACE" -> TRACE;
-            case "CONNECT" -> CONNECT;
-            default -> throw new IllegalArgumentException("Unknown HTTP method: " + method);
-        };
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/HttpServer.java b/http-server/src/main/java/org/pragmatica/http/server/HttpServer.java
deleted file mode 100644
index dc873947..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/HttpServer.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.http.server.impl.NettyHttpServer;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-import java.util.function.BiConsumer;
-
-/**
- * HTTP server interface.
- * <p>
- * Create instances using the factory method {@link #httpServer(HttpServerConfig, BiConsumer)}.
- *
- * <h2>Example Usage</h2>
- * <pre>{@code
- * var config = HttpServerConfig.https(8443, TlsConfig.selfSigned());
- *
- * HttpServer.httpServer(config, (request, response) -> {
- *     if (request.method() == HttpMethod.GET && request.path().equals("/health")) {
- *         response.ok("{\"status\":\"UP\"}");
- *     } else {
- *         response.notFound();
- *     }
- * })
- * .flatMap(HttpServer::start)
- * .onSuccess(_ -> System.out.println("Server started"))
- * .onFailure(cause -> System.err.println("Failed: " + cause.message()));
- * }</pre>
- */
-public interface HttpServer {
-
-    /**
-     * Start the server.
-     *
-     * @return promise that completes when server is listening
-     */
-    Promise<Unit> start();
-
-    /**
-     * Stop the server gracefully.
-     *
-     * @return promise that completes when server is stopped
-     */
-    Promise<Unit> stop();
-
-    /**
-     * Get the port the server is configured to listen on.
-     *
-     * @return configured port number
-     */
-    int port();
-
-    /**
-     * Create a new HTTP server.
-     *
-     * @param config  server configuration
-     * @param handler request handler that processes each request
-     * @return promise with server instance or error
-     */
-    static Promise<HttpServer> httpServer(
-            HttpServerConfig config,
-            BiConsumer<RequestContext, ResponseWriter> handler
-    ) {
-        return NettyHttpServer.create(config, handler);
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/HttpServerConfig.java b/http-server/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
deleted file mode 100644
index 484a3836..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.lang.Option;
-
-/**
- * Configuration for HTTP server.
- *
- * @param port             server port
- * @param maxContentLength maximum request body size in bytes
- * @param tls              optional TLS configuration for HTTPS
- */
-public record HttpServerConfig(
-        int port,
-        int maxContentLength,
-        Option<TlsConfig> tls
-) {
-    public static final int DEFAULT_PORT = 8080;
-    public static final int DEFAULT_MAX_CONTENT = 1024 * 1024; // 1MB
-
-    /**
-     * Create HTTP (non-TLS) server configuration.
-     */
-    public static HttpServerConfig http(int port) {
-        return new HttpServerConfig(port, DEFAULT_MAX_CONTENT, Option.empty());
-    }
-
-    /**
-     * Create HTTP server configuration with custom max content length.
-     */
-    public static HttpServerConfig http(int port, int maxContentLength) {
-        return new HttpServerConfig(port, maxContentLength, Option.empty());
-    }
-
-    /**
-     * Create HTTPS (TLS) server configuration.
-     */
-    public static HttpServerConfig https(int port, TlsConfig tls) {
-        return new HttpServerConfig(port, DEFAULT_MAX_CONTENT, Option.some(tls));
-    }
-
-    /**
-     * Create HTTPS server configuration with custom max content length.
-     */
-    public static HttpServerConfig https(int port, TlsConfig tls, int maxContentLength) {
-        return new HttpServerConfig(port, maxContentLength, Option.some(tls));
-    }
-
-    /**
-     * Create default HTTP server on port 8080.
-     */
-    public static HttpServerConfig defaultConfig() {
-        return http(DEFAULT_PORT);
-    }
-
-    /**
-     * Check if TLS is enabled.
-     */
-    public boolean isTlsEnabled() {
-        return tls.isPresent();
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/HttpServerError.java b/http-server/src/main/java/org/pragmatica/http/server/HttpServerError.java
deleted file mode 100644
index 28d082c0..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/HttpServerError.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.lang.Cause;
-
-import java.nio.file.Path;
-
-/**
- * Error types for HTTP server operations.
- */
-public sealed interface HttpServerError extends Cause {
-
-    /**
-     * Failed to bind to the specified port.
-     */
-    record BindFailed(int port, Throwable cause) implements HttpServerError {
-        @Override
-        public String message() {
-            return "Failed to bind to port " + port + ": " + cause.getMessage();
-        }
-    }
-
-    /**
-     * TLS configuration failed.
-     */
-    record TlsConfigFailed(String reason) implements HttpServerError {
-        @Override
-        public String message() {
-            return "TLS configuration failed: " + reason;
-        }
-    }
-
-    /**
-     * Failed to load certificate from file.
-     */
-    record CertificateLoadFailed(Path path, Throwable cause) implements HttpServerError {
-        @Override
-        public String message() {
-            return "Failed to load certificate from " + path + ": " + cause.getMessage();
-        }
-    }
-
-    /**
-     * Failed to generate self-signed certificate.
-     */
-    record SelfSignedGenerationFailed(Throwable cause) implements HttpServerError {
-        @Override
-        public String message() {
-            return "Failed to generate self-signed certificate: " + cause.getMessage();
-        }
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/HttpStatus.java b/http-server/src/main/java/org/pragmatica/http/server/HttpStatus.java
deleted file mode 100644
index ddf08575..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/HttpStatus.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package org.pragmatica.http.server;
-
-/**
- * HTTP response status codes.
- */
-public enum HttpStatus {
-    // 2xx Success
-    OK(200, "OK"),
-    CREATED(201, "Created"),
-    ACCEPTED(202, "Accepted"),
-    NO_CONTENT(204, "No Content"),
-
-    // 3xx Redirection
-    MOVED_PERMANENTLY(301, "Moved Permanently"),
-    FOUND(302, "Found"),
-    NOT_MODIFIED(304, "Not Modified"),
-    TEMPORARY_REDIRECT(307, "Temporary Redirect"),
-    PERMANENT_REDIRECT(308, "Permanent Redirect"),
-
-    // 4xx Client Errors
-    BAD_REQUEST(400, "Bad Request"),
-    UNAUTHORIZED(401, "Unauthorized"),
-    FORBIDDEN(403, "Forbidden"),
-    NOT_FOUND(404, "Not Found"),
-    METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
-    CONFLICT(409, "Conflict"),
-    UNPROCESSABLE_ENTITY(422, "Unprocessable Entity"),
-    TOO_MANY_REQUESTS(429, "Too Many Requests"),
-
-    // 5xx Server Errors
-    INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
-    NOT_IMPLEMENTED(501, "Not Implemented"),
-    BAD_GATEWAY(502, "Bad Gateway"),
-    SERVICE_UNAVAILABLE(503, "Service Unavailable"),
-    GATEWAY_TIMEOUT(504, "Gateway Timeout");
-
-    private final int code;
-    private final String reasonPhrase;
-
-    HttpStatus(int code, String reasonPhrase) {
-        this.code = code;
-        this.reasonPhrase = reasonPhrase;
-    }
-
-    public int code() {
-        return code;
-    }
-
-    public String reasonPhrase() {
-        return reasonPhrase;
-    }
-
-    public boolean isSuccess() {
-        return code >= 200 && code < 300;
-    }
-
-    public boolean isRedirect() {
-        return code >= 300 && code < 400;
-    }
-
-    public boolean isClientError() {
-        return code >= 400 && code < 500;
-    }
-
-    public boolean isServerError() {
-        return code >= 500 && code < 600;
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/RequestContext.java b/http-server/src/main/java/org/pragmatica/http/server/RequestContext.java
deleted file mode 100644
index 49f22e70..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/RequestContext.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package org.pragmatica.http.server;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.util.CharsetUtil;
-import org.pragmatica.lang.Option;
-
-import java.net.URLDecoder;
-import java.nio.charset.StandardCharsets;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Immutable HTTP request context.
- * <p>
- * Provides access to request method, path, query parameters, headers, and body.
- *
- * @param method  HTTP method
- * @param path    request path (without query string)
- * @param query   raw query string (may be null)
- * @param headers request headers (case-insensitive keys)
- * @param body    request body as ByteBuf
- */
-public record RequestContext(
-        HttpMethod method,
-        String path,
-        String query,
-        Map<String, String> headers,
-        ByteBuf body
-) {
-    /**
-     * Get header value by name (case-insensitive).
-     */
-    public Option<String> header(String name) {
-        return Option.option(headers.get(name.toLowerCase()));
-    }
-
-    /**
-     * Get query parameter value by name.
-     */
-    public Option<String> queryParam(String name) {
-        if (query == null || query.isEmpty()) {
-            return Option.empty();
-        }
-
-        var params = parseQueryParams();
-        return Option.option(params.get(name));
-    }
-
-    /**
-     * Get all query parameters as a map.
-     */
-    public Map<String, String> queryParams() {
-        if (query == null || query.isEmpty()) {
-            return Collections.emptyMap();
-        }
-        return parseQueryParams();
-    }
-
-    /**
-     * Get request body as UTF-8 string.
-     */
-    public String bodyAsString() {
-        if (body == null || body.readableBytes() == 0) {
-            return "";
-        }
-        return body.toString(CharsetUtil.UTF_8);
-    }
-
-    /**
-     * Check if request has body.
-     */
-    public boolean hasBody() {
-        return body != null && body.readableBytes() > 0;
-    }
-
-    /**
-     * Get Content-Type header.
-     */
-    public Option<String> contentType() {
-        return header("content-type");
-    }
-
-    /**
-     * Check if request content type is JSON.
-     */
-    public boolean isJson() {
-        return contentType()
-                .map(ct -> ct.contains("application/json"))
-                .fold(() -> false, bool -> bool);
-    }
-
-    /**
-     * Release the body buffer. Must be called when done with the request.
-     */
-    public void release() {
-        if (body != null && body.refCnt() > 0) {
-            body.release();
-        }
-    }
-
-    private Map<String, String> parseQueryParams() {
-        var params = new HashMap<String, String>();
-        var pairs = query.split("&");
-
-        for (var pair : pairs) {
-            var idx = pair.indexOf('=');
-            if (idx > 0) {
-                var key = URLDecoder.decode(pair.substring(0, idx), StandardCharsets.UTF_8);
-                var value = idx < pair.length() - 1
-                            ? URLDecoder.decode(pair.substring(idx + 1), StandardCharsets.UTF_8)
-                            : "";
-                params.put(key, value);
-            } else if (!pair.isEmpty()) {
-                params.put(URLDecoder.decode(pair, StandardCharsets.UTF_8), "");
-            }
-        }
-
-        return params;
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/ResponseWriter.java b/http-server/src/main/java/org/pragmatica/http/server/ResponseWriter.java
deleted file mode 100644
index 9faad27b..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/ResponseWriter.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package org.pragmatica.http.server;
-
-import io.netty.buffer.ByteBuf;
-import org.pragmatica.lang.Cause;
-
-/**
- * Response writing interface for HTTP handlers.
- * <p>
- * Provides methods to send various HTTP responses.
- * Each response method can only be called once per request.
- */
-public interface ResponseWriter {
-
-    /**
-     * Send successful response with content.
-     *
-     * @param content     response body
-     * @param contentType Content-Type header value
-     */
-    void ok(ByteBuf content, String contentType);
-
-    /**
-     * Send successful JSON response.
-     *
-     * @param json JSON string
-     */
-    void ok(String json);
-
-    /**
-     * Send 204 No Content response.
-     */
-    void noContent();
-
-    /**
-     * Send error response with custom status and message.
-     *
-     * @param status  HTTP status code
-     * @param message error message
-     */
-    void error(HttpStatus status, String message);
-
-    /**
-     * Send 404 Not Found response.
-     */
-    void notFound();
-
-    /**
-     * Send 400 Bad Request response.
-     *
-     * @param message error message
-     */
-    void badRequest(String message);
-
-    /**
-     * Send 500 Internal Server Error response.
-     *
-     * @param cause error cause
-     */
-    void internalError(Cause cause);
-
-    /**
-     * Send response with custom status and JSON body.
-     *
-     * @param status HTTP status
-     * @param json   JSON response body
-     */
-    void respond(HttpStatus status, String json);
-
-    /**
-     * Send response with custom status, body, and content type.
-     *
-     * @param status      HTTP status
-     * @param content     response body
-     * @param contentType Content-Type header value
-     */
-    void respond(HttpStatus status, ByteBuf content, String contentType);
-
-    /**
-     * Add header to the response.
-     * Must be called before any response method.
-     *
-     * @param name  header name
-     * @param value header value
-     * @return this writer for chaining
-     */
-    ResponseWriter header(String name, String value);
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/TlsConfig.java b/http-server/src/main/java/org/pragmatica/http/server/TlsConfig.java
deleted file mode 100644
index fde70297..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/TlsConfig.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.lang.Option;
-
-import java.nio.file.Path;
-
-/**
- * TLS configuration for HTTPS server.
- * <p>
- * Two modes supported:
- * <ul>
- *   <li>{@link SelfSigned} - generates self-signed certificate at startup (for development)</li>
- *   <li>{@link FromFiles} - loads certificate and private key from PEM files (for production)</li>
- * </ul>
- */
-public sealed interface TlsConfig {
-
-    /**
-     * Self-signed certificate generated at startup.
-     * Suitable for development and testing only.
-     */
-    record SelfSigned() implements TlsConfig {}
-
-    /**
-     * Certificate and private key loaded from PEM files.
-     * Suitable for production use.
-     */
-    record FromFiles(
-            Path certificatePath,
-            Path privateKeyPath,
-            Option<String> keyPassword
-    ) implements TlsConfig {}
-
-    /**
-     * Create self-signed TLS configuration.
-     */
-    static TlsConfig selfSigned() {
-        return new SelfSigned();
-    }
-
-    /**
-     * Create TLS configuration from certificate files.
-     *
-     * @param certificatePath path to PEM certificate file
-     * @param privateKeyPath  path to PEM private key file
-     */
-    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath) {
-        return new FromFiles(certificatePath, privateKeyPath, Option.empty());
-    }
-
-    /**
-     * Create TLS configuration from password-protected certificate files.
-     *
-     * @param certificatePath path to PEM certificate file
-     * @param privateKeyPath  path to PEM private key file
-     * @param keyPassword     password for the private key
-     */
-    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath, String keyPassword) {
-        return new FromFiles(certificatePath, privateKeyPath, Option.some(keyPassword));
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/impl/HttpRequestHandler.java b/http-server/src/main/java/org/pragmatica/http/server/impl/HttpRequestHandler.java
deleted file mode 100644
index adebd106..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/impl/HttpRequestHandler.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package org.pragmatica.http.server.impl;
-
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.handler.codec.http.FullHttpRequest;
-import io.netty.handler.codec.http.HttpUtil;
-import org.pragmatica.http.server.HttpMethod;
-import org.pragmatica.http.server.HttpStatus;
-import org.pragmatica.http.server.RequestContext;
-import org.pragmatica.http.server.ResponseWriter;
-import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.function.BiConsumer;
-
-/**
- * Netty channel handler that processes HTTP requests.
- */
-public final class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
-    private static final Logger LOG = LoggerFactory.getLogger(HttpRequestHandler.class);
-
-    private final BiConsumer<RequestContext, ResponseWriter> handler;
-
-    public HttpRequestHandler(BiConsumer<RequestContext, ResponseWriter> handler) {
-        this.handler = handler;
-    }
-
-    @Override
-    protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
-        if (!request.decoderResult().isSuccess()) {
-            sendBadRequest(ctx, "Invalid HTTP request");
-            return;
-        }
-
-        var keepAlive = HttpUtil.isKeepAlive(request);
-        RequestContext context = null;
-        try {
-            context = createRequestContext(request);
-            var writer = new NettyResponseWriter(ctx, keepAlive);
-            handler.accept(context, writer);
-        } catch (Exception e) {
-            LOG.error("Handler error", e);
-            new NettyResponseWriter(ctx, keepAlive).internalError(Causes.fromThrowable(e));
-        } finally {
-            if (context != null) {
-                context.release();
-            }
-        }
-    }
-
-    @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
-        LOG.error("Channel error", cause);
-        ctx.close();
-    }
-
-    private RequestContext createRequestContext(FullHttpRequest request) {
-        var uri = request.uri();
-        var queryIndex = uri.indexOf('?');
-
-        String path;
-        String query;
-        if (queryIndex >= 0) {
-            path = uri.substring(0, queryIndex);
-            query = uri.substring(queryIndex + 1);
-        } else {
-            path = uri;
-            query = null;
-        }
-
-        var method = HttpMethod.from(request.method().name());
-        var headers = extractHeaders(request);
-        var body = request.content().retain();
-
-        return new RequestContext(method, path, query, headers, body);
-    }
-
-    private Map<String, String> extractHeaders(FullHttpRequest request) {
-        var headers = new HashMap<String, String>();
-        for (var entry : request.headers()) {
-            headers.put(entry.getKey().toLowerCase(Locale.ROOT), entry.getValue());
-        }
-        return headers;
-    }
-
-    private void sendBadRequest(ChannelHandlerContext ctx, String message) {
-        var writer = new NettyResponseWriter(ctx, false);
-        writer.error(HttpStatus.BAD_REQUEST, message);
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java b/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
deleted file mode 100644
index 7e4554f4..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyHttpServer.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package org.pragmatica.http.server.impl;
-
-import org.pragmatica.http.server.HttpServer;
-import org.pragmatica.http.server.HttpServerConfig;
-import org.pragmatica.http.server.HttpServerError;
-import org.pragmatica.http.server.RequestContext;
-import org.pragmatica.http.server.ResponseWriter;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
-
-import java.util.function.BiConsumer;
-
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.MultiThreadIoEventLoopGroup;
-import io.netty.channel.nio.NioIoHandler;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.handler.codec.http.HttpObjectAggregator;
-import io.netty.handler.codec.http.HttpServerCodec;
-import io.netty.handler.ssl.SslContext;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.lang.Unit.unit;
-
-/**
- * Netty-based HTTP server implementation.
- */
-public final class NettyHttpServer implements HttpServer {
-    private static final Logger LOG = LoggerFactory.getLogger(NettyHttpServer.class);
-
-    private final HttpServerConfig config;
-    private final BiConsumer<RequestContext, ResponseWriter> handler;
-    private final Option<SslContext> sslContext;
-
-    private EventLoopGroup bossGroup;
-    private EventLoopGroup workerGroup;
-    private Channel serverChannel;
-
-    private NettyHttpServer(HttpServerConfig config,
-                            BiConsumer<RequestContext, ResponseWriter> handler,
-                            Option<SslContext> sslContext) {
-        this.config = config;
-        this.handler = handler;
-        this.sslContext = sslContext;
-    }
-
-    /**
-     * Create a new Netty HTTP server.
-     *
-     * @param config  server configuration
-     * @param handler request handler
-     * @return server instance or error
-     */
-    public static Promise<HttpServer> create(HttpServerConfig config,
-                                             BiConsumer<RequestContext, ResponseWriter> handler) {
-        Result<Option<SslContext>> sslResult = config.tls()
-                                                     .map(TlsContextFactory::create)
-                                                     .map(result -> result.map(Option::some))
-                                                     .fold(() -> Result.success(Option.empty()),
-                                                           result -> result);
-        return sslResult.map(ssl -> (HttpServer) new NettyHttpServer(config, handler, ssl))
-                        .async();
-    }
-
-    @Override
-    public Promise<Unit> start() {
-        return Promise.promise(promise -> {
-                                   bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
-                                   workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
-                                   try{
-                                   var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
-                                                   .channel(NioServerSocketChannel.class)
-                                                   .childHandler(new ChannelInitializer<SocketChannel>() {
-            @Override
-            protected void initChannel(SocketChannel ch) {
-                                                                     var pipeline = ch.pipeline();
-                                                                     sslContext.onPresent(ssl -> pipeline.addLast(ssl.newHandler(ch.alloc())));
-                                                                     pipeline.addLast(new HttpServerCodec());
-                                                                     pipeline.addLast(new HttpObjectAggregator(config.maxContentLength()));
-                                                                     pipeline.addLast(new HttpRequestHandler(handler));
-                                                                 }
-        })
-                                                   .option(ChannelOption.SO_BACKLOG, 128)
-                                                   .childOption(ChannelOption.SO_KEEPALIVE, true);
-                                   var channelFuture = bootstrap.bind(config.port());
-                                   channelFuture.addListener(future -> {
-                                                                 if (future.isSuccess()) {
-                                                                 serverChannel = channelFuture.channel();
-                                                                 var protocol = sslContext.isPresent()
-                                                                                ? "HTTPS"
-                                                                                : "HTTP";
-                                                                 LOG.info("{} server started on port {}",
-                                                                          protocol,
-                                                                          config.port());
-                                                                 promise.succeed(unit());
-                                                             }else {
-                                                                 cleanup();
-                                                                 promise.fail(new HttpServerError.BindFailed(config.port(),
-                                                                                                             future.cause()));
-                                                             }
-                                                             });
-                               } catch (Exception e) {
-                                   cleanup();
-                                   promise.fail(new HttpServerError.BindFailed(config.port(), e));
-                               }
-                               });
-    }
-
-    @Override
-    public Promise<Unit> stop() {
-        return Promise.promise(promise -> {
-                                   LOG.info("Stopping HTTP server on port {}", config.port());
-                                   if (serverChannel != null) {
-                                   serverChannel.close()
-                                                .addListener(future -> {
-                                   cleanup();
-                                   promise.succeed(unit());
-                               });
-                               }else {
-                                   cleanup();
-                                   promise.succeed(unit());
-                               }
-                               });
-    }
-
-    @Override
-    public int port() {
-        return config.port();
-    }
-
-    private void cleanup() {
-        if (workerGroup != null) {
-            workerGroup.shutdownGracefully();
-        }
-        if (bossGroup != null) {
-            bossGroup.shutdownGracefully();
-        }
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyResponseWriter.java b/http-server/src/main/java/org/pragmatica/http/server/impl/NettyResponseWriter.java
deleted file mode 100644
index 7341196a..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/impl/NettyResponseWriter.java
+++ /dev/null
@@ -1,143 +0,0 @@
-package org.pragmatica.http.server.impl;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.handler.codec.http.DefaultFullHttpResponse;
-import io.netty.handler.codec.http.HttpHeaderNames;
-import io.netty.handler.codec.http.HttpHeaderValues;
-import io.netty.handler.codec.http.HttpResponseStatus;
-import io.netty.handler.codec.http.HttpVersion;
-import io.netty.util.CharsetUtil;
-import org.pragmatica.http.server.HttpStatus;
-import org.pragmatica.http.server.ResponseWriter;
-import org.pragmatica.lang.Cause;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * Netty implementation of ResponseWriter.
- */
-public final class NettyResponseWriter implements ResponseWriter {
-    private static final String APPLICATION_JSON = "application/json";
-
-    private final ChannelHandlerContext ctx;
-    private final boolean keepAlive;
-    private final Map<String, String> headers = new HashMap<>();
-    private boolean responseSent = false;
-
-    public NettyResponseWriter(ChannelHandlerContext ctx, boolean keepAlive) {
-        this.ctx = ctx;
-        this.keepAlive = keepAlive;
-    }
-
-    @Override
-    public void ok(ByteBuf content, String contentType) {
-        respond(HttpStatus.OK, content, contentType);
-    }
-
-    @Override
-    public void ok(String json) {
-        respond(HttpStatus.OK, json);
-    }
-
-    @Override
-    public void noContent() {
-        sendResponse(HttpStatus.NO_CONTENT, Unpooled.EMPTY_BUFFER, null);
-    }
-
-    @Override
-    public void error(HttpStatus status, String message) {
-        var json = "{\"error\":\"" + escapeJson(message) + "\"}";
-        respond(status, json);
-    }
-
-    @Override
-    public void notFound() {
-        error(HttpStatus.NOT_FOUND, "Not Found");
-    }
-
-    @Override
-    public void badRequest(String message) {
-        error(HttpStatus.BAD_REQUEST, message);
-    }
-
-    @Override
-    public void internalError(Cause cause) {
-        error(HttpStatus.INTERNAL_SERVER_ERROR, cause.message());
-    }
-
-    @Override
-    public void respond(HttpStatus status, String json) {
-        var content = Unpooled.copiedBuffer(json, CharsetUtil.UTF_8);
-        respond(status, content, APPLICATION_JSON);
-    }
-
-    @Override
-    public void respond(HttpStatus status, ByteBuf content, String contentType) {
-        sendResponse(status, content, contentType);
-    }
-
-    @Override
-    public ResponseWriter header(String name, String value) {
-        headers.put(name, value);
-        return this;
-    }
-
-    private void sendResponse(HttpStatus status, ByteBuf content, String contentType) {
-        if (responseSent) {
-            content.release();
-            return;
-        }
-        responseSent = true;
-
-        var nettyStatus = HttpResponseStatus.valueOf(status.code());
-        var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, nettyStatus, content);
-
-        // Set content headers
-        if (contentType != null) {
-            response.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType);
-        }
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
-
-        // Set custom headers
-        headers.forEach((name, value) -> response.headers().set(name, value));
-
-        // Handle keep-alive
-        if (keepAlive) {
-            response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
-            ctx.writeAndFlush(response);
-        } else {
-            ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
-        }
-    }
-
-    private static String escapeJson(String value) {
-        if (value == null) {
-            return "";
-        }
-        var sb = new StringBuilder(value.length());
-        for (int i = 0; i < value.length(); i++) {
-            char c = value.charAt(i);
-            switch (c) {
-                case '"' -> sb.append("\\\"");
-                case '\\' -> sb.append("\\\\");
-                case '\b' -> sb.append("\\b");
-                case '\f' -> sb.append("\\f");
-                case '\n' -> sb.append("\\n");
-                case '\r' -> sb.append("\\r");
-                case '\t' -> sb.append("\\t");
-                default -> {
-                    if (c < ' ') {
-                        sb.append(String.format("\\u%04x", (int) c));
-                    } else {
-                        sb.append(c);
-                    }
-                }
-            }
-        }
-        return sb.toString();
-    }
-}
diff --git a/http-server/src/main/java/org/pragmatica/http/server/impl/TlsContextFactory.java b/http-server/src/main/java/org/pragmatica/http/server/impl/TlsContextFactory.java
deleted file mode 100644
index f3bbf186..00000000
--- a/http-server/src/main/java/org/pragmatica/http/server/impl/TlsContextFactory.java
+++ /dev/null
@@ -1,55 +0,0 @@
-package org.pragmatica.http.server.impl;
-
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.util.SelfSignedCertificate;
-import org.pragmatica.http.server.HttpServerError;
-import org.pragmatica.http.server.TlsConfig;
-import org.pragmatica.lang.Result;
-
-/**
- * Factory for creating Netty SSL contexts from TLS configuration.
- */
-public final class TlsContextFactory {
-
-    private TlsContextFactory() {}
-
-    /**
-     * Create SSL context from TLS configuration.
-     *
-     * @param config TLS configuration
-     * @return SSL context or error
-     */
-    public static Result<SslContext> create(TlsConfig config) {
-        return switch (config) {
-            case TlsConfig.SelfSigned() -> createSelfSigned();
-            case TlsConfig.FromFiles fromFiles -> createFromFiles(fromFiles);
-        };
-    }
-
-    private static Result<SslContext> createSelfSigned() {
-        try {
-            var ssc = new SelfSignedCertificate();
-            var sslContext = SslContextBuilder
-                    .forServer(ssc.certificate(), ssc.privateKey())
-                    .build();
-            return Result.success(sslContext);
-        } catch (Exception e) {
-            return new HttpServerError.SelfSignedGenerationFailed(e).result();
-        }
-    }
-
-    private static Result<SslContext> createFromFiles(TlsConfig.FromFiles config) {
-        try {
-            var password = config.keyPassword().fold(() -> null, pwd -> pwd);
-            var builder = SslContextBuilder.forServer(
-                    config.certificatePath().toFile(),
-                    config.privateKeyPath().toFile(),
-                    password
-            );
-            return Result.success(builder.build());
-        } catch (Exception e) {
-            return new HttpServerError.CertificateLoadFailed(config.certificatePath(), e).result();
-        }
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/HttpMethodTest.java b/http-server/src/test/java/org/pragmatica/http/server/HttpMethodTest.java
deleted file mode 100644
index 932a794a..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/HttpMethodTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
-
-class HttpMethodTest {
-
-    @Test
-    void from_parses_uppercase_method() {
-        assertThat(HttpMethod.from("GET")).isEqualTo(HttpMethod.GET);
-        assertThat(HttpMethod.from("POST")).isEqualTo(HttpMethod.POST);
-        assertThat(HttpMethod.from("PUT")).isEqualTo(HttpMethod.PUT);
-        assertThat(HttpMethod.from("DELETE")).isEqualTo(HttpMethod.DELETE);
-    }
-
-    @Test
-    void from_parses_lowercase_method() {
-        assertThat(HttpMethod.from("get")).isEqualTo(HttpMethod.GET);
-        assertThat(HttpMethod.from("post")).isEqualTo(HttpMethod.POST);
-    }
-
-    @Test
-    void from_parses_mixed_case_method() {
-        assertThat(HttpMethod.from("Get")).isEqualTo(HttpMethod.GET);
-        assertThat(HttpMethod.from("PoSt")).isEqualTo(HttpMethod.POST);
-    }
-
-    @Test
-    void from_throws_for_unknown_method() {
-        assertThatThrownBy(() -> HttpMethod.from("INVALID"))
-                .isInstanceOf(IllegalArgumentException.class)
-                .hasMessageContaining("Unknown HTTP method");
-    }
-
-    @Test
-    void all_methods_are_parseable() {
-        for (HttpMethod method : HttpMethod.values()) {
-            assertThat(HttpMethod.from(method.name())).isEqualTo(method);
-        }
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/HttpServerConfigTest.java b/http-server/src/test/java/org/pragmatica/http/server/HttpServerConfigTest.java
deleted file mode 100644
index 01bf8359..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/HttpServerConfigTest.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class HttpServerConfigTest {
-
-    @Test
-    void http_creates_plain_http_config() {
-        var config = HttpServerConfig.http(8080);
-
-        assertThat(config.port()).isEqualTo(8080);
-        assertThat(config.maxContentLength()).isEqualTo(HttpServerConfig.DEFAULT_MAX_CONTENT);
-        assertThat(config.tls().isPresent()).isFalse();
-        assertThat(config.isTlsEnabled()).isFalse();
-    }
-
-    @Test
-    void http_with_custom_max_content() {
-        var config = HttpServerConfig.http(9000, 2048);
-
-        assertThat(config.port()).isEqualTo(9000);
-        assertThat(config.maxContentLength()).isEqualTo(2048);
-        assertThat(config.isTlsEnabled()).isFalse();
-    }
-
-    @Test
-    void https_creates_tls_config() {
-        var tls = TlsConfig.selfSigned();
-        var config = HttpServerConfig.https(8443, tls);
-
-        assertThat(config.port()).isEqualTo(8443);
-        assertThat(config.maxContentLength()).isEqualTo(HttpServerConfig.DEFAULT_MAX_CONTENT);
-        assertThat(config.tls().isPresent()).isTrue();
-        assertThat(config.isTlsEnabled()).isTrue();
-    }
-
-    @Test
-    void https_with_custom_max_content() {
-        var tls = TlsConfig.selfSigned();
-        var config = HttpServerConfig.https(443, tls, 4096);
-
-        assertThat(config.port()).isEqualTo(443);
-        assertThat(config.maxContentLength()).isEqualTo(4096);
-        assertThat(config.isTlsEnabled()).isTrue();
-    }
-
-    @Test
-    void defaultConfig_uses_port_8080() {
-        var config = HttpServerConfig.defaultConfig();
-
-        assertThat(config.port()).isEqualTo(HttpServerConfig.DEFAULT_PORT);
-        assertThat(config.isTlsEnabled()).isFalse();
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/HttpServerIntegrationTest.java b/http-server/src/test/java/org/pragmatica/http/server/HttpServerIntegrationTest.java
deleted file mode 100644
index 3591a095..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/HttpServerIntegrationTest.java
+++ /dev/null
@@ -1,180 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.junit.jupiter.api.Test;
-
-import java.net.URI;
-import java.net.http.HttpClient;
-import java.net.http.HttpRequest;
-import java.net.http.HttpResponse;
-import java.time.Duration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class HttpServerIntegrationTest {
-
-    @Test
-    void server_responds_to_get_request() throws Exception {
-        var config = HttpServerConfig.http(0); // port 0 = random available port
-
-        var serverRef = new HttpServer[1];
-
-        HttpServer.httpServer(config, (request, response) -> {
-            if (request.method() == HttpMethod.GET && request.path().equals("/health")) {
-                response.ok("{\"status\":\"UP\"}");
-            } else {
-                response.notFound();
-            }
-        })
-        .flatMap(server -> {
-            serverRef[0] = server;
-            return server.start();
-        })
-        .await()
-        .onFailureRun(() -> org.junit.jupiter.api.Assertions.fail("Server failed to start"));
-
-        // Server started, but we used port 0 so we need to get actual port
-        // For now, use the configured port (which was 0, so this won't work)
-        // Let's use a fixed port for the test
-    }
-
-    @Test
-    void server_starts_and_stops_on_fixed_port() throws Exception {
-        int port = 18080;
-        var config = HttpServerConfig.http(port);
-
-        var serverRef = new HttpServer[1];
-
-        // Start server
-        HttpServer.httpServer(config, (request, response) -> {
-            if (request.path().equals("/health")) {
-                response.ok("{\"status\":\"UP\"}");
-            } else if (request.path().equals("/echo")) {
-                response.ok(request.bodyAsString());
-            } else {
-                response.notFound();
-            }
-        })
-        .flatMap(server -> {
-            serverRef[0] = server;
-            return server.start();
-        })
-        .await()
-        .onFailureRun(() -> org.junit.jupiter.api.Assertions.fail("Server failed to start"));
-
-        try {
-            // Make HTTP request
-            var client = HttpClient.newBuilder()
-                    .connectTimeout(Duration.ofSeconds(5))
-                    .build();
-
-            var request = HttpRequest.newBuilder()
-                    .uri(URI.create("http://localhost:" + port + "/health"))
-                    .GET()
-                    .build();
-
-            var response = client.send(request, HttpResponse.BodyHandlers.ofString());
-
-            assertThat(response.statusCode()).isEqualTo(200);
-            assertThat(response.body()).isEqualTo("{\"status\":\"UP\"}");
-
-            // Test 404
-            var notFoundRequest = HttpRequest.newBuilder()
-                    .uri(URI.create("http://localhost:" + port + "/unknown"))
-                    .GET()
-                    .build();
-
-            var notFoundResponse = client.send(notFoundRequest, HttpResponse.BodyHandlers.ofString());
-            assertThat(notFoundResponse.statusCode()).isEqualTo(404);
-
-        } finally {
-            // Stop server
-            if (serverRef[0] != null) {
-                serverRef[0].stop().await();
-            }
-        }
-    }
-
-    @Test
-    void server_handles_post_request_with_body() throws Exception {
-        int port = 18081;
-        var config = HttpServerConfig.http(port);
-
-        var serverRef = new HttpServer[1];
-
-        HttpServer.httpServer(config, (request, response) -> {
-            if (request.method() == HttpMethod.POST && request.path().equals("/echo")) {
-                response.ok(request.bodyAsString());
-            } else {
-                response.notFound();
-            }
-        })
-        .flatMap(server -> {
-            serverRef[0] = server;
-            return server.start();
-        })
-        .await()
-        .onFailureRun(() -> org.junit.jupiter.api.Assertions.fail("Server failed to start"));
-
-        try {
-            var client = HttpClient.newBuilder()
-                    .connectTimeout(Duration.ofSeconds(5))
-                    .build();
-
-            var request = HttpRequest.newBuilder()
-                    .uri(URI.create("http://localhost:" + port + "/echo"))
-                    .POST(HttpRequest.BodyPublishers.ofString("{\"message\":\"hello\"}"))
-                    .header("Content-Type", "application/json")
-                    .build();
-
-            var response = client.send(request, HttpResponse.BodyHandlers.ofString());
-
-            assertThat(response.statusCode()).isEqualTo(200);
-            assertThat(response.body()).isEqualTo("{\"message\":\"hello\"}");
-
-        } finally {
-            if (serverRef[0] != null) {
-                serverRef[0].stop().await();
-            }
-        }
-    }
-
-    @Test
-    void server_parses_query_parameters() throws Exception {
-        int port = 18082;
-        var config = HttpServerConfig.http(port);
-
-        var serverRef = new HttpServer[1];
-
-        HttpServer.httpServer(config, (request, response) -> {
-            var name = request.queryParam("name").fold(() -> "unknown", n -> n);
-            response.ok("{\"greeting\":\"Hello, " + name + "!\"}");
-        })
-        .flatMap(server -> {
-            serverRef[0] = server;
-            return server.start();
-        })
-        .await()
-        .onFailureRun(() -> org.junit.jupiter.api.Assertions.fail("Server failed to start"));
-
-        try {
-            var client = HttpClient.newBuilder()
-                    .connectTimeout(Duration.ofSeconds(5))
-                    .build();
-
-            var request = HttpRequest.newBuilder()
-                    .uri(URI.create("http://localhost:" + port + "/greet?name=World"))
-                    .GET()
-                    .build();
-
-            var response = client.send(request, HttpResponse.BodyHandlers.ofString());
-
-            assertThat(response.statusCode()).isEqualTo(200);
-            assertThat(response.body()).isEqualTo("{\"greeting\":\"Hello, World!\"}");
-
-        } finally {
-            if (serverRef[0] != null) {
-                serverRef[0].stop().await();
-            }
-        }
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/HttpStatusTest.java b/http-server/src/test/java/org/pragmatica/http/server/HttpStatusTest.java
deleted file mode 100644
index 9eec6938..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/HttpStatusTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class HttpStatusTest {
-
-    @Test
-    void ok_has_code_200() {
-        assertThat(HttpStatus.OK.code()).isEqualTo(200);
-        assertThat(HttpStatus.OK.reasonPhrase()).isEqualTo("OK");
-    }
-
-    @Test
-    void not_found_has_code_404() {
-        assertThat(HttpStatus.NOT_FOUND.code()).isEqualTo(404);
-        assertThat(HttpStatus.NOT_FOUND.reasonPhrase()).isEqualTo("Not Found");
-    }
-
-    @Test
-    void internal_server_error_has_code_500() {
-        assertThat(HttpStatus.INTERNAL_SERVER_ERROR.code()).isEqualTo(500);
-    }
-
-    @Test
-    void isSuccess_returns_true_for_2xx_codes() {
-        assertThat(HttpStatus.OK.isSuccess()).isTrue();
-        assertThat(HttpStatus.CREATED.isSuccess()).isTrue();
-        assertThat(HttpStatus.NO_CONTENT.isSuccess()).isTrue();
-
-        assertThat(HttpStatus.NOT_FOUND.isSuccess()).isFalse();
-        assertThat(HttpStatus.INTERNAL_SERVER_ERROR.isSuccess()).isFalse();
-    }
-
-    @Test
-    void isRedirect_returns_true_for_3xx_codes() {
-        assertThat(HttpStatus.MOVED_PERMANENTLY.isRedirect()).isTrue();
-        assertThat(HttpStatus.FOUND.isRedirect()).isTrue();
-
-        assertThat(HttpStatus.OK.isRedirect()).isFalse();
-        assertThat(HttpStatus.NOT_FOUND.isRedirect()).isFalse();
-    }
-
-    @Test
-    void isClientError_returns_true_for_4xx_codes() {
-        assertThat(HttpStatus.BAD_REQUEST.isClientError()).isTrue();
-        assertThat(HttpStatus.NOT_FOUND.isClientError()).isTrue();
-        assertThat(HttpStatus.FORBIDDEN.isClientError()).isTrue();
-
-        assertThat(HttpStatus.OK.isClientError()).isFalse();
-        assertThat(HttpStatus.INTERNAL_SERVER_ERROR.isClientError()).isFalse();
-    }
-
-    @Test
-    void isServerError_returns_true_for_5xx_codes() {
-        assertThat(HttpStatus.INTERNAL_SERVER_ERROR.isServerError()).isTrue();
-        assertThat(HttpStatus.BAD_GATEWAY.isServerError()).isTrue();
-
-        assertThat(HttpStatus.OK.isServerError()).isFalse();
-        assertThat(HttpStatus.NOT_FOUND.isServerError()).isFalse();
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/RequestContextTest.java b/http-server/src/test/java/org/pragmatica/http/server/RequestContextTest.java
deleted file mode 100644
index ce7ab68f..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/RequestContextTest.java
+++ /dev/null
@@ -1,159 +0,0 @@
-package org.pragmatica.http.server;
-
-import io.netty.buffer.Unpooled;
-import io.netty.util.CharsetUtil;
-import org.junit.jupiter.api.Test;
-
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class RequestContextTest {
-
-    @Test
-    void header_returns_value_case_insensitively() {
-        var headers = Map.of("content-type", "application/json", "x-custom", "value");
-        var ctx = new RequestContext(HttpMethod.GET, "/path", null, headers, null);
-
-        assertThat(ctx.header("Content-Type").isPresent()).isTrue();
-        ctx.header("Content-Type").onPresent(v -> assertThat(v).isEqualTo("application/json"));
-
-        assertThat(ctx.header("X-Custom").isPresent()).isTrue();
-        ctx.header("X-Custom").onPresent(v -> assertThat(v).isEqualTo("value"));
-    }
-
-    @Test
-    void header_returns_empty_for_missing_header() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", null, Map.of(), null);
-
-        assertThat(ctx.header("X-Missing").isPresent()).isFalse();
-    }
-
-    @Test
-    void queryParam_parses_query_string() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", "foo=bar&baz=qux", Map.of(), null);
-
-        assertThat(ctx.queryParam("foo").isPresent()).isTrue();
-        ctx.queryParam("foo").onPresent(v -> assertThat(v).isEqualTo("bar"));
-
-        assertThat(ctx.queryParam("baz").isPresent()).isTrue();
-        ctx.queryParam("baz").onPresent(v -> assertThat(v).isEqualTo("qux"));
-    }
-
-    @Test
-    void queryParam_handles_url_encoded_values() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", "name=John%20Doe&email=test%40example.com", Map.of(), null);
-
-        ctx.queryParam("name").onPresent(v -> assertThat(v).isEqualTo("John Doe"));
-        ctx.queryParam("email").onPresent(v -> assertThat(v).isEqualTo("test@example.com"));
-    }
-
-    @Test
-    void queryParam_returns_empty_for_null_query() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", null, Map.of(), null);
-
-        assertThat(ctx.queryParam("any").isPresent()).isFalse();
-    }
-
-    @Test
-    void queryParam_returns_empty_for_missing_param() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", "foo=bar", Map.of(), null);
-
-        assertThat(ctx.queryParam("missing").isPresent()).isFalse();
-    }
-
-    @Test
-    void queryParams_returns_all_params() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", "a=1&b=2&c=3", Map.of(), null);
-
-        var params = ctx.queryParams();
-        assertThat(params).containsEntry("a", "1");
-        assertThat(params).containsEntry("b", "2");
-        assertThat(params).containsEntry("c", "3");
-    }
-
-    @Test
-    void queryParams_returns_empty_map_for_null_query() {
-        var ctx = new RequestContext(HttpMethod.GET, "/path", null, Map.of(), null);
-
-        assertThat(ctx.queryParams()).isEmpty();
-    }
-
-    @Test
-    void bodyAsString_returns_utf8_content() {
-        var body = Unpooled.copiedBuffer("Hello, World!", CharsetUtil.UTF_8);
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), body);
-
-        assertThat(ctx.bodyAsString()).isEqualTo("Hello, World!");
-    }
-
-    @Test
-    void bodyAsString_returns_empty_for_null_body() {
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), null);
-
-        assertThat(ctx.bodyAsString()).isEmpty();
-    }
-
-    @Test
-    void hasBody_returns_true_when_body_present() {
-        var body = Unpooled.copiedBuffer("content", CharsetUtil.UTF_8);
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), body);
-
-        assertThat(ctx.hasBody()).isTrue();
-    }
-
-    @Test
-    void hasBody_returns_false_when_body_null() {
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), null);
-
-        assertThat(ctx.hasBody()).isFalse();
-    }
-
-    @Test
-    void hasBody_returns_false_when_body_empty() {
-        var body = Unpooled.EMPTY_BUFFER;
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), body);
-
-        assertThat(ctx.hasBody()).isFalse();
-    }
-
-    @Test
-    void contentType_returns_content_type_header() {
-        var headers = Map.of("content-type", "application/json");
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, headers, null);
-
-        assertThat(ctx.contentType().isPresent()).isTrue();
-        ctx.contentType().onPresent(v -> assertThat(v).isEqualTo("application/json"));
-    }
-
-    @Test
-    void isJson_returns_true_for_json_content_type() {
-        var headers = Map.of("content-type", "application/json");
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, headers, null);
-
-        assertThat(ctx.isJson()).isTrue();
-    }
-
-    @Test
-    void isJson_returns_true_for_json_with_charset() {
-        var headers = Map.of("content-type", "application/json; charset=utf-8");
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, headers, null);
-
-        assertThat(ctx.isJson()).isTrue();
-    }
-
-    @Test
-    void isJson_returns_false_for_non_json_content() {
-        var headers = Map.of("content-type", "text/plain");
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, headers, null);
-
-        assertThat(ctx.isJson()).isFalse();
-    }
-
-    @Test
-    void isJson_returns_false_when_no_content_type() {
-        var ctx = new RequestContext(HttpMethod.POST, "/path", null, Map.of(), null);
-
-        assertThat(ctx.isJson()).isFalse();
-    }
-}
diff --git a/http-server/src/test/java/org/pragmatica/http/server/TlsConfigTest.java b/http-server/src/test/java/org/pragmatica/http/server/TlsConfigTest.java
deleted file mode 100644
index 286288db..00000000
--- a/http-server/src/test/java/org/pragmatica/http/server/TlsConfigTest.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.junit.jupiter.api.Test;
-
-import java.nio.file.Path;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class TlsConfigTest {
-
-    @Test
-    void selfSigned_creates_self_signed_config() {
-        var config = TlsConfig.selfSigned();
-
-        assertThat(config).isInstanceOf(TlsConfig.SelfSigned.class);
-    }
-
-    @Test
-    void fromFiles_creates_file_based_config() {
-        var cert = Path.of("/path/to/cert.pem");
-        var key = Path.of("/path/to/key.pem");
-
-        var config = TlsConfig.fromFiles(cert, key);
-
-        assertThat(config).isInstanceOf(TlsConfig.FromFiles.class);
-        var fromFiles = (TlsConfig.FromFiles) config;
-        assertThat(fromFiles.certificatePath()).isEqualTo(cert);
-        assertThat(fromFiles.privateKeyPath()).isEqualTo(key);
-        assertThat(fromFiles.keyPassword().isPresent()).isFalse();
-    }
-
-    @Test
-    void fromFiles_with_password_creates_protected_config() {
-        var cert = Path.of("/path/to/cert.pem");
-        var key = Path.of("/path/to/key.pem");
-
-        var config = TlsConfig.fromFiles(cert, key, "secret");
-
-        assertThat(config).isInstanceOf(TlsConfig.FromFiles.class);
-        var fromFiles = (TlsConfig.FromFiles) config;
-        assertThat(fromFiles.keyPassword().isPresent()).isTrue();
-        fromFiles.keyPassword().onPresent(pwd -> assertThat(pwd).isEqualTo("secret"));
-    }
-}
diff --git a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactRepoSlice.java b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactRepoSlice.java
index bfdec4d7..91ee57ec 100644
--- a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactRepoSlice.java
+++ b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactRepoSlice.java
@@ -19,42 +19,38 @@
  * </ul>
  */
 public record ArtifactRepoSlice(
-    MavenProtocolHandler mavenHandler
-) implements Slice {
-
+ MavenProtocolHandler mavenHandler) implements Slice {
     public static ArtifactRepoSlice artifactRepoSlice(ArtifactStore store) {
         return new ArtifactRepoSlice(MavenProtocolHandler.mavenProtocolHandler(store));
     }
 
     @Override
-    public List<SliceMethod<?, ?>> methods() {
+    public List<SliceMethod< ? , ? >> methods() {
         return List.of(
-            new SliceMethod<>(
-                MethodName.methodName("get").unwrap(),
-                this::handleGet,
-                new TypeToken<MavenProtocolHandler.MavenResponse>() {},
-                new TypeToken<RepositoryRequest>() {}
-            ),
-            new SliceMethod<>(
-                MethodName.methodName("put").unwrap(),
-                this::handlePut,
-                new TypeToken<MavenProtocolHandler.MavenResponse>() {},
-                new TypeToken<RepositoryRequest>() {}
-            )
-        );
+        new SliceMethod<>(
+        MethodName.methodName("get")
+                  .unwrap(),
+        this::handleGet,
+        new TypeToken<MavenProtocolHandler.MavenResponse>() {},
+        new TypeToken<RepositoryRequest>() {}),
+        new SliceMethod<>(
+        MethodName.methodName("put")
+                  .unwrap(),
+        this::handlePut,
+        new TypeToken<MavenProtocolHandler.MavenResponse>() {},
+        new TypeToken<RepositoryRequest>() {}));
     }
 
     @Override
     public List<SliceRoute> routes() {
         return List.of(
-            SliceRoute.get("/repository/{path}", "get")
-                .withPathVar("path")
-                .build(),
-            SliceRoute.put("/repository/{path}", "put")
-                .withPathVar("path")
-                .withBody()
-                .build()
-        );
+        SliceRoute.get("/repository/{path}", "get")
+                  .withPathVar("path")
+                  .build(),
+        SliceRoute.put("/repository/{path}", "put")
+                  .withPathVar("path")
+                  .withBody()
+                  .build());
     }
 
     private Promise<MavenProtocolHandler.MavenResponse> handleGet(RepositoryRequest request) {
@@ -69,7 +65,6 @@ private Promise<MavenProtocolHandler.MavenResponse> handlePut(RepositoryRequest
      * Request for repository operations.
      */
     public record RepositoryRequest(
-        String path,
-        byte[] content
-    ) {}
+    String path,
+    byte[] content) {}
 }
diff --git a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactStore.java b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactStore.java
index 407b6b91..d079588c 100644
--- a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactStore.java
+++ b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/ArtifactStore.java
@@ -11,8 +11,6 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
@@ -20,6 +18,9 @@
 import java.util.HexFormat;
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Artifact storage backed by DHT.
  * Stores artifacts in chunks for efficient distribution.
@@ -32,7 +33,6 @@
  * </ul>
  */
 public interface ArtifactStore {
-
     /**
      * Deploy an artifact.
      */
@@ -41,7 +41,7 @@ public interface ArtifactStore {
     /**
      * Resolve an artifact.
      */
-    Promise<byte[]> resolve(Artifact artifact);
+    Promise<byte[] > resolve(Artifact artifact);
 
     /**
      * Check if an artifact exists.
@@ -62,38 +62,31 @@ public interface ArtifactStore {
      * Deployment result with checksums.
      */
     record DeployResult(
-        Artifact artifact,
-        long size,
-        String md5,
-        String sha1
-    ) {}
+    Artifact artifact,
+    long size,
+    String md5,
+    String sha1) {}
 
     /**
      * Artifact metadata.
      */
     record ArtifactMetadata(
-        long size,
-        int chunkCount,
-        String md5,
-        String sha1,
-        long deployedAt
-    ) {
+    long size,
+    int chunkCount,
+    String md5,
+    String sha1,
+    long deployedAt) {
         public byte[] toBytes() {
             var data = size + ":" + chunkCount + ":" + md5 + ":" + sha1 + ":" + deployedAt;
             return data.getBytes(StandardCharsets.UTF_8);
         }
 
         public static Option<ArtifactMetadata> fromBytes(byte[] bytes) {
-            try {
+            try{
                 var parts = new String(bytes, StandardCharsets.UTF_8).split(":");
                 if (parts.length != 5) return Option.none();
                 return Option.some(new ArtifactMetadata(
-                    Long.parseLong(parts[0]),
-                    Integer.parseInt(parts[1]),
-                    parts[2],
-                    parts[3],
-                    Long.parseLong(parts[4])
-                ));
+                Long.parseLong(parts[0]), Integer.parseInt(parts[1]), parts[2], parts[3], Long.parseLong(parts[4])));
             } catch (Exception e) {
                 return Option.none();
             }
@@ -142,10 +135,10 @@ static ArtifactStore artifactStore(DHTClient dht) {
 }
 
 class ArtifactStoreImpl implements ArtifactStore {
-
     private static final Logger log = LoggerFactory.getLogger(ArtifactStoreImpl.class);
-    private static final int CHUNK_SIZE = 64 * 1024; // 64KB chunks
+    private static final int CHUNK_SIZE = 64 * 1024;
 
+    // 64KB chunks
     private final DHTClient dht;
 
     ArtifactStoreImpl(DHTClient dht) {
@@ -155,70 +148,60 @@ class ArtifactStoreImpl implements ArtifactStore {
     @Override
     public Promise<DeployResult> deploy(Artifact artifact, byte[] content) {
         log.info("Deploying artifact: {} ({} bytes)", artifact.asString(), content.length);
-
         var md5 = computeHash(content, "MD5");
         var sha1 = computeHash(content, "SHA-1");
         var chunks = splitIntoChunks(content);
-
         // Store all chunks
         var chunkPromises = new ArrayList<Promise<Unit>>();
-        for (int i = 0; i < chunks.size(); i++) {
+        for (int i = 0; i < chunks.size(); i++ ) {
             var chunkKey = chunkKey(artifact, i);
             chunkPromises.add(dht.put(chunkKey, chunks.get(i)));
         }
-
         // Store metadata after chunks
         var metadata = new ArtifactMetadata(
-            content.length,
-            chunks.size(),
-            md5,
-            sha1,
-            System.currentTimeMillis()
-        );
-
+        content.length, chunks.size(), md5, sha1, System.currentTimeMillis());
         return Promise.allOf(chunkPromises)
-            .flatMap(_ -> dht.put(metaKey(artifact), metadata.toBytes()))
-            .flatMap(_ -> updateVersionsList(artifact))
-            .map(_ -> {
-                log.info("Deployed artifact: {} ({} chunks)", artifact.asString(), chunks.size());
-                return new DeployResult(artifact, content.length, md5, sha1);
-            });
+                      .flatMap(_ -> dht.put(metaKey(artifact),
+                                            metadata.toBytes()))
+                      .flatMap(_ -> updateVersionsList(artifact))
+                      .map(_ -> {
+                               log.info("Deployed artifact: {} ({} chunks)",
+                                        artifact.asString(),
+                                        chunks.size());
+                               return new DeployResult(artifact, content.length, md5, sha1);
+                           });
     }
 
     @Override
-    public Promise<byte[]> resolve(Artifact artifact) {
+    public Promise<byte[] > resolve(Artifact artifact) {
         log.debug("Resolving artifact: {}", artifact.asString());
-
         return dht.get(metaKey(artifact))
-            .flatMap(metaOpt -> metaOpt
-                .flatMap(ArtifactMetadata::fromBytes)
-                .fold(
-                    () -> new ArtifactStoreError.NotFound(artifact).promise(),
-                    meta -> resolveChunks(artifact, meta)
-                ));
+                  .flatMap(metaOpt -> metaOpt.flatMap(ArtifactMetadata::fromBytes)
+                                             .fold(() -> new ArtifactStoreError.NotFound(artifact).promise(),
+                                                   meta -> resolveChunks(artifact, meta)));
     }
 
-    private Promise<byte[]> resolveChunks(Artifact artifact, ArtifactMetadata meta) {
-        var chunkPromises = new ArrayList<Promise<Option<byte[]>>>();
-        for (int i = 0; i < meta.chunkCount(); i++) {
+    private Promise<byte[] > resolveChunks(Artifact artifact, ArtifactMetadata meta) {
+        var chunkPromises = new ArrayList<Promise<Option<byte[] >>>();
+        for (int i = 0; i < meta.chunkCount(); i++ ) {
             chunkPromises.add(dht.get(chunkKey(artifact, i)));
         }
-
         return Promise.allOf(chunkPromises)
-            .flatMap(results -> {
-                var chunks = new ArrayList<byte[]>();
-                for (var result : results) {
-                    if (result.isFailure()) {
-                        return new ArtifactStoreError.ResolveFailed(artifact, "Failed to fetch chunk").promise();
-                    }
-                    var chunkOpt = result.unwrap();
-                    if (chunkOpt.isEmpty()) {
-                        return new ArtifactStoreError.CorruptedArtifact(artifact).promise();
-                    }
-                    chunkOpt.onPresent(chunks::add);
-                }
-                return Promise.success(reassembleChunks(chunks, (int) meta.size()));
-            });
+                      .flatMap(results -> {
+                                   var chunks = new ArrayList<byte[] >();
+                                   for (var result : results) {
+                                   if (result.isFailure()) {
+                                   return new ArtifactStoreError.ResolveFailed(artifact, "Failed to fetch chunk").promise();
+                               }
+                                   var chunkOpt = result.unwrap();
+                                   if (chunkOpt.isEmpty()) {
+                                   return new ArtifactStoreError.CorruptedArtifact(artifact).promise();
+                               }
+                                   chunkOpt.onPresent(chunks::add);
+                               }
+                                   return Promise.success(reassembleChunks(chunks,
+                                                                           (int) meta.size()));
+                               });
     }
 
     @Override
@@ -230,44 +213,41 @@ public Promise<Boolean> exists(Artifact artifact) {
     public Promise<List<Version>> versions(GroupId groupId, ArtifactId artifactId) {
         var versionsKey = versionsKey(groupId, artifactId);
         return dht.get(versionsKey)
-            .map(opt -> opt
-                .map(this::parseVersionsList)
-                .or(List.of()));
+                  .map(opt -> opt.map(this::parseVersionsList)
+                                 .or(List.of()));
     }
 
     @Override
     public Promise<Unit> delete(Artifact artifact) {
         log.info("Deleting artifact: {}", artifact.asString());
-
         return dht.get(metaKey(artifact))
-            .flatMap(metaOpt -> metaOpt
-                .flatMap(ArtifactMetadata::fromBytes)
-                .fold(
-                    () -> Promise.success(Unit.unit()),
-                    meta -> deleteChunksAndMeta(artifact, meta)
-                ));
+                  .flatMap(metaOpt -> metaOpt.flatMap(ArtifactMetadata::fromBytes)
+                                             .fold(() -> Promise.success(Unit.unit()),
+                                                   meta -> deleteChunksAndMeta(artifact, meta)));
     }
 
     private Promise<Unit> deleteChunksAndMeta(Artifact artifact, ArtifactMetadata meta) {
         var deletePromises = new ArrayList<Promise<Boolean>>();
-        for (int i = 0; i < meta.chunkCount(); i++) {
+        for (int i = 0; i < meta.chunkCount(); i++ ) {
             deletePromises.add(dht.remove(chunkKey(artifact, i)));
         }
         deletePromises.add(dht.remove(metaKey(artifact)));
-
-        return Promise.allOf(deletePromises).mapToUnit();
+        return Promise.allOf(deletePromises)
+                      .mapToUnit();
     }
 
     private Promise<Unit> updateVersionsList(Artifact artifact) {
         var versionsKey = versionsKey(artifact.groupId(), artifact.artifactId());
         return dht.get(versionsKey)
-            .flatMap(opt -> {
-                var versions = new ArrayList<>(opt.map(this::parseVersionsList).or(List.of()));
-                if (!versions.contains(artifact.version())) {
-                    versions.add(artifact.version());
-                }
-                return dht.put(versionsKey, serializeVersionsList(versions));
-            });
+                  .flatMap(opt -> {
+                               var versions = new ArrayList<>(opt.map(this::parseVersionsList)
+                                                                 .or(List.of()));
+                               if (!versions.contains(artifact.version())) {
+                               versions.add(artifact.version());
+                           }
+                               return dht.put(versionsKey,
+                                              serializeVersionsList(versions));
+                           });
     }
 
     private List<Version> parseVersionsList(byte[] data) {
@@ -275,27 +255,33 @@ private List<Version> parseVersionsList(byte[] data) {
         if (str.isEmpty()) return new ArrayList<>();
         var versions = new ArrayList<Version>();
         for (var v : str.split(",")) {
-            Version.version(v).onSuccess(versions::add);
+            Version.version(v)
+                   .onSuccess(versions::add);
         }
         return versions;
     }
 
     private byte[] serializeVersionsList(List<Version> versions) {
-        var str = String.join(",", versions.stream().map(Version::withQualifier).toList());
+        var str = String.join(",",
+                              versions.stream()
+                                      .map(Version::withQualifier)
+                                      .toList());
         return str.getBytes(StandardCharsets.UTF_8);
     }
 
     private byte[] metaKey(Artifact artifact) {
-        var key = "artifacts/" + artifact.groupId().id() + "/" +
-                  artifact.artifactId().id() + "/" +
-                  artifact.version().withQualifier() + "/meta";
+        var key = "artifacts/" + artifact.groupId()
+                                         .id() + "/" + artifact.artifactId()
+                                                               .id() + "/" + artifact.version()
+                                                                                     .withQualifier() + "/meta";
         return key.getBytes(StandardCharsets.UTF_8);
     }
 
     private byte[] chunkKey(Artifact artifact, int index) {
-        var key = "artifacts/" + artifact.groupId().id() + "/" +
-                  artifact.artifactId().id() + "/" +
-                  artifact.version().withQualifier() + "/content/" + index;
+        var key = "artifacts/" + artifact.groupId()
+                                         .id() + "/" + artifact.artifactId()
+                                                               .id() + "/" + artifact.version()
+                                                                                     .withQualifier() + "/content/" + index;
         return key.getBytes(StandardCharsets.UTF_8);
     }
 
@@ -304,8 +290,8 @@ private byte[] versionsKey(GroupId groupId, ArtifactId artifactId) {
         return key.getBytes(StandardCharsets.UTF_8);
     }
 
-    private List<byte[]> splitIntoChunks(byte[] content) {
-        var chunks = new ArrayList<byte[]>();
+    private List<byte[] > splitIntoChunks(byte[] content) {
+        var chunks = new ArrayList<byte[] >();
         int offset = 0;
         while (offset < content.length) {
             int length = Math.min(CHUNK_SIZE, content.length - offset);
@@ -317,7 +303,7 @@ private List<byte[]> splitIntoChunks(byte[] content) {
         return chunks;
     }
 
-    private byte[] reassembleChunks(List<byte[]> chunks, int totalSize) {
+    private byte[] reassembleChunks(List<byte[] > chunks, int totalSize) {
         var result = new byte[totalSize];
         int offset = 0;
         for (var chunk : chunks) {
@@ -328,10 +314,11 @@ private byte[] reassembleChunks(List<byte[]> chunks, int totalSize) {
     }
 
     private String computeHash(byte[] content, String algorithm) {
-        try {
+        try{
             var md = MessageDigest.getInstance(algorithm);
             var hash = md.digest(content);
-            return HexFormat.of().formatHex(hash);
+            return HexFormat.of()
+                            .formatHex(hash);
         } catch (Exception e) {
             return "";
         }
diff --git a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/MavenProtocolHandler.java b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/MavenProtocolHandler.java
index 9dec4a7c..6a6183ba 100644
--- a/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/MavenProtocolHandler.java
+++ b/infra-services/artifact-repo/src/main/java/org/pragmatica/aether/infra/artifact/MavenProtocolHandler.java
@@ -9,8 +9,6 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.nio.charset.StandardCharsets;
 import java.time.Instant;
@@ -18,6 +16,9 @@
 import java.time.format.DateTimeFormatter;
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Handler for Maven repository protocol.
  * Supports GET for artifact resolution and PUT for deployment.
@@ -30,7 +31,6 @@
  * </ul>
  */
 public interface MavenProtocolHandler {
-
     /**
      * Handle a GET request.
      */
@@ -45,10 +45,9 @@ public interface MavenProtocolHandler {
      * Response from Maven protocol handler.
      */
     record MavenResponse(
-        int statusCode,
-        String contentType,
-        byte[] content
-    ) {
+    int statusCode,
+    String contentType,
+    byte[] content) {
         public static MavenResponse ok(byte[] content, String contentType) {
             return new MavenResponse(200, contentType, content);
         }
@@ -75,7 +74,9 @@ public static MavenResponse serverError(String message) {
      */
     sealed interface ParsedPath {
         record ArtifactPath(Artifact artifact, String classifier, String extension) implements ParsedPath {}
+
         record MetadataPath(GroupId groupId, ArtifactId artifactId) implements ParsedPath {}
+
         record ChecksumPath(ParsedPath inner, String algorithm) implements ParsedPath {}
     }
 
@@ -88,7 +89,6 @@ static MavenProtocolHandler mavenProtocolHandler(ArtifactStore store) {
 }
 
 class MavenProtocolHandlerImpl implements MavenProtocolHandler {
-
     private static final Logger log = LoggerFactory.getLogger(MavenProtocolHandlerImpl.class);
     private static final String REPOSITORY_PREFIX = "/repository/";
 
@@ -101,16 +101,13 @@ class MavenProtocolHandlerImpl implements MavenProtocolHandler {
     @Override
     public Promise<MavenResponse> handleGet(String path) {
         log.debug("GET {}", path);
-
         if (!path.startsWith(REPOSITORY_PREFIX)) {
             return Promise.success(MavenResponse.notFound("Invalid path"));
         }
-
         var repoPath = path.substring(REPOSITORY_PREFIX.length());
-        return parsePath(repoPath).fold(
-            () -> Promise.success(MavenResponse.badRequest("Cannot parse path: " + path)),
-            parsed -> handleGetParsed(parsed)
-        );
+        return parsePath(repoPath)
+               .fold(() -> Promise.success(MavenResponse.badRequest("Cannot parse path: " + path)),
+                     parsed -> handleGetParsed(parsed));
     }
 
     private Promise<MavenResponse> handleGetParsed(ParsedPath parsed) {
@@ -123,35 +120,43 @@ private Promise<MavenResponse> handleGetParsed(ParsedPath parsed) {
 
     private Promise<MavenResponse> handleGetArtifact(ParsedPath.ArtifactPath ap) {
         return store.resolve(ap.artifact())
-            .map(content -> MavenResponse.ok(content, contentTypeFor(ap.extension())))
-            .recover(cause -> {
-                if (cause instanceof ArtifactStore.ArtifactStoreError.NotFound) {
-                    return MavenResponse.notFound("Artifact not found: " + ap.artifact().asString());
-                }
-                return MavenResponse.serverError(cause.message());
-            });
+                    .map(content -> MavenResponse.ok(content,
+                                                     contentTypeFor(ap.extension())))
+                    .recover(cause -> {
+                                 if (cause instanceof ArtifactStore.ArtifactStoreError.NotFound) {
+                                 return MavenResponse.notFound("Artifact not found: " + ap.artifact()
+                                                                                         .asString());
+                             }
+                                 return MavenResponse.serverError(cause.message());
+                             });
     }
 
     private Promise<MavenResponse> handleGetMetadata(ParsedPath.MetadataPath mp) {
-        return store.versions(mp.groupId(), mp.artifactId())
-            .map(versions -> {
-                if (versions.isEmpty()) {
-                    return MavenResponse.notFound("No versions found");
-                }
-                var xml = generateMavenMetadata(mp.groupId(), mp.artifactId(), versions);
-                return MavenResponse.ok(xml.getBytes(StandardCharsets.UTF_8), "application/xml");
-            });
+        return store.versions(mp.groupId(),
+                              mp.artifactId())
+                    .map(versions -> {
+                             if (versions.isEmpty()) {
+                             return MavenResponse.notFound("No versions found");
+                         }
+                             var xml = generateMavenMetadata(mp.groupId(),
+                                                             mp.artifactId(),
+                                                             versions);
+                             return MavenResponse.ok(xml.getBytes(StandardCharsets.UTF_8),
+                                                     "application/xml");
+                         });
     }
 
     private Promise<MavenResponse> handleGetChecksum(ParsedPath.ChecksumPath cp) {
         // For checksums, we need to resolve the inner artifact first
         if (cp.inner() instanceof ParsedPath.ArtifactPath ap) {
             return store.resolve(ap.artifact())
-                .map(content -> {
-                    var checksum = computeChecksum(content, cp.algorithm());
-                    return MavenResponse.ok(checksum.getBytes(StandardCharsets.UTF_8), "text/plain");
-                })
-                .recover(cause -> MavenResponse.notFound("Artifact not found"));
+                        .map(content -> {
+                                 var checksum = computeChecksum(content,
+                                                                cp.algorithm());
+                                 return MavenResponse.ok(checksum.getBytes(StandardCharsets.UTF_8),
+                                                         "text/plain");
+                             })
+                        .recover(cause -> MavenResponse.notFound("Artifact not found"));
         }
         return Promise.success(MavenResponse.badRequest("Invalid checksum path"));
     }
@@ -159,55 +164,53 @@ private Promise<MavenResponse> handleGetChecksum(ParsedPath.ChecksumPath cp) {
     @Override
     public Promise<MavenResponse> handlePut(String path, byte[] content) {
         log.debug("PUT {} ({} bytes)", path, content.length);
-
         if (!path.startsWith(REPOSITORY_PREFIX)) {
             return Promise.success(MavenResponse.badRequest("Invalid path"));
         }
-
         var repoPath = path.substring(REPOSITORY_PREFIX.length());
-        return parsePath(repoPath).fold(
-            () -> Promise.success(MavenResponse.badRequest("Cannot parse path: " + path)),
-            parsed -> handlePutParsed(parsed, content)
-        );
+        return parsePath(repoPath)
+               .fold(() -> Promise.success(MavenResponse.badRequest("Cannot parse path: " + path)),
+                     parsed -> handlePutParsed(parsed, content));
     }
 
     private Promise<MavenResponse> handlePutParsed(ParsedPath parsed, byte[] content) {
         return switch (parsed) {
-            case ParsedPath.ArtifactPath ap when ap.extension().equals("jar") ->
-                store.deploy(ap.artifact(), content)
-                    .map(_ -> MavenResponse.created())
-                    .recover(cause -> MavenResponse.serverError(cause.message()));
+            case ParsedPath.ArtifactPath ap when ap.extension()
+                                                   .equals("jar") ->
+            store.deploy(ap.artifact(),
+                         content)
+                 .map(_ -> MavenResponse.created())
+                 .recover(cause -> MavenResponse.serverError(cause.message()));
             case ParsedPath.ArtifactPath _ ->
-                // Accept POM, checksums etc. silently (we don't store them separately)
-                Promise.success(MavenResponse.created());
+            // Accept POM, checksums etc. silently (we don't store them separately)
+            Promise.success(MavenResponse.created());
             case ParsedPath.ChecksumPath _ ->
-                // Checksums are computed, not stored
-                Promise.success(MavenResponse.created());
+            // Checksums are computed, not stored
+            Promise.success(MavenResponse.created());
             case ParsedPath.MetadataPath _ ->
-                // Metadata is generated, not stored
-                Promise.success(MavenResponse.created());
+            // Metadata is generated, not stored
+            Promise.success(MavenResponse.created());
         };
     }
 
     private Option<ParsedPath> parsePath(String path) {
         // Check for checksum suffix
         if (path.endsWith(".md5")) {
-            return parsePath(path.substring(0, path.length() - 4))
-                .map(inner -> new ParsedPath.ChecksumPath(inner, "MD5"));
+            return parsePath(path.substring(0,
+                                            path.length() - 4))
+                   .map(inner -> new ParsedPath.ChecksumPath(inner, "MD5"));
         }
         if (path.endsWith(".sha1")) {
-            return parsePath(path.substring(0, path.length() - 5))
-                .map(inner -> new ParsedPath.ChecksumPath(inner, "SHA-1"));
+            return parsePath(path.substring(0,
+                                            path.length() - 5))
+                   .map(inner -> new ParsedPath.ChecksumPath(inner, "SHA-1"));
         }
-
         var parts = path.split("/");
         if (parts.length < 3) return Option.none();
-
         // Check for maven-metadata.xml
         if (parts[parts.length - 1].equals("maven-metadata.xml")) {
             return parseMetadataPath(parts);
         }
-
         // Parse artifact path: groupPath/artifactId/version/file
         return parseArtifactPath(parts);
     }
@@ -215,62 +218,59 @@ private Option<ParsedPath> parsePath(String path) {
     private Option<ParsedPath> parseMetadataPath(String[] parts) {
         // groupPath/artifactId/maven-metadata.xml
         if (parts.length < 3) return Option.none();
-
         var artifactIdStr = parts[parts.length - 2];
         var groupPath = new StringBuilder();
-        for (int i = 0; i < parts.length - 2; i++) {
+        for (int i = 0; i < parts.length - 2; i++ ) {
             if (i > 0) groupPath.append(".");
             groupPath.append(parts[i]);
         }
-
-        return Result.all(
-            GroupId.groupId(groupPath.toString()),
-            ArtifactId.artifactId(artifactIdStr)
-        ).map((groupId, artifactId) -> Option.<ParsedPath>some(new ParsedPath.MetadataPath(groupId, artifactId)))
-         .or(Option.none());
+        return Result.all(GroupId.groupId(groupPath.toString()),
+                          ArtifactId.artifactId(artifactIdStr))
+                     .map((groupId, artifactId) -> Option.<ParsedPath>some(new ParsedPath.MetadataPath(groupId,
+                                                                                                       artifactId)))
+                     .or(Option.none());
     }
 
     private Option<ParsedPath> parseArtifactPath(String[] parts) {
         // groupPath/artifactId/version/file
         if (parts.length < 4) return Option.none();
-
         var fileName = parts[parts.length - 1];
         var versionStr = parts[parts.length - 2];
         var artifactIdStr = parts[parts.length - 3];
-
         var groupPath = new StringBuilder();
-        for (int i = 0; i < parts.length - 3; i++) {
+        for (int i = 0; i < parts.length - 3; i++ ) {
             if (i > 0) groupPath.append(".");
             groupPath.append(parts[i]);
         }
-
         // Parse file name: artifactId-version[-classifier].extension
         var extension = extractExtension(fileName);
         var classifier = extractClassifier(fileName, artifactIdStr, versionStr);
-
-        return Result.all(
-            GroupId.groupId(groupPath.toString()),
-            ArtifactId.artifactId(artifactIdStr),
-            Version.version(versionStr)
-        ).map((groupId, artifactId, version) -> {
-            var artifact = new Artifact(groupId, artifactId, version);
-            return Option.<ParsedPath>some(new ParsedPath.ArtifactPath(artifact, classifier, extension));
-        }).or(Option.none());
+        return Result.all(GroupId.groupId(groupPath.toString()),
+                          ArtifactId.artifactId(artifactIdStr),
+                          Version.version(versionStr))
+                     .map((groupId, artifactId, version) -> {
+                              var artifact = new Artifact(groupId, artifactId, version);
+                              return Option.<ParsedPath>some(new ParsedPath.ArtifactPath(artifact, classifier, extension));
+                          })
+                     .or(Option.none());
     }
 
     private String extractExtension(String fileName) {
         var lastDot = fileName.lastIndexOf('.');
-        return lastDot > 0 ? fileName.substring(lastDot + 1) : "";
+        return lastDot > 0
+               ? fileName.substring(lastDot + 1)
+               : "";
     }
 
     private String extractClassifier(String fileName, String artifactId, String version) {
         var prefix = artifactId + "-" + version;
         if (!fileName.startsWith(prefix)) return "";
-
         var remainder = fileName.substring(prefix.length());
         if (remainder.startsWith("-")) {
             var dotIndex = remainder.indexOf('.');
-            return dotIndex > 1 ? remainder.substring(1, dotIndex) : "";
+            return dotIndex > 1
+                   ? remainder.substring(1, dotIndex)
+                   : "";
         }
         return "";
     }
@@ -278,47 +278,59 @@ private String extractClassifier(String fileName, String artifactId, String vers
     private String generateMavenMetadata(GroupId groupId, ArtifactId artifactId, List<Version> versions) {
         var latest = versions.getLast();
         var release = versions.stream()
-            .filter(v -> !v.withQualifier().contains("SNAPSHOT"))
-            .reduce((a, b) -> b)
-            .orElse(latest);
-
+                              .filter(v -> !v.withQualifier()
+                                             .contains("SNAPSHOT"))
+                              .reduce((a, b) -> b)
+                              .orElse(latest);
         var timestamp = DateTimeFormatter.ofPattern("yyyyMMddHHmmss")
-            .format(Instant.now().atOffset(ZoneOffset.UTC));
-
+                                         .format(Instant.now()
+                                                        .atOffset(ZoneOffset.UTC));
         var sb = new StringBuilder();
         sb.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
         sb.append("<metadata>\n");
-        sb.append("  <groupId>").append(groupId.id()).append("</groupId>\n");
-        sb.append("  <artifactId>").append(artifactId.id()).append("</artifactId>\n");
+        sb.append("  <groupId>")
+          .append(groupId.id())
+          .append("</groupId>\n");
+        sb.append("  <artifactId>")
+          .append(artifactId.id())
+          .append("</artifactId>\n");
         sb.append("  <versioning>\n");
-        sb.append("    <latest>").append(latest.withQualifier()).append("</latest>\n");
-        sb.append("    <release>").append(release.withQualifier()).append("</release>\n");
+        sb.append("    <latest>")
+          .append(latest.withQualifier())
+          .append("</latest>\n");
+        sb.append("    <release>")
+          .append(release.withQualifier())
+          .append("</release>\n");
         sb.append("    <versions>\n");
         for (var v : versions) {
-            sb.append("      <version>").append(v.withQualifier()).append("</version>\n");
+            sb.append("      <version>")
+              .append(v.withQualifier())
+              .append("</version>\n");
         }
         sb.append("    </versions>\n");
-        sb.append("    <lastUpdated>").append(timestamp).append("</lastUpdated>\n");
+        sb.append("    <lastUpdated>")
+          .append(timestamp)
+          .append("</lastUpdated>\n");
         sb.append("  </versioning>\n");
         sb.append("</metadata>\n");
-
         return sb.toString();
     }
 
     private String contentTypeFor(String extension) {
         return switch (extension) {
-            case "jar" -> "application/java-archive";
-            case "pom" -> "application/xml";
-            case "xml" -> "application/xml";
+            case"jar" -> "application/java-archive";
+            case"pom" -> "application/xml";
+            case"xml" -> "application/xml";
             default -> "application/octet-stream";
         };
     }
 
     private String computeChecksum(byte[] content, String algorithm) {
-        try {
+        try{
             var md = java.security.MessageDigest.getInstance(algorithm);
             var hash = md.digest(content);
-            return java.util.HexFormat.of().formatHex(hash);
+            return java.util.HexFormat.of()
+                       .formatHex(hash);
         } catch (Exception e) {
             return "";
         }
diff --git a/jbct-bug-report.md b/jbct-bug-report.md
new file mode 100644
index 00000000..5f3e37ec
--- /dev/null
+++ b/jbct-bug-report.md
@@ -0,0 +1,133 @@
+# jbct-maven-plugin 0.4.0 Parse Error Bug Report
+
+## Summary
+
+jbct-maven-plugin 0.4.0 fails to parse valid Java 21+ source files with "Parse error at line 1:1".
+
+## Environment
+
+- **jbct-maven-plugin version**: 0.4.0
+- **Java version**: 25 (configured in pom.xml)
+- **Maven version**: 3.9.11
+- **OS**: macOS Darwin 24.6.0
+
+## Error Message
+
+```
+[ERROR] Error formatting .../FrameworkClassLoader.java: Parse error at FrameworkClassLoader.java:1:1 - Parse error
+[ERROR] Error formatting .../SharedDependencyLoader.java: Parse error at SharedDependencyLoader.java:1:1 - Parse error
+[ERROR] Failed to execute goal org.pragmatica-lite:jbct-maven-plugin:0.4.0:format (default) on project slice: Formatting failed for 2 file(s)
+```
+
+## Affected Files
+
+### 1. FrameworkClassLoader.java
+
+**Location**: `slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java`
+
+**Java features used**:
+- Method references: `Causes::fromThrowable`, `FrameworkClassLoader::toUrl`
+- Array constructor references: `urls.toArray(URL[]::new)`
+- Try-with-resources with `Stream<Path>`
+- `var` local variable type inference
+
+**Minimal reproduction** (standard Java 11+ code):
+```java
+package org.pragmatica.aether.slice;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.List;
+
+public class FrameworkClassLoader extends URLClassLoader {
+
+    public FrameworkClassLoader(URL[] frameworkJars) {
+        super(frameworkJars, ClassLoader.getPlatformClassLoader());
+    }
+
+    public static FrameworkClassLoader fromJars(Path... jarPaths) {
+        var urls = new ArrayList<URL>();
+        // ... processing
+        return new FrameworkClassLoader(urls.toArray(URL[]::new));
+    }
+}
+```
+
+### 2. SharedDependencyLoader.java
+
+**Location**: `slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java`
+
+**Java features used** (likely causing the parse error):
+
+1. **Unnamed variable `_`** (Java 22 preview / Java 23+):
+```java
+.flatMap(_ -> processApiSequentially(remaining, sharedLibraryLoader, repository));
+```
+
+2. **`List.getFirst()`** (Java 21+):
+```java
+var dependency = dependencies.getFirst();
+```
+
+3. **Pattern matching in switch with record patterns** (Java 21+):
+```java
+result -> switch (result) {
+    case CompatibilityResult.Compatible(var loadedVersion) -> {
+        // ...
+        yield Promise.success(null);
+    }
+    case CompatibilityResult.Conflict(var loadedVersion, var required) -> {
+        // ...
+        yield loadConflictIntoSlice(dependency, repository, conflictUrls);
+    }
+}
+```
+
+4. **Exhaustive switch on sealed type with record deconstruction**:
+```java
+return switch (pattern) {
+    case VersionPattern.Exact(Version version) -> version;
+    case VersionPattern.Range(Version from, _, _, _) -> from;
+    case VersionPattern.Comparison(_, Version version) -> version;
+    case VersionPattern.Tilde(Version version) -> version;
+    case VersionPattern.Caret(Version version) -> version;
+};
+```
+
+## Root Cause Analysis
+
+The parser likely does not support:
+
+1. **Unnamed variable `_`** - Introduced as preview in Java 22, finalized in Java 23
+2. **Record patterns in switch** - Java 21 feature
+3. **Pattern matching for switch** - Java 21 feature
+4. **`List.getFirst()`** method - Java 21 SequencedCollection API
+
+The error occurring at "line 1:1" suggests the parser fails during initial tokenization or grammar recognition, possibly due to unsupported language level.
+
+## Expected Behavior
+
+The formatter should either:
+1. Successfully parse and format Java 21+ source files
+2. Provide a meaningful error message indicating which language feature is unsupported
+3. Skip files with unsupported features (with warning) rather than failing the build
+
+## Workaround
+
+Currently using `<skip>true</skip>` in plugin configuration.
+
+## Suggested Fix
+
+Update the Java parser to support Java 21+ language features, specifically:
+- Record patterns (JEP 440)
+- Pattern matching for switch (JEP 441)
+- Unnamed patterns and variables (JEP 456)
+- SequencedCollection API methods
+
+## Full File Contents
+
+See attached files or repository:
+- https://github.com/siy/aether/blob/release-0.6.3/slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java
+- https://github.com/siy/aether/blob/release-0.6.3/slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java
diff --git a/node/src/main/java/org/pragmatica/aether/Main.java b/node/src/main/java/org/pragmatica/aether/Main.java
index 2e2e0c67..09da99ac 100644
--- a/node/src/main/java/org/pragmatica/aether/Main.java
+++ b/node/src/main/java/org/pragmatica/aether/Main.java
@@ -4,12 +4,13 @@
 import org.pragmatica.aether.node.AetherNodeConfig;
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.net.NodeInfo;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.Arrays;
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
 import static org.pragmatica.net.NodeAddress.nodeAddress;
 
@@ -36,68 +37,69 @@ private void run() {
         var nodeId = parseNodeId();
         var port = parsePort();
         var peers = parsePeers(nodeId, port);
-
         log.info("Starting Aether node {} on port {}", nodeId, port);
         log.info("Peers: {}", peers);
-
         var config = AetherNodeConfig.aetherNodeConfig(nodeId, port, peers);
         var node = AetherNode.aetherNode(config);
-
         // Register shutdown hook
-        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
-            log.info("Shutdown requested, stopping node...");
-            node.stop().await();
-            log.info("Node stopped");
-        }));
-
+        Runtime.getRuntime()
+               .addShutdownHook(new Thread(() -> {
+                                               log.info("Shutdown requested, stopping node...");
+                                               node.stop()
+                                                   .await();
+                                               log.info("Node stopped");
+                                           }));
         // Start the node
         node.start()
             .onSuccess(_ -> log.info("Node {} is running. Press Ctrl+C to stop.", nodeId))
             .onFailure(cause -> {
-                log.error("Failed to start node: {}", cause.message());
+                log.error("Failed to start node: {}",
+                          cause.message());
                 System.exit(1);
             })
             .await();
-
         // Keep main thread alive
-        try {
-            Thread.currentThread().join();
+        try{
+            Thread.currentThread()
+                  .join();
         } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
     private NodeId parseNodeId() {
         return findArg("--node-id=")
-                .map(NodeId::nodeId)
-                .orElseGet(NodeId::randomNodeId);
+               .map(NodeId::nodeId)
+               .orElseGet(NodeId::randomNodeId);
     }
 
     private int parsePort() {
         return findArg("--port=")
-                .map(Integer::parseInt)
-                .orElse(8090);
+               .map(Integer::parseInt)
+               .orElse(8090);
     }
 
     private List<NodeInfo> parsePeers(NodeId self, int selfPort) {
         var selfInfo = nodeInfo(self, nodeAddress("localhost", selfPort));
-
         return findArg("--peers=")
-                .map(peersStr -> Arrays.stream(peersStr.split(","))
-                                       .map(String::trim)
-                                       .filter(s -> !s.isEmpty())
-                                       .map(this::parsePeerAddress)
-                                       .toList())
-                .map(peers -> {
-                    // Include self in the peer list if not already there
-                    if (peers.stream().noneMatch(p -> p.id().equals(self))) {
+               .map(peersStr -> Arrays.stream(peersStr.split(","))
+                                      .map(String::trim)
+                                      .filter(s -> !s.isEmpty())
+                                      .map(this::parsePeerAddress)
+                                      .toList())
+               .map(peers -> {
+                        // Include self in the peer list if not already there
+        if (peers.stream()
+                 .noneMatch(p -> p.id()
+                                  .equals(self))) {
                         var allPeers = new java.util.ArrayList<>(peers);
                         allPeers.add(selfInfo);
                         return List.copyOf(allPeers);
                     }
-                    return peers;
-                })
-                .orElse(List.of(selfInfo));
+                        return peers;
+                    })
+               .orElse(List.of(selfInfo));
     }
 
     private NodeInfo parsePeerAddress(String peerStr) {
@@ -108,14 +110,15 @@ private NodeInfo parsePeerAddress(String peerStr) {
             // Generate node ID from address for discovery
             var nodeId = NodeId.nodeId("node-" + host + "-" + port);
             return nodeInfo(nodeId, nodeAddress(host, port));
-        } else if (parts.length == 3) {
+        }else if (parts.length == 3) {
             // Format: nodeId:host:port
             var nodeId = NodeId.nodeId(parts[0]);
             var host = parts[1];
             var port = Integer.parseInt(parts[2]);
             return nodeInfo(nodeId, nodeAddress(host, port));
         }
-        throw new IllegalArgumentException("Invalid peer format: " + peerStr + ". Expected host:port or nodeId:host:port");
+        throw new IllegalArgumentException("Invalid peer format: " + peerStr
+                                           + ". Expected host:port or nodeId:host:port");
     }
 
     private java.util.Optional<String> findArg(String prefix) {
diff --git a/node/src/main/java/org/pragmatica/aether/api/AlertManager.java b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
index 8ea1e383..8e7d9e6c 100644
--- a/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
+++ b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
@@ -1,21 +1,21 @@
 package org.pragmatica.aether.api;
 
 import org.pragmatica.cluster.net.NodeId;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Manages alert thresholds and tracks active alerts.
  *
  * <p>In-memory only - thresholds reset on node restart.
  */
 public class AlertManager {
-
     private static final Logger log = LoggerFactory.getLogger(AlertManager.class);
     private static final int MAX_ALERT_HISTORY = 100;
 
@@ -44,11 +44,9 @@ public String checkThreshold(String metric, NodeId nodeId, double value) {
         if (threshold == null) {
             return null;
         }
-
         var alertKey = metric + ":" + nodeId.id();
         var existing = activeAlerts.get(alertKey);
         var severity = threshold.severity(value);
-
         if (severity == null) {
             // Value is normal, clear any existing alert
             if (existing != null) {
@@ -57,39 +55,32 @@ public String checkThreshold(String metric, NodeId nodeId, double value) {
             }
             return null;
         }
-
         // Check if this is a new alert or severity change
         if (existing == null || !existing.severity.equals(severity)) {
-            var alert = new ActiveAlert(metric, nodeId, value, threshold.forSeverity(severity), severity, System.currentTimeMillis());
+            var alert = new ActiveAlert(metric,
+                                        nodeId,
+                                        value,
+                                        threshold.forSeverity(severity),
+                                        severity,
+                                        System.currentTimeMillis());
             activeAlerts.put(alertKey, alert);
             addToHistory(metric, nodeId, value, severity, "TRIGGERED");
-
             // Return alert message to broadcast
             return buildAlertMessage(alert);
         }
-
-        return null; // No change
+        return null;
     }
 
     private String buildAlertMessage(ActiveAlert alert) {
-        return "{\"type\":\"ALERT\",\"timestamp\":" + System.currentTimeMillis() + ",\"data\":{" +
-                "\"metric\":\"" + alert.metric + "\"," +
-                "\"nodeId\":\"" + alert.nodeId.id() + "\"," +
-                "\"value\":" + alert.value + "," +
-                "\"threshold\":" + alert.threshold + "," +
-                "\"severity\":\"" + alert.severity + "\"}}";
+        return "{\"type\":\"ALERT\",\"timestamp\":" + System.currentTimeMillis() + ",\"data\":{" + "\"metric\":\"" + alert.metric
+               + "\"," + "\"nodeId\":\"" + alert.nodeId.id() + "\"," + "\"value\":" + alert.value + ","
+               + "\"threshold\":" + alert.threshold + "," + "\"severity\":\"" + alert.severity + "\"}}";
     }
 
     private void addToHistory(String metric, NodeId nodeId, double value, String severity, String status) {
         synchronized (alertHistory) {
             alertHistory.add(new AlertHistoryEntry(
-                    System.currentTimeMillis(),
-                    metric,
-                    nodeId.id(),
-                    value,
-                    severity,
-                    status
-            ));
+            System.currentTimeMillis(), metric, nodeId.id(), value, severity, status));
             while (alertHistory.size() > MAX_ALERT_HISTORY) {
                 alertHistory.remove(0);
             }
@@ -105,9 +96,14 @@ public String thresholdsAsJson() {
         boolean first = true;
         for (var entry : thresholds.entrySet()) {
             if (!first) sb.append(",");
-            sb.append("\"").append(entry.getKey()).append("\":{");
-            sb.append("\"warning\":").append(entry.getValue().warning).append(",");
-            sb.append("\"critical\":").append(entry.getValue().critical);
+            sb.append("\"")
+              .append(entry.getKey())
+              .append("\":{");
+            sb.append("\"warning\":")
+              .append(entry.getValue().warning)
+              .append(",");
+            sb.append("\"critical\":")
+              .append(entry.getValue().critical);
             sb.append("}");
             first = false;
         }
@@ -125,12 +121,23 @@ public String activeAlertsAsJson() {
         for (var alert : activeAlerts.values()) {
             if (!first) sb.append(",");
             sb.append("{");
-            sb.append("\"metric\":\"").append(alert.metric).append("\",");
-            sb.append("\"nodeId\":\"").append(alert.nodeId.id()).append("\",");
-            sb.append("\"value\":").append(alert.value).append(",");
-            sb.append("\"threshold\":").append(alert.threshold).append(",");
-            sb.append("\"severity\":\"").append(alert.severity).append("\",");
-            sb.append("\"triggeredAt\":").append(alert.triggeredAt);
+            sb.append("\"metric\":\"")
+              .append(alert.metric)
+              .append("\",");
+            sb.append("\"nodeId\":\"")
+              .append(alert.nodeId.id())
+              .append("\",");
+            sb.append("\"value\":")
+              .append(alert.value)
+              .append(",");
+            sb.append("\"threshold\":")
+              .append(alert.threshold)
+              .append(",");
+            sb.append("\"severity\":\"")
+              .append(alert.severity)
+              .append("\",");
+            sb.append("\"triggeredAt\":")
+              .append(alert.triggeredAt);
             sb.append("}");
             first = false;
         }
@@ -149,12 +156,24 @@ public String alertHistoryAsJson() {
             for (var entry : alertHistory) {
                 if (!first) sb.append(",");
                 sb.append("{");
-                sb.append("\"timestamp\":").append(entry.timestamp).append(",");
-                sb.append("\"metric\":\"").append(entry.metric).append("\",");
-                sb.append("\"nodeId\":\"").append(entry.nodeId).append("\",");
-                sb.append("\"value\":").append(entry.value).append(",");
-                sb.append("\"severity\":\"").append(entry.severity).append("\",");
-                sb.append("\"status\":\"").append(entry.status).append("\"");
+                sb.append("\"timestamp\":")
+                  .append(entry.timestamp)
+                  .append(",");
+                sb.append("\"metric\":\"")
+                  .append(entry.metric)
+                  .append("\",");
+                sb.append("\"nodeId\":\"")
+                  .append(entry.nodeId)
+                  .append("\",");
+                sb.append("\"value\":")
+                  .append(entry.value)
+                  .append(",");
+                sb.append("\"severity\":\"")
+                  .append(entry.severity)
+                  .append("\",");
+                sb.append("\"status\":\"")
+                  .append(entry.status)
+                  .append("\"");
                 sb.append("}");
                 first = false;
             }
@@ -171,11 +190,23 @@ String severity(double value) {
         }
 
         double forSeverity(String severity) {
-            return "CRITICAL".equals(severity) ? critical : warning;
+            return "CRITICAL".equals(severity)
+                   ? critical
+                   : warning;
         }
     }
 
-    private record ActiveAlert(String metric, NodeId nodeId, double value, double threshold, String severity, long triggeredAt) {}
-
-    private record AlertHistoryEntry(long timestamp, String metric, String nodeId, double value, String severity, String status) {}
+    private record ActiveAlert(String metric,
+                               NodeId nodeId,
+                               double value,
+                               double threshold,
+                               String severity,
+                               long triggeredAt) {}
+
+    private record AlertHistoryEntry(long timestamp,
+                                     String metric,
+                                     String nodeId,
+                                     double value,
+                                     String severity,
+                                     String status) {}
 }
diff --git a/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
index d5984ef5..7a2861b5 100644
--- a/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
+++ b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
@@ -2,8 +2,6 @@
 
 import org.pragmatica.aether.node.AetherNode;
 import org.pragmatica.cluster.net.NodeId;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -12,13 +10,15 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Publishes dashboard metrics via WebSocket at regular intervals.
  *
  * <p>Aggregates metrics from various collectors and broadcasts to all connected clients.
  */
 public class DashboardMetricsPublisher {
-
     private static final Logger log = LoggerFactory.getLogger(DashboardMetricsPublisher.class);
     private static final long BROADCAST_INTERVAL_MS = 1000;
 
@@ -31,16 +31,19 @@ public DashboardMetricsPublisher(Supplier<AetherNode> nodeSupplier, AlertManager
         this.nodeSupplier = nodeSupplier;
         this.alertManager = alertManager;
         this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-            var thread = new Thread(r, "dashboard-publisher");
-            thread.setDaemon(true);
-            return thread;
-        });
+                                                                        var thread = new Thread(r, "dashboard-publisher");
+                                                                        thread.setDaemon(true);
+                                                                        return thread;
+                                                                    });
     }
 
     public void start() {
         if (running) return;
         running = true;
-        scheduler.scheduleAtFixedRate(this::publishMetrics, BROADCAST_INTERVAL_MS, BROADCAST_INTERVAL_MS, TimeUnit.MILLISECONDS);
+        scheduler.scheduleAtFixedRate(this::publishMetrics,
+                                      BROADCAST_INTERVAL_MS,
+                                      BROADCAST_INTERVAL_MS,
+                                      TimeUnit.MILLISECONDS);
         log.info("Dashboard metrics publisher started");
     }
 
@@ -52,13 +55,11 @@ public void stop() {
 
     private void publishMetrics() {
         if (DashboardWebSocketHandler.connectedClients() == 0) {
-            return; // No clients connected, skip
+            return;
         }
-
-        try {
+        try{
             var message = buildMetricsUpdate();
             DashboardWebSocketHandler.broadcast(message);
-
             // Check thresholds and broadcast alerts
             checkAndBroadcastAlerts();
         } catch (Exception e) {
@@ -68,12 +69,11 @@ private void publishMetrics() {
 
     private void checkAndBroadcastAlerts() {
         var node = nodeSupplier.get();
-        var allMetrics = node.metricsCollector().allMetrics();
-
+        var allMetrics = node.metricsCollector()
+                             .allMetrics();
         for (var entry : allMetrics.entrySet()) {
             var nodeId = entry.getKey();
             var metrics = entry.getValue();
-
             for (var metric : metrics.entrySet()) {
                 var alert = alertManager.checkThreshold(metric.getKey(), nodeId, metric.getValue());
                 if (alert != null) {
@@ -89,41 +89,56 @@ private void checkAndBroadcastAlerts() {
     public String buildInitialState() {
         var node = nodeSupplier.get();
         var sb = new StringBuilder();
-        sb.append("{\"type\":\"INITIAL_STATE\",\"timestamp\":").append(System.currentTimeMillis()).append(",\"data\":{");
-
+        sb.append("{\"type\":\"INITIAL_STATE\",\"timestamp\":")
+          .append(System.currentTimeMillis())
+          .append(",\"data\":{");
         // Nodes (first node in sorted list is typically the leader in Rabia)
         sb.append("\"nodes\":[");
-        var allMetrics = node.metricsCollector().allMetrics();
-        var sortedNodes = allMetrics.keySet().stream()
-                .sorted((a, b) -> a.id().compareTo(b.id()))
-                .collect(Collectors.toList());
-        var leaderId = sortedNodes.isEmpty() ? "" : sortedNodes.get(0).id();
+        var allMetrics = node.metricsCollector()
+                             .allMetrics();
+        var sortedNodes = allMetrics.keySet()
+                                    .stream()
+                                    .sorted((a, b) -> a.id()
+                                                       .compareTo(b.id()))
+                                    .collect(Collectors.toList());
+        var leaderId = sortedNodes.isEmpty()
+                       ? ""
+                       : sortedNodes.get(0)
+                                    .id();
         boolean firstNode = true;
         for (var nodeId : sortedNodes) {
             if (!firstNode) sb.append(",");
-            sb.append("{\"id\":\"").append(nodeId.id()).append("\",");
-            sb.append("\"isLeader\":").append(nodeId.id().equals(leaderId)).append("}");
+            sb.append("{\"id\":\"")
+              .append(nodeId.id())
+              .append("\",");
+            sb.append("\"isLeader\":")
+              .append(nodeId.id()
+                            .equals(leaderId))
+              .append("}");
             firstNode = false;
         }
         sb.append("],");
-
         // Slices
         sb.append("\"slices\":[");
-        var slices = node.sliceStore().loaded();
+        var slices = node.sliceStore()
+                         .loaded();
         boolean firstSlice = true;
         for (var slice : slices) {
             if (!firstSlice) sb.append(",");
-            sb.append("\"").append(slice.artifact().asString()).append("\"");
+            sb.append("\"")
+              .append(slice.artifact()
+                           .asString())
+              .append("\"");
             firstSlice = false;
         }
         sb.append("],");
-
         // Thresholds
-        sb.append("\"thresholds\":").append(alertManager.thresholdsAsJson()).append(",");
-
+        sb.append("\"thresholds\":")
+          .append(alertManager.thresholdsAsJson())
+          .append(",");
         // Current metrics snapshot
-        sb.append("\"metrics\":").append(buildMetricsData());
-
+        sb.append("\"metrics\":")
+          .append(buildMetricsData());
         sb.append("}}");
         return sb.toString();
     }
@@ -133,8 +148,11 @@ public String buildInitialState() {
      */
     private String buildMetricsUpdate() {
         var sb = new StringBuilder();
-        sb.append("{\"type\":\"METRICS_UPDATE\",\"timestamp\":").append(System.currentTimeMillis());
-        sb.append(",\"data\":").append(buildMetricsData()).append("}");
+        sb.append("{\"type\":\"METRICS_UPDATE\",\"timestamp\":")
+          .append(System.currentTimeMillis());
+        sb.append(",\"data\":")
+          .append(buildMetricsData())
+          .append("}");
         return sb.toString();
     }
 
@@ -142,30 +160,34 @@ private String buildMetricsData() {
         var node = nodeSupplier.get();
         var sb = new StringBuilder();
         sb.append("{");
-
         // Load metrics
         sb.append("\"load\":{");
-        var allMetrics = node.metricsCollector().allMetrics();
+        var allMetrics = node.metricsCollector()
+                             .allMetrics();
         boolean firstNode = true;
         for (var entry : allMetrics.entrySet()) {
             if (!firstNode) sb.append(",");
-            sb.append("\"").append(entry.getKey().id()).append("\":{");
-
+            sb.append("\"")
+              .append(entry.getKey()
+                           .id())
+              .append("\":{");
             boolean firstMetric = true;
-            for (var metric : entry.getValue().entrySet()) {
+            for (var metric : entry.getValue()
+                                   .entrySet()) {
                 if (!firstMetric) sb.append(",");
-                sb.append("\"").append(metric.getKey()).append("\":").append(metric.getValue());
+                sb.append("\"")
+                  .append(metric.getKey())
+                  .append("\":")
+                  .append(metric.getValue());
                 firstMetric = false;
             }
-
             sb.append("}");
             firstNode = false;
         }
         sb.append("},");
-
         // Invocation metrics (if available)
-        sb.append("\"invocations\":").append(buildInvocationMetrics());
-
+        sb.append("\"invocations\":")
+          .append(buildInvocationMetrics());
         sb.append("}");
         return sb.toString();
     }
@@ -183,11 +205,9 @@ public void handleSetThreshold(String message) {
         var metricPattern = Pattern.compile("\"metric\"\\s*:\\s*\"([^\"]+)\"");
         var warningPattern = Pattern.compile("\"warning\"\\s*:\\s*([\\d.]+)");
         var criticalPattern = Pattern.compile("\"critical\"\\s*:\\s*([\\d.]+)");
-
         var metricMatch = metricPattern.matcher(message);
         var warningMatch = warningPattern.matcher(message);
         var criticalMatch = criticalPattern.matcher(message);
-
         if (metricMatch.find() && warningMatch.find() && criticalMatch.find()) {
             var metric = metricMatch.group(1);
             var warning = Double.parseDouble(warningMatch.group(1));
@@ -204,57 +224,59 @@ public String buildHistoryResponse(String message) {
         // Parse: {"type":"GET_HISTORY","timeRange":"1h"}
         var rangePattern = Pattern.compile("\"timeRange\"\\s*:\\s*\"([^\"]+)\"");
         var rangeMatch = rangePattern.matcher(message);
-
         var range = "1h";
         if (rangeMatch.find()) {
             range = rangeMatch.group(1);
         }
-
         var node = nodeSupplier.get();
-        var historicalData = node.metricsCollector().historicalMetrics();
+        var historicalData = node.metricsCollector()
+                                 .historicalMetrics();
         var cutoff = System.currentTimeMillis() - parseTimeRange(range);
-
         var sb = new StringBuilder();
-        sb.append("{\"type\":\"HISTORY\",\"timeRange\":\"").append(range).append("\",\"nodes\":{");
-
+        sb.append("{\"type\":\"HISTORY\",\"timeRange\":\"")
+          .append(range)
+          .append("\",\"nodes\":{");
         // Build node-centric history: {"nodes": {"node-1": [{"timestamp": ..., "metrics": {...}}, ...]}}
         boolean firstNode = true;
         for (var nodeEntry : historicalData.entrySet()) {
             if (!firstNode) sb.append(",");
-            sb.append("\"").append(nodeEntry.getKey().id()).append("\":[");
-
+            sb.append("\"")
+              .append(nodeEntry.getKey()
+                               .id())
+              .append("\":[");
             boolean firstSnapshot = true;
             for (var snapshot : nodeEntry.getValue()) {
                 if (snapshot.timestamp() < cutoff) continue;
-
                 if (!firstSnapshot) sb.append(",");
-                sb.append("{\"timestamp\":").append(snapshot.timestamp()).append(",\"metrics\":{");
-
+                sb.append("{\"timestamp\":")
+                  .append(snapshot.timestamp())
+                  .append(",\"metrics\":{");
                 boolean firstMetric = true;
-                for (var metric : snapshot.metrics().entrySet()) {
+                for (var metric : snapshot.metrics()
+                                          .entrySet()) {
                     if (!firstMetric) sb.append(",");
-                    sb.append("\"").append(metric.getKey()).append("\":").append(metric.getValue());
+                    sb.append("\"")
+                      .append(metric.getKey())
+                      .append("\":")
+                      .append(metric.getValue());
                     firstMetric = false;
                 }
-
                 sb.append("}}");
                 firstSnapshot = false;
             }
-
             sb.append("]");
             firstNode = false;
         }
-
         sb.append("}}");
         return sb.toString();
     }
 
     private long parseTimeRange(String range) {
         return switch (range) {
-            case "5m" -> 5 * 60 * 1000L;
-            case "15m" -> 15 * 60 * 1000L;
-            case "1h" -> 60 * 60 * 1000L;
-            case "2h" -> 2 * 60 * 60 * 1000L;
+            case"5m" -> 5 * 60 * 1000L;
+            case"15m" -> 15 * 60 * 1000L;
+            case"1h" -> 60 * 60 * 1000L;
+            case"2h" -> 2 * 60 * 60 * 1000L;
             default -> 60 * 60 * 1000L;
         };
     }
diff --git a/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java b/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
index e359ce35..4ebcdb36 100644
--- a/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
+++ b/node/src/main/java/org/pragmatica/aether/api/DashboardWebSocketHandler.java
@@ -16,7 +16,6 @@
  * <p>Manages connected dashboard clients and broadcasts metrics updates.
  */
 public class DashboardWebSocketHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
-
     private static final Logger log = LoggerFactory.getLogger(DashboardWebSocketHandler.class);
     private static final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
 
@@ -29,8 +28,9 @@ public DashboardWebSocketHandler(DashboardMetricsPublisher metricsPublisher) {
     @Override
     public void handlerAdded(ChannelHandlerContext ctx) {
         channels.add(ctx.channel());
-        log.info("Dashboard client connected: {}", ctx.channel().remoteAddress());
-
+        log.info("Dashboard client connected: {}",
+                 ctx.channel()
+                    .remoteAddress());
         // Send initial state snapshot
         var initialState = metricsPublisher.buildInitialState();
         ctx.writeAndFlush(new TextWebSocketFrame(initialState));
@@ -39,7 +39,9 @@ public void handlerAdded(ChannelHandlerContext ctx) {
     @Override
     public void handlerRemoved(ChannelHandlerContext ctx) {
         channels.remove(ctx.channel());
-        log.info("Dashboard client disconnected: {}", ctx.channel().remoteAddress());
+        log.info("Dashboard client disconnected: {}",
+                 ctx.channel()
+                    .remoteAddress());
     }
 
     @Override
@@ -51,14 +53,13 @@ protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) {
 
     private void handleClientMessage(ChannelHandlerContext ctx, String message) {
         log.debug("Received from dashboard client: {}", message);
-
         // Parse client messages (subscribe, set threshold, get history)
         if (message.contains("\"type\":\"SUBSCRIBE\"")) {
             // Client subscribing to streams - currently all clients get all updates
             log.debug("Client subscribed to streams");
-        } else if (message.contains("\"type\":\"SET_THRESHOLD\"")) {
+        }else if (message.contains("\"type\":\"SET_THRESHOLD\"")) {
             metricsPublisher.handleSetThreshold(message);
-        } else if (message.contains("\"type\":\"GET_HISTORY\"")) {
+        }else if (message.contains("\"type\":\"GET_HISTORY\"")) {
             var history = metricsPublisher.buildHistoryResponse(message);
             ctx.writeAndFlush(new TextWebSocketFrame(history));
         }
@@ -80,7 +81,10 @@ public static int connectedClients() {
 
     @Override
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
-        log.error("WebSocket error for client {}", ctx.channel().remoteAddress(), cause);
+        log.error("WebSocket error for client {}",
+                  ctx.channel()
+                     .remoteAddress(),
+                  cause);
         ctx.close();
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java b/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
index a668c9fc..23be9714 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
@@ -14,7 +14,6 @@
  * Implementations can range from simple decision trees to AI-powered systems.
  */
 public interface ClusterController {
-
     /**
      * Evaluate current cluster state and produce control decisions.
      *
@@ -27,31 +26,33 @@ public interface ClusterController {
      * Context provided to the controller for decision-making.
      */
     record ControlContext(
-            Map<NodeId, Map<String, Double>> metrics,
-            Map<Artifact, Blueprint> blueprints,
-            List<NodeId> activeNodes
-    ) {
+    Map<NodeId, Map<String, Double>> metrics,
+    Map<Artifact, Blueprint> blueprints,
+    List<NodeId> activeNodes) {
         /**
          * Get average value of a metric across all nodes.
          */
         public double avgMetric(String metricName) {
-            var values = metrics.values().stream()
+            var values = metrics.values()
+                                .stream()
                                 .map(m -> m.get(metricName))
                                 .filter(v -> v != null)
                                 .mapToDouble(Double::doubleValue)
                                 .toArray();
-
             if (values.length == 0) {
                 return 0.0;
             }
-            return java.util.Arrays.stream(values).average().orElse(0.0);
+            return java.util.Arrays.stream(values)
+                       .average()
+                       .orElse(0.0);
         }
 
         /**
          * Get max value of a metric across all nodes.
          */
         public double maxMetric(String metricName) {
-            return metrics.values().stream()
+            return metrics.values()
+                          .stream()
                           .map(m -> m.get(metricName))
                           .filter(v -> v != null)
                           .mapToDouble(Double::doubleValue)
@@ -63,7 +64,8 @@ public double maxMetric(String metricName) {
          * Get total calls for a method across all nodes.
          */
         public double totalCalls(String methodName) {
-            return metrics.values().stream()
+            return metrics.values()
+                          .stream()
                           .map(m -> m.get("method." + methodName + ".calls"))
                           .filter(v -> v != null)
                           .mapToDouble(Double::doubleValue)
diff --git a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
index e282f725..9e27824d 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
@@ -16,8 +16,6 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.Map;
@@ -25,6 +23,9 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Control loop that runs the ClusterController periodically on the leader node.
  *
@@ -36,7 +37,6 @@
  * </ul>
  */
 public interface ControlLoop {
-
     @MessageReceiver
     void onLeaderChange(LeaderChange leaderChange);
 
@@ -59,10 +59,10 @@ public interface ControlLoop {
     void stop();
 
     static ControlLoop controlLoop(NodeId self,
-                                    ClusterController controller,
-                                    MetricsCollector metricsCollector,
-                                    ClusterNode<KVCommand<AetherKey>> cluster,
-                                    long intervalMs) {
+                                   ClusterController controller,
+                                   MetricsCollector metricsCollector,
+                                   ClusterNode<KVCommand<AetherKey>> cluster,
+                                   long intervalMs) {
         return new ControlLoopImpl(self, controller, metricsCollector, cluster, intervalMs);
     }
 
@@ -70,15 +70,14 @@ static ControlLoop controlLoop(NodeId self,
      * Create with default 5-second interval.
      */
     static ControlLoop controlLoop(NodeId self,
-                                    ClusterController controller,
-                                    MetricsCollector metricsCollector,
-                                    ClusterNode<KVCommand<AetherKey>> cluster) {
+                                   ClusterController controller,
+                                   MetricsCollector metricsCollector,
+                                   ClusterNode<KVCommand<AetherKey>> cluster) {
         return controlLoop(self, controller, metricsCollector, cluster, 5000);
     }
 }
 
 class ControlLoopImpl implements ControlLoop {
-
     private static final Logger log = LoggerFactory.getLogger(ControlLoopImpl.class);
 
     private final NodeId self;
@@ -88,12 +87,13 @@ class ControlLoopImpl implements ControlLoop {
     private final long intervalMs;
 
     private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-        var thread = new Thread(r, "control-loop");
-        thread.setDaemon(true);
-        return thread;
-    });
+                                                                                                      var thread = new Thread(r,
+                                                                                                                              "control-loop");
+                                                                                                      thread.setDaemon(true);
+                                                                                                      return thread;
+                                                                                                  });
 
-    private final AtomicReference<ScheduledFuture<?>> evaluationTask = new AtomicReference<>();
+    private final AtomicReference<ScheduledFuture< ? >> evaluationTask = new AtomicReference<>();
     private final AtomicReference<List<NodeId>> topology = new AtomicReference<>(List.of());
     private final ConcurrentHashMap<Artifact, ClusterController.Blueprint> blueprints = new ConcurrentHashMap<>();
 
@@ -114,7 +114,7 @@ public void onLeaderChange(LeaderChange leaderChange) {
         if (leaderChange.localNodeIsLeader()) {
             log.info("Node {} became leader, starting control loop", self);
             startEvaluation();
-        } else {
+        }else {
             log.info("Node {} is no longer leader, stopping control loop", self);
             stopEvaluation();
         }
@@ -145,23 +145,21 @@ public void unregisterBlueprint(Artifact artifact) {
     public void stop() {
         stopEvaluation();
         scheduler.shutdown();
-        try {
+        try{
             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                 scheduler.shutdownNow();
             }
         } catch (InterruptedException e) {
             scheduler.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
     private void startEvaluation() {
         stopEvaluation();
-
         var task = scheduler.scheduleAtFixedRate(
-                this::runEvaluation,
-                intervalMs, intervalMs, TimeUnit.MILLISECONDS
-        );
+        this::runEvaluation, intervalMs, intervalMs, TimeUnit.MILLISECONDS);
         evaluationTask.set(task);
     }
 
@@ -173,33 +171,28 @@ private void stopEvaluation() {
     }
 
     private void runEvaluation() {
-        try {
+        try{
             if (blueprints.isEmpty()) {
                 log.trace("No blueprints registered, skipping evaluation");
                 return;
             }
-
             var context = new ControlContext(
-                    metricsCollector.allMetrics(),
-                    Map.copyOf(blueprints),
-                    topology.get()
-            );
-
+            metricsCollector.allMetrics(), Map.copyOf(blueprints), topology.get());
             controller.evaluate(context)
                       .onSuccess(this::applyDecisions)
-                      .onFailure(cause -> log.error("Controller evaluation failed: {}", cause.message()));
-
+                      .onFailure(cause -> log.error("Controller evaluation failed: {}",
+                                                    cause.message()));
         } catch (Exception e) {
             log.error("Control loop error: {}", e.getMessage(), e);
         }
     }
 
     private void applyDecisions(ClusterController.ControlDecisions decisions) {
-        if (decisions.changes().isEmpty()) {
+        if (decisions.changes()
+                     .isEmpty()) {
             log.trace("No scaling decisions");
             return;
         }
-
         for (var change : decisions.changes()) {
             applyChange(change);
         }
@@ -208,35 +201,31 @@ private void applyDecisions(ClusterController.ControlDecisions decisions) {
     private void applyChange(BlueprintChange change) {
         var artifact = change.artifact();
         var currentBlueprint = blueprints.get(artifact);
-
         if (currentBlueprint == null) {
             log.warn("Blueprint not found for {}, skipping change", artifact);
             return;
         }
-
         int newInstances = switch (change) {
             case BlueprintChange.ScaleUp(_, int additional) ->
-                    currentBlueprint.instances() + additional;
+            currentBlueprint.instances() + additional;
             case BlueprintChange.ScaleDown(_, int reduceBy) ->
-                    Math.max(1, currentBlueprint.instances() - reduceBy);
+            Math.max(1, currentBlueprint.instances() - reduceBy);
         };
-
         if (newInstances == currentBlueprint.instances()) {
             return;
         }
-
         log.info("Applying scaling decision: {} from {} to {} instances",
-                 artifact, currentBlueprint.instances(), newInstances);
-
+                 artifact,
+                 currentBlueprint.instances(),
+                 newInstances);
         // Update local blueprint
         blueprints.put(artifact, new ClusterController.Blueprint(artifact, newInstances));
-
         // Update blueprint in KVStore via consensus
         var key = new BlueprintKey(artifact);
         var value = new BlueprintValue(newInstances);
         var command = new KVCommand.Put<AetherKey, AetherValue>(key, value);
-
         cluster.apply(List.of(command))
-               .onFailure(cause -> log.error("Failed to apply blueprint change: {}", cause.message()));
+               .onFailure(cause -> log.error("Failed to apply blueprint change: {}",
+                                             cause.message()));
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/controller/DecisionTreeController.java b/node/src/main/java/org/pragmatica/aether/controller/DecisionTreeController.java
index a97521f7..ddba13e4 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/DecisionTreeController.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/DecisionTreeController.java
@@ -2,12 +2,13 @@
 
 import org.pragmatica.aether.metrics.MetricsCollector;
 import org.pragmatica.lang.Promise;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Simple rule-based controller for MVP.
  *
@@ -21,35 +22,26 @@
  * <p>Future versions will support configurable rules via YAML.
  */
 public interface DecisionTreeController extends ClusterController {
-
     /**
      * Create a decision tree controller with default thresholds.
      */
     static DecisionTreeController decisionTreeController() {
         return decisionTreeController(
-                0.8,  // cpuScaleUpThreshold
-                0.2,  // cpuScaleDownThreshold
-                1000  // callRateScaleUpThreshold (calls per second)
-        );
+        0.8, 0.2, 1000);
     }
 
     /**
      * Create a decision tree controller with custom thresholds.
      */
-    static DecisionTreeController decisionTreeController(
-            double cpuScaleUpThreshold,
-            double cpuScaleDownThreshold,
-            double callRateScaleUpThreshold) {
+    static DecisionTreeController decisionTreeController(double cpuScaleUpThreshold,
+                                                         double cpuScaleDownThreshold,
+                                                         double callRateScaleUpThreshold) {
         return new DecisionTreeControllerImpl(
-                cpuScaleUpThreshold,
-                cpuScaleDownThreshold,
-                callRateScaleUpThreshold
-        );
+        cpuScaleUpThreshold, cpuScaleDownThreshold, callRateScaleUpThreshold);
     }
 }
 
 class DecisionTreeControllerImpl implements DecisionTreeController {
-
     private static final Logger log = LoggerFactory.getLogger(DecisionTreeControllerImpl.class);
 
     private final double cpuScaleUpThreshold;
@@ -57,8 +49,8 @@ class DecisionTreeControllerImpl implements DecisionTreeController {
     private final double callRateScaleUpThreshold;
 
     DecisionTreeControllerImpl(double cpuScaleUpThreshold,
-                                double cpuScaleDownThreshold,
-                                double callRateScaleUpThreshold) {
+                               double cpuScaleDownThreshold,
+                               double callRateScaleUpThreshold) {
         this.cpuScaleUpThreshold = cpuScaleUpThreshold;
         this.cpuScaleDownThreshold = cpuScaleDownThreshold;
         this.callRateScaleUpThreshold = callRateScaleUpThreshold;
@@ -67,42 +59,41 @@ class DecisionTreeControllerImpl implements DecisionTreeController {
     @Override
     public Promise<ControlDecisions> evaluate(ControlContext context) {
         var changes = new ArrayList<BlueprintChange>();
-
         // Get current CPU usage
         var avgCpu = context.avgMetric(MetricsCollector.CPU_USAGE);
-
-        log.debug("Evaluating: avgCpu={}, blueprints={}", avgCpu, context.blueprints().size());
-
-        for (var entry : context.blueprints().entrySet()) {
+        log.debug("Evaluating: avgCpu={}, blueprints={}",
+                  avgCpu,
+                  context.blueprints()
+                         .size());
+        for (var entry : context.blueprints()
+                                .entrySet()) {
             var artifact = entry.getKey();
             var blueprint = entry.getValue();
-
             // Rule 1: High CPU → scale up
             if (avgCpu > cpuScaleUpThreshold) {
-                log.info("Rule triggered: High CPU ({} > {}), scaling up {}",
-                         avgCpu, cpuScaleUpThreshold, artifact);
+                log.info("Rule triggered: High CPU ({} > {}), scaling up {}", avgCpu, cpuScaleUpThreshold, artifact);
                 changes.add(new BlueprintChange.ScaleUp(artifact, 1));
-                continue; // One change per artifact per evaluation
+                continue;
             }
-
             // Rule 2: Low CPU → scale down (if more than 1 instance)
             if (avgCpu < cpuScaleDownThreshold && blueprint.instances() > 1) {
-                log.info("Rule triggered: Low CPU ({} < {}), scaling down {}",
-                         avgCpu, cpuScaleDownThreshold, artifact);
+                log.info("Rule triggered: Low CPU ({} < {}), scaling down {}", avgCpu, cpuScaleDownThreshold, artifact);
                 changes.add(new BlueprintChange.ScaleDown(artifact, 1));
                 continue;
             }
-
             // Rule 3: High call rate → scale up
             // Check all methods for this artifact
-            for (var metricsEntry : context.metrics().entrySet()) {
+            for (var metricsEntry : context.metrics()
+                                           .entrySet()) {
                 var nodeMetrics = metricsEntry.getValue();
                 for (var metricName : nodeMetrics.keySet()) {
                     if (metricName.startsWith("method.") && metricName.endsWith(".calls")) {
                         var callCount = nodeMetrics.get(metricName);
                         if (callCount != null && callCount > callRateScaleUpThreshold) {
                             log.info("Rule triggered: High call rate ({} > {}), scaling up {}",
-                                     callCount, callRateScaleUpThreshold, artifact);
+                                     callCount,
+                                     callRateScaleUpThreshold,
+                                     artifact);
                             changes.add(new BlueprintChange.ScaleUp(artifact, 1));
                             break;
                         }
@@ -110,7 +101,6 @@ public Promise<ControlDecisions> evaluate(ControlContext context) {
                 }
             }
         }
-
         return Promise.success(new ControlDecisions(changes));
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceImpl.java b/node/src/main/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceImpl.java
index 3a58658c..f84aef4b 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceImpl.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceImpl.java
@@ -21,16 +21,13 @@
 import java.util.List;
 
 public interface BlueprintServiceImpl {
-    static BlueprintService blueprintService(
-            ClusterNode<KVCommand<AetherKey>> cluster,
-            KVStore<AetherKey, AetherValue> store,
-            Repository repository
-                                            ) {
+    static BlueprintService blueprintService(ClusterNode<KVCommand<AetherKey>> cluster,
+                                             KVStore<AetherKey, AetherValue> store,
+                                             Repository repository) {
         record blueprintService(
-                ClusterNode<KVCommand<AetherKey>> cluster,
-                KVStore<AetherKey, AetherValue> store,
-                Repository repository
-        ) implements BlueprintService {
+        ClusterNode<KVCommand<AetherKey>> cluster,
+        KVStore<AetherKey, AetherValue> store,
+        Repository repository) implements BlueprintService {
             @Override
             public Promise<ExpandedBlueprint> publish(String dsl) {
                 return BlueprintParser.parse(dsl)
@@ -61,13 +58,13 @@ public Promise<Unit> delete(BlueprintId id) {
             }
 
             private Promise<ExpandedBlueprint> storeBlueprint(ExpandedBlueprint expanded) {
-                return storeBlueprintWithKey(AppBlueprintKey.appBlueprintKey(expanded.id()), expanded);
+                return storeBlueprintWithKey(AppBlueprintKey.appBlueprintKey(expanded.id()),
+                                             expanded);
             }
 
             private Promise<ExpandedBlueprint> storeBlueprintWithKey(AppBlueprintKey key, ExpandedBlueprint expanded) {
                 var value = new AppBlueprintValue(expanded);
                 KVCommand<AetherKey> command = new Put<>(key, value);
-
                 return cluster.apply(List.of(command))
                               .map(_ -> expanded);
             }
@@ -85,7 +82,6 @@ private Option<ExpandedBlueprint> extractBlueprint(AetherValue value) {
                 };
             }
         }
-
         return new blueprintService(cluster, store, repository);
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
index 4dd2fd0c..af9e14fd 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
@@ -20,9 +20,6 @@
 import org.pragmatica.aether.metrics.deployment.DeploymentEvent.DeploymentStarted;
 import org.pragmatica.message.MessageReceiver;
 import org.pragmatica.message.MessageRouter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import org.pragmatica.cluster.state.kvstore.KVStore;
 
 import java.util.List;
@@ -31,6 +28,9 @@
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Cluster-wide orchestration component that manages slice deployments across the cluster.
  * Only active on the leader node.
@@ -51,7 +51,6 @@
  * </ul>
  */
 public interface ClusterDeploymentManager {
-
     @MessageReceiver
     void onLeaderChange(LeaderChange leaderChange);
 
@@ -68,15 +67,11 @@ public interface ClusterDeploymentManager {
      * State of the cluster deployment manager.
      */
     sealed interface ClusterDeploymentState {
+        default void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {}
 
-        default void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-        }
-
-        default void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-        }
+        default void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {}
 
-        default void onTopologyChange(TopologyChangeNotification topologyChange) {
-        }
+        default void onTopologyChange(TopologyChangeNotification topologyChange) {}
 
         /**
          * Dormant state when node is NOT the leader.
@@ -87,15 +82,13 @@ record Dormant() implements ClusterDeploymentState {}
          * Active state when node IS the leader.
          */
         record Active(
-                NodeId self,
-                ClusterNode<KVCommand<AetherKey>> cluster,
-                KVStore<AetherKey, AetherValue> kvStore,
-                MessageRouter router,
-                Map<Artifact, Blueprint> blueprints,
-                Map<SliceNodeKey, SliceState> sliceStates,
-                List<NodeId> activeNodes
-        ) implements ClusterDeploymentState {
-
+        NodeId self,
+        ClusterNode<KVCommand<AetherKey>> cluster,
+        KVStore<AetherKey, AetherValue> kvStore,
+        MessageRouter router,
+        Map<Artifact, Blueprint> blueprints,
+        Map<SliceNodeKey, SliceState> sliceStates,
+        List<NodeId> activeNodes) implements ClusterDeploymentState {
             private static final Logger log = LoggerFactory.getLogger(Active.class);
 
             /**
@@ -104,53 +97,54 @@ record Active(
              */
             void rebuildStateFromKVStore() {
                 log.info("Rebuilding cluster deployment state from KVStore");
-
-                kvStore.snapshot().forEach((key, value) -> {
-                    switch (key) {
-                        case BlueprintKey blueprintKey when value instanceof BlueprintValue blueprintValue -> {
-                            var artifact = blueprintKey.artifact();
-                            var instances = (int) blueprintValue.instanceCount();
-                            blueprints.put(artifact, new Blueprint(artifact, instances));
-                            log.debug("Restored blueprint: {} with {} instances", artifact, instances);
-                        }
-                        case SliceNodeKey sliceNodeKey when value instanceof SliceNodeValue sliceNodeValue -> {
-                            sliceStates.put(sliceNodeKey, sliceNodeValue.state());
-                            log.debug("Restored slice state: {} = {}", sliceNodeKey, sliceNodeValue.state());
-                        }
-                        default -> {
-                            // Ignore other key types (routes, endpoints, etc.)
-                        }
-                    }
-                });
-
+                kvStore.snapshot()
+                       .forEach((key, value) -> {
+                                    switch (key) {
+                    case BlueprintKey blueprintKey when value instanceof BlueprintValue blueprintValue -> {
+                                    var artifact = blueprintKey.artifact();
+                                    var instances = (int) blueprintValue.instanceCount();
+                                    blueprints.put(artifact,
+                                                   new Blueprint(artifact, instances));
+                                    log.debug("Restored blueprint: {} with {} instances", artifact, instances);
+                                }
+                    case SliceNodeKey sliceNodeKey when value instanceof SliceNodeValue sliceNodeValue -> {
+                                    sliceStates.put(sliceNodeKey,
+                                                    sliceNodeValue.state());
+                                    log.debug("Restored slice state: {} = {}",
+                                              sliceNodeKey,
+                                              sliceNodeValue.state());
+                                }
+                    default -> {}
+                }
+                                });
                 log.info("Restored {} blueprints and {} slice states from KVStore",
-                         blueprints.size(), sliceStates.size());
+                         blueprints.size(),
+                         sliceStates.size());
             }
 
             @Override
             public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-                var key = valuePut.cause().key();
-                var value = valuePut.cause().value();
-
+                var key = valuePut.cause()
+                                  .key();
+                var value = valuePut.cause()
+                                    .value();
                 switch (key) {
                     case BlueprintKey blueprintKey when value instanceof BlueprintValue blueprintValue ->
-                            handleBlueprintChange(blueprintKey, blueprintValue);
+                    handleBlueprintChange(blueprintKey, blueprintValue);
                     case SliceNodeKey sliceNodeKey when value instanceof SliceNodeValue sliceNodeValue ->
-                            trackSliceState(sliceNodeKey, sliceNodeValue.state());
-                    default -> {
-                    }
+                    trackSliceState(sliceNodeKey, sliceNodeValue.state());
+                    default -> {}
                 }
             }
 
             @Override
             public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-                var key = valueRemove.cause().key();
-
+                var key = valueRemove.cause()
+                                     .key();
                 switch (key) {
                     case BlueprintKey blueprintKey -> handleBlueprintRemoval(blueprintKey);
                     case SliceNodeKey sliceNodeKey -> sliceStates.remove(sliceNodeKey);
-                    default -> {
-                    }
+                    default -> {}
                 }
             }
 
@@ -166,8 +160,7 @@ case NodeRemoved(NodeId removedNode, List<NodeId> topology) -> {
                         handleNodeRemoval(removedNode);
                         reconcile();
                     }
-                    default -> {
-                    }
+                    default -> {}
                 }
             }
 
@@ -179,18 +172,14 @@ private void updateTopology(List<NodeId> topology) {
             private void handleBlueprintChange(BlueprintKey key, BlueprintValue value) {
                 var artifact = key.artifact();
                 var desiredInstances = (int) value.instanceCount();
-
                 log.info("Blueprint changed for {}: {} instances", artifact, desiredInstances);
-
                 blueprints.put(artifact, new Blueprint(artifact, desiredInstances));
                 allocateInstances(artifact, desiredInstances);
             }
 
             private void handleBlueprintRemoval(BlueprintKey key) {
                 var artifact = key.artifact();
-
                 log.info("Blueprint removed for {}", artifact);
-
                 blueprints.remove(artifact);
                 deallocateAllInstances(artifact);
             }
@@ -201,12 +190,12 @@ private void trackSliceState(SliceNodeKey sliceKey, SliceState state) {
 
             private void handleNodeRemoval(NodeId removedNode) {
                 // Remove state entries for the removed node
-                var keysToRemove = sliceStates.keySet().stream()
-                                              .filter(key -> key.nodeId().equals(removedNode))
+                var keysToRemove = sliceStates.keySet()
+                                              .stream()
+                                              .filter(key -> key.nodeId()
+                                                                .equals(removedNode))
                                               .toList();
-
                 keysToRemove.forEach(sliceStates::remove);
-
                 log.info("Removed {} slice states for departed node {}", keysToRemove.size(), removedNode);
             }
 
@@ -218,18 +207,17 @@ private void allocateInstances(Artifact artifact, int desiredInstances) {
                     log.warn("No active nodes available for allocation of {}", artifact);
                     return;
                 }
-
                 var currentInstances = getCurrentInstances(artifact);
                 var currentCount = currentInstances.size();
-
                 log.debug("Allocating {} instances of {} (current: {}) across {} nodes",
-                          desiredInstances, artifact, currentCount, activeNodes.size());
-
+                          desiredInstances,
+                          artifact,
+                          currentCount,
+                          activeNodes.size());
                 // Scale up if needed
                 if (desiredInstances > currentCount) {
                     scaleUp(artifact, desiredInstances - currentCount, currentInstances);
                 }
-
                 // Scale down if needed
                 if (desiredInstances < currentCount) {
                     scaleDown(artifact, currentCount - desiredInstances, currentInstances);
@@ -241,83 +229,78 @@ private void scaleUp(Artifact artifact, int toAdd, List<SliceNodeKey> existingIn
                 var nodesWithInstances = existingInstances.stream()
                                                           .map(SliceNodeKey::nodeId)
                                                           .toList();
-
                 var added = 0;
-
                 // First pass: allocate to nodes without instances
                 for (var node : activeNodes) {
                     if (added >= toAdd) {
                         break;
                     }
-
                     if (!nodesWithInstances.contains(node)) {
                         var sliceKey = new SliceNodeKey(artifact, node);
                         if (!sliceStates.containsKey(sliceKey)) {
                             issueLoadCommand(sliceKey);
-                            added++;
+                            added++ ;
                         }
                     }
                 }
-
                 // Second pass: if still need more, allocate additional instances (round-robin)
                 // This handles cases where instances > nodes
                 var nodeIndex = 0;
                 while (added < toAdd) {
                     var targetNode = activeNodes.get(nodeIndex % activeNodes.size());
                     var sliceKey = new SliceNodeKey(artifact, targetNode);
-
                     // Note: In current design, one slice per node per artifact
                     // For multiple instances per node, we'd need instance numbering
                     // For now, just issue the command (will be idempotent if already exists)
                     issueLoadCommand(sliceKey);
-                    added++;
-                    nodeIndex++;
+                    added++ ;
+                    nodeIndex++ ;
                 }
             }
 
             private void scaleDown(Artifact artifact, int toRemove, List<SliceNodeKey> existingInstances) {
                 // Remove from the end (LIFO to maintain round-robin balance)
                 var toRemoveKeys = existingInstances.stream()
-                                                    .skip(Math.max(0, existingInstances.size() - toRemove))
+                                                    .skip(Math.max(0,
+                                                                   existingInstances.size() - toRemove))
                                                     .toList();
-
                 toRemoveKeys.forEach(this::issueUnloadCommand);
             }
 
             private List<SliceNodeKey> getCurrentInstances(Artifact artifact) {
-                return sliceStates.keySet().stream()
-                                  .filter(key -> key.artifact().equals(artifact))
+                return sliceStates.keySet()
+                                  .stream()
+                                  .filter(key -> key.artifact()
+                                                    .equals(artifact))
                                   .toList();
             }
 
             private void issueLoadCommand(SliceNodeKey sliceKey) {
                 log.info("Issuing LOAD command for {}", sliceKey);
-
                 // Emit deployment started event for metrics via MessageRouter
                 var timestamp = System.currentTimeMillis();
                 router.route(new DeploymentStarted(sliceKey.artifact(), sliceKey.nodeId(), timestamp));
-
                 var value = new SliceNodeValue(SliceState.LOAD);
                 var command = new KVCommand.Put<AetherKey, AetherValue>(sliceKey, value);
-
                 cluster.apply(List.of(command))
                        .onFailure(cause -> log.error("Failed to issue LOAD command for {}: {}",
-                                                     sliceKey, cause.message()));
+                                                     sliceKey,
+                                                     cause.message()));
             }
 
             private void issueUnloadCommand(SliceNodeKey sliceKey) {
                 log.info("Issuing UNLOAD command for {}", sliceKey);
-
                 var value = new SliceNodeValue(SliceState.UNLOAD);
                 var command = new KVCommand.Put<AetherKey, AetherValue>(sliceKey, value);
-
                 cluster.apply(List.of(command))
                        .onFailure(cause -> log.error("Failed to issue UNLOAD command for {}: {}",
-                                                     sliceKey, cause.message()));
+                                                     sliceKey,
+                                                     cause.message()));
             }
 
             private void deallocateAllInstances(Artifact artifact) {
-                getCurrentInstances(artifact).forEach(this::issueUnloadCommand);
+                getCurrentInstances(artifact)
+                .forEach(this::issueUnloadCommand);
             }
 
             /**
@@ -326,15 +309,15 @@ private void deallocateAllInstances(Artifact artifact) {
              */
             void reconcile() {
                 log.info("Performing cluster reconciliation");
-
                 for (var blueprint : blueprints.values()) {
                     var artifact = blueprint.artifact();
                     var desiredInstances = blueprint.instances();
                     var currentInstances = getCurrentInstances(artifact);
-
                     if (currentInstances.size() != desiredInstances) {
                         log.info("Reconciliation: {} has {} instances, desired {}",
-                                 artifact, currentInstances.size(), desiredInstances);
+                                 artifact,
+                                 currentInstances.size(),
+                                 desiredInstances);
                         allocateInstances(artifact, desiredInstances);
                     }
                 }
@@ -350,43 +333,35 @@ record Blueprint(Artifact artifact, int instances) {}
     /**
      * Create a new cluster deployment manager.
      */
-    static ClusterDeploymentManager clusterDeploymentManager(
-            NodeId self,
-            ClusterNode<KVCommand<AetherKey>> cluster,
-            KVStore<AetherKey, AetherValue> kvStore,
-            MessageRouter router
-    ) {
+    static ClusterDeploymentManager clusterDeploymentManager(NodeId self,
+                                                             ClusterNode<KVCommand<AetherKey>> cluster,
+                                                             KVStore<AetherKey, AetherValue> kvStore,
+                                                             MessageRouter router) {
         record clusterDeploymentManager(
-                NodeId self,
-                ClusterNode<KVCommand<AetherKey>> cluster,
-                KVStore<AetherKey, AetherValue> kvStore,
-                MessageRouter router,
-                AtomicReference<ClusterDeploymentState> state
-        ) implements ClusterDeploymentManager {
-
+        NodeId self,
+        ClusterNode<KVCommand<AetherKey>> cluster,
+        KVStore<AetherKey, AetherValue> kvStore,
+        MessageRouter router,
+        AtomicReference<ClusterDeploymentState> state) implements ClusterDeploymentManager {
             private static final Logger log = LoggerFactory.getLogger(clusterDeploymentManager.class);
 
             @Override
             public void onLeaderChange(LeaderChange leaderChange) {
                 if (leaderChange.localNodeIsLeader()) {
                     log.info("Node {} became leader, activating cluster deployment manager", self);
-
                     var activeState = new ClusterDeploymentState.Active(
-                            self,
-                            cluster,
-                            kvStore,
-                            router,
-                            new ConcurrentHashMap<>(),
-                            new ConcurrentHashMap<>(),
-                            new CopyOnWriteArrayList<>()
-                    );
-
+                    self,
+                    cluster,
+                    kvStore,
+                    router,
+                    new ConcurrentHashMap<>(),
+                    new ConcurrentHashMap<>(),
+                    new CopyOnWriteArrayList<>());
                     state.set(activeState);
-
                     // Rebuild state from KVStore and reconcile
                     activeState.rebuildStateFromKVStore();
                     activeState.reconcile();
-                } else {
+                }else {
                     log.info("Node {} is not leader, deactivating cluster deployment manager", self);
                     state.set(new ClusterDeploymentState.Dormant());
                 }
@@ -394,26 +369,23 @@ public void onLeaderChange(LeaderChange leaderChange) {
 
             @Override
             public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-                state.get().onValuePut(valuePut);
+                state.get()
+                     .onValuePut(valuePut);
             }
 
             @Override
             public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-                state.get().onValueRemove(valueRemove);
+                state.get()
+                     .onValueRemove(valueRemove);
             }
 
             @Override
             public void onTopologyChange(TopologyChangeNotification topologyChange) {
-                state.get().onTopologyChange(topologyChange);
+                state.get()
+                     .onTopologyChange(topologyChange);
             }
         }
-
         return new clusterDeploymentManager(
-                self,
-                cluster,
-                kvStore,
-                router,
-                new AtomicReference<>(new ClusterDeploymentState.Dormant())
-        );
+        self, cluster, kvStore, router, new AtomicReference<>(new ClusterDeploymentState.Dormant()));
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
index 0a8018d5..768e23b0 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
@@ -33,8 +33,6 @@
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.message.MessageReceiver;
 import org.pragmatica.message.MessageRouter;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.Map;
@@ -43,6 +41,9 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 public interface NodeDeploymentManager {
     record SliceDeployment(SliceNodeKey key, SliceState state, long timestamp) {}
 
@@ -56,89 +57,88 @@ record SliceDeployment(SliceNodeKey key, SliceState state, long timestamp) {}
     void onQuorumStateChange(QuorumStateNotification quorumStateNotification);
 
     sealed interface NodeDeploymentState {
-        default void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-        }
+        default void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {}
 
-        default void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-        }
+        default void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {}
 
         record DormantNodeDeploymentState() implements NodeDeploymentState {}
 
         record ActiveNodeDeploymentState(
-                NodeId self,
-                SliceStore sliceStore,
-                SliceActionConfig configuration,
-                ClusterNode<KVCommand<AetherKey>> cluster,
-                KVStore<AetherKey, AetherValue> kvStore,
-                InvocationHandler invocationHandler,
-                RouteRegistry routeRegistry,
-                MessageRouter router,
-                ConcurrentHashMap<SliceNodeKey, SliceDeployment> deployments
-        ) implements NodeDeploymentState {
-
+        NodeId self,
+        SliceStore sliceStore,
+        SliceActionConfig configuration,
+        ClusterNode<KVCommand<AetherKey>> cluster,
+        KVStore<AetherKey, AetherValue> kvStore,
+        InvocationHandler invocationHandler,
+        RouteRegistry routeRegistry,
+        MessageRouter router,
+        ConcurrentHashMap<SliceNodeKey, SliceDeployment> deployments) implements NodeDeploymentState {
             private static final Logger log = LoggerFactory.getLogger(ActiveNodeDeploymentState.class);
-            private static final Fn1<Cause, Class<?>> UNEXPECTED_VALUE_TYPE =
-                    Causes.forOneValue("Unexpected value type for slice-node key: {}");
-            private static final Fn1<Cause, SliceNodeKey> CLEANUP_FAILED =
-                    Causes.forOneValue("Failed to cleanup slice {} during abrupt removal");
-            private static final Fn1<Cause, SliceNodeKey> STATE_UPDATE_FAILED =
-                    Causes.forOneValue("Failed to update slice state for {}");
-            private static final Fn1<Cause, SliceNodeKey> UNLOAD_FAILED =
-                    Causes.forOneValue("Failed to unload slice {}");
+
+            private static final Fn1<Cause, Class< ? >>UNEXPECTED_VALUE_TYPE = Causes.forOneValue("Unexpected value type for slice-node key: {}");
+
+            private static final Fn1<Cause, SliceNodeKey>CLEANUP_FAILED = Causes.forOneValue("Failed to cleanup slice {} during abrupt removal");
+
+            private static final Fn1<Cause, SliceNodeKey>STATE_UPDATE_FAILED = Causes.forOneValue("Failed to update slice state for {}");
+
+            private static final Fn1<Cause, SliceNodeKey>UNLOAD_FAILED = Causes.forOneValue("Failed to unload slice {}");
 
             public void whenOurKeyMatches(AetherKey key, Consumer<SliceNodeKey> action) {
                 switch (key) {
                     case SliceNodeKey sliceKey when sliceKey.isForNode(self) -> action.accept(sliceKey);
-                    default -> {
-                    }
+                    default -> {}
                 }
             }
 
             @Override
             public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-                whenOurKeyMatches(valuePut.cause().key(), sliceKey -> {
-                    var value = valuePut.cause().value();
-
-                    switch (value) {
-                        case SliceNodeValue(SliceState state) -> {
-                            log.debug("ValuePut received for key: {}, state: {}", sliceKey, state);
-                            recordDeployment(sliceKey, state);
-                            processStateTransition(sliceKey, state);
-                        }
-                        default -> log.warn(UNEXPECTED_VALUE_TYPE.apply(value.getClass()).message());
-                    }
-                });
+                whenOurKeyMatches(valuePut.cause()
+                                          .key(),
+                                  sliceKey -> {
+                                      var value = valuePut.cause()
+                                                          .value();
+                                      switch (value) {
+                    case SliceNodeValue(SliceState state) -> {
+                                      log.debug("ValuePut received for key: {}, state: {}", sliceKey, state);
+                                      recordDeployment(sliceKey, state);
+                                      processStateTransition(sliceKey, state);
+                                  }
+                    default -> log.warn(UNEXPECTED_VALUE_TYPE.apply(value.getClass())
+                                                             .message());
+                }
+                                  });
             }
 
             @Override
             public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-                whenOurKeyMatches(valueRemove.cause().key(), sliceKey -> {
-                    log.debug("ValueRemove received for key: {}", sliceKey);
-
-                    // WARNING: Removal may happen during abrupt stop due to lack of consensus.
-                    // In this case slice might be active and we should immediately stop it,
-                    // unload and remove, ignoring errors.
-                    var deployment = deployments.remove(sliceKey);
-
-                    if (shouldForceCleanup(deployment)) {
-                        forceCleanupSlice(sliceKey);
-                    }
-                });
+                whenOurKeyMatches(valueRemove.cause()
+                                             .key(),
+                                  sliceKey -> {
+                                      log.debug("ValueRemove received for key: {}", sliceKey);
+                                      // WARNING: Removal may happen during abrupt stop due to lack of consensus.
+                // In this case slice might be active and we should immediately stop it,
+                // unload and remove, ignoring errors.
+                var deployment = deployments.remove(sliceKey);
+                                      if (shouldForceCleanup(deployment)) {
+                                      forceCleanupSlice(sliceKey);
+                                  }
+                                  });
             }
 
             private void recordDeployment(SliceNodeKey sliceKey, SliceState state) {
                 var timestamp = System.currentTimeMillis();
                 var previousDeployment = deployments.get(sliceKey);
-                var previousState = previousDeployment != null ? previousDeployment.state() : null;
-
+                var previousState = previousDeployment != null
+                                    ? previousDeployment.state()
+                                    : null;
                 var deployment = new SliceDeployment(sliceKey, state, timestamp);
                 deployments.put(sliceKey, deployment);
-
                 // Emit state transition event for metrics via MessageRouter
                 // For initial LOAD, use LOAD as both from and to (captures loadTime)
-                var effectiveFromState = previousState != null ? previousState : state;
+                var effectiveFromState = previousState != null
+                                         ? previousState
+                                         : state;
                 router.route(new StateTransition(sliceKey.artifact(), self, effectiveFromState, state, timestamp));
-
                 // Emit deployment failed event if transitioning to FAILED
                 // We do this here because we have access to previousState
                 if (state == SliceState.FAILED && previousState != null) {
@@ -163,43 +163,42 @@ private void logCleanupFailure(SliceNodeKey sliceKey, Cause cause) {
             private void processStateTransition(SliceNodeKey sliceKey, SliceState state) {
                 switch (state) {
                     case LOAD -> handleLoading(sliceKey);
-                    case LOADING -> {
-                    } // Transitional state, no action
+                    case LOADING -> {}
+                    // Transitional state, no action
                     case LOADED -> handleLoaded(sliceKey);
                     case ACTIVATE -> handleActivating(sliceKey);
-                    case ACTIVATING -> {
-                    } // Transitional state, no action
+                    case ACTIVATING -> {}
+                    // Transitional state, no action
                     case ACTIVE -> handleActive(sliceKey);
                     case DEACTIVATE -> handleDeactivating(sliceKey);
-                    case DEACTIVATING -> {
-                    } // Transitional state, no action
+                    case DEACTIVATING -> {}
+                    // Transitional state, no action
                     case FAILED -> handleFailed(sliceKey);
                     case UNLOAD -> handleUnloading(sliceKey);
-                    case UNLOADING -> {
-                    } // Transitional state, no action
+                    case UNLOADING -> {}
                 }
             }
 
             private void handleLoading(SliceNodeKey sliceKey) {
                 executeWithStateTransition(
-                        sliceKey,
-                        SliceState.LOADING,
-                        sliceStore.loadSlice(sliceKey.artifact()),
-                        SliceState.LOADED,
-                        SliceState.FAILED
-                                          );
+                sliceKey,
+                SliceState.LOADING,
+                sliceStore.loadSlice(sliceKey.artifact()),
+                SliceState.LOADED,
+                SliceState.FAILED);
             }
 
             private void handleLoaded(SliceNodeKey sliceKey) {
                 // Only auto-activate if slice is actually loaded in our store
                 // (protects against externally-set states like in tests)
-                var isLoaded = sliceStore.loaded().stream()
-                        .anyMatch(ls -> ls.artifact().equals(sliceKey.artifact()));
-
+                var isLoaded = sliceStore.loaded()
+                                         .stream()
+                                         .anyMatch(ls -> ls.artifact()
+                                                           .equals(sliceKey.artifact()));
                 if (isLoaded) {
                     log.info("Slice {} loaded, auto-activating", sliceKey.artifact());
                     transitionTo(sliceKey, SliceState.ACTIVATE);
-                } else {
+                }else {
                     log.debug("Slice {} state is LOADED but not found in SliceStore, skipping auto-activation",
                               sliceKey.artifact());
                 }
@@ -207,18 +206,18 @@ private void handleLoaded(SliceNodeKey sliceKey) {
 
             private void handleActivating(SliceNodeKey sliceKey) {
                 // Only activate if slice is actually loaded in our store
-                var isLoaded = sliceStore.loaded().stream()
-                        .anyMatch(ls -> ls.artifact().equals(sliceKey.artifact()));
-
+                var isLoaded = sliceStore.loaded()
+                                         .stream()
+                                         .anyMatch(ls -> ls.artifact()
+                                                           .equals(sliceKey.artifact()));
                 if (isLoaded) {
                     executeWithStateTransition(
-                            sliceKey,
-                            SliceState.ACTIVATING,
-                            sliceStore.activateSlice(sliceKey.artifact()),
-                            SliceState.ACTIVE,
-                            SliceState.FAILED
-                                              );
-                } else {
+                    sliceKey,
+                    SliceState.ACTIVATING,
+                    sliceStore.activateSlice(sliceKey.artifact()),
+                    SliceState.ACTIVE,
+                    SliceState.FAILED);
+                }else {
                     log.debug("Slice {} state is ACTIVATE but not found in SliceStore, skipping activation",
                               sliceKey.artifact());
                 }
@@ -238,34 +237,40 @@ private void handleActive(SliceNodeKey sliceKey) {
 
             private void registerRoutes(SliceNodeKey sliceKey) {
                 var artifact = sliceKey.artifact();
-                var loadedSlice = sliceStore.loaded().stream()
-                        .filter(ls -> ls.artifact().equals(artifact))
-                        .findFirst();
-
+                var loadedSlice = sliceStore.loaded()
+                                            .stream()
+                                            .filter(ls -> ls.artifact()
+                                                            .equals(artifact))
+                                            .findFirst();
                 loadedSlice.ifPresent(ls -> {
-                    var slice = ls.slice();
-                    var routes = slice.routes();
-
-                    if (routes.isEmpty()) {
-                        return;
-                    }
-
-                    routes.forEach(route -> {
-                        var bindings = route.bindings().stream()
-                                .map(this::toBinding)
-                                .toList();
-
-                        routeRegistry.register(artifact, route.methodName(), route.httpMethod(),
-                                               route.pathPattern(), bindings)
-                                     .onSuccess(_ -> log.info("Registered route {} {} -> {}:{}",
-                                                              route.httpMethod(), route.pathPattern(),
-                                                              artifact.asString(), route.methodName()))
-                                     .onFailure(cause -> log.error("Failed to register route {} {} -> {}:{}: {}",
-                                                                   route.httpMethod(), route.pathPattern(),
-                                                                   artifact.asString(), route.methodName(),
-                                                                   cause.message()));
-                    });
-                });
+                                          var slice = ls.slice();
+                                          var routes = slice.routes();
+                                          if (routes.isEmpty()) {
+                                          return;
+                                      }
+                                          routes.forEach(route -> {
+                                                             var bindings = route.bindings()
+                                                                                 .stream()
+                                                                                 .map(this::toBinding)
+                                                                                 .toList();
+                                                             routeRegistry.register(artifact,
+                                                                                    route.methodName(),
+                                                                                    route.httpMethod(),
+                                                                                    route.pathPattern(),
+                                                                                    bindings)
+                                                                          .onSuccess(_ -> log.info("Registered route {} {} -> {}:{}",
+                                                                                                   route.httpMethod(),
+                                                                                                   route.pathPattern(),
+                                                                                                   artifact.asString(),
+                                                                                                   route.methodName()))
+                                                                          .onFailure(cause -> log.error("Failed to register route {} {} -> {}:{}: {}",
+                                                                                                        route.httpMethod(),
+                                                                                                        route.pathPattern(),
+                                                                                                        artifact.asString(),
+                                                                                                        route.methodName(),
+                                                                                                        cause.message()));
+                                                         });
+                                      });
             }
 
             private Binding toBinding(SliceRoute.RouteBinding binding) {
@@ -280,29 +285,30 @@ private Binding toBinding(SliceRoute.RouteBinding binding) {
 
             private void registerSliceForInvocation(SliceNodeKey sliceKey) {
                 var artifact = sliceKey.artifact();
-                var loadedSlice = sliceStore.loaded().stream()
-                        .filter(ls -> ls.artifact().equals(artifact))
-                        .findFirst();
-
+                var loadedSlice = sliceStore.loaded()
+                                            .stream()
+                                            .filter(ls -> ls.artifact()
+                                                            .equals(artifact))
+                                            .findFirst();
                 loadedSlice.ifPresent(ls -> {
-                    var slice = ls.slice();
-                    // Use configured provider or default to Fury (thread-safe, no pooling needed)
-                    SerializerFactoryProvider serializerProvider = configuration.serializerProvider();
-                    if (serializerProvider == null) {
-                        serializerProvider = FurySerializerFactoryProvider.furySerializerFactoryProvider();
-                    }
-
-                    // Create SerializerFactory from provider using all type tokens
-                    var typeTokens = slice.methods().stream()
-                            .flatMap(m -> java.util.stream.Stream.of(m.parameterType(), m.returnType()))
-                            .collect(Collectors.toList());
-                    var serializerFactory = serializerProvider.createFactory(typeTokens);
-
-                    // Create and register SliceBridge
-                    var sliceBridge = SliceBridgeImpl.sliceBridge(artifact, slice, serializerFactory);
-                    invocationHandler.registerSlice(artifact, sliceBridge);
-                    log.info("Registered slice {} for invocation", artifact);
-                });
+                                          var slice = ls.slice();
+                                          // Use configured provider or default to Fury (thread-safe, no pooling needed)
+                SerializerFactoryProvider serializerProvider = configuration.serializerProvider();
+                                          if (serializerProvider == null) {
+                                          serializerProvider = FurySerializerFactoryProvider.furySerializerFactoryProvider();
+                                      }
+                                          // Create SerializerFactory from provider using all type tokens
+                var typeTokens = slice.methods()
+                                      .stream()
+                                      .flatMap(m -> java.util.stream.Stream.of(m.parameterType(),
+                                                                               m.returnType()))
+                                      .collect(Collectors.toList());
+                                          var serializerFactory = serializerProvider.createFactory(typeTokens);
+                                          // Create and register SliceBridge
+                var sliceBridge = SliceBridgeImpl.sliceBridge(artifact, slice, serializerFactory);
+                                          invocationHandler.registerSlice(artifact, sliceBridge);
+                                          log.info("Registered slice {} for invocation", artifact);
+                                      });
             }
 
             private void unregisterSliceFromInvocation(SliceNodeKey sliceKey) {
@@ -313,31 +319,37 @@ private void unregisterSliceFromInvocation(SliceNodeKey sliceKey) {
 
             private void publishEndpoints(SliceNodeKey sliceKey) {
                 var artifact = sliceKey.artifact();
-                var loadedSlice = sliceStore.loaded().stream()
-                        .filter(ls -> ls.artifact().equals(artifact))
-                        .findFirst();
-
+                var loadedSlice = sliceStore.loaded()
+                                            .stream()
+                                            .filter(ls -> ls.artifact()
+                                                            .equals(artifact))
+                                            .findFirst();
                 loadedSlice.ifPresent(ls -> {
-                    var slice = ls.slice();
-                    var methods = slice.methods();
-                    // Use nodeId hash as instance number to ensure uniqueness across cluster
-                    int instanceNumber = Math.abs(self.id().hashCode());
-
-                    var commands = methods.stream()
-                            .map(method -> createEndpointPutCommand(artifact, method.name(), instanceNumber))
-                            .toList();
-
-                    if (!commands.isEmpty()) {
-                        cluster.apply(commands)
-                               .onSuccess(_ -> log.info("Published {} endpoints for slice {}", methods.size(), artifact))
-                               .onFailure(cause -> log.error("Failed to publish endpoints for {}: {}", artifact, cause.message()));
-                    }
-                });
+                                          var slice = ls.slice();
+                                          var methods = slice.methods();
+                                          // Use nodeId hash as instance number to ensure uniqueness across cluster
+                int instanceNumber = Math.abs(self.id()
+                                                  .hashCode());
+                                          var commands = methods.stream()
+                                                                .map(method -> createEndpointPutCommand(artifact,
+                                                                                                        method.name(),
+                                                                                                        instanceNumber))
+                                                                .toList();
+                                          if (!commands.isEmpty()) {
+                                          cluster.apply(commands)
+                                                 .onSuccess(_ -> log.info("Published {} endpoints for slice {}",
+                                                                          methods.size(),
+                                                                          artifact))
+                                                 .onFailure(cause -> log.error("Failed to publish endpoints for {}: {}",
+                                                                               artifact,
+                                                                               cause.message()));
+                                      }
+                                      });
             }
 
             private KVCommand<AetherKey> createEndpointPutCommand(org.pragmatica.aether.artifact.Artifact artifact,
-                                                                   MethodName methodName,
-                                                                   int instanceNumber) {
+                                                                  MethodName methodName,
+                                                                  int instanceNumber) {
                 var key = new EndpointKey(artifact, methodName, instanceNumber);
                 var value = new EndpointValue(self);
                 return new KVCommand.Put<>(key, value);
@@ -350,87 +362,90 @@ private void handleDeactivating(SliceNodeKey sliceKey) {
                 // 3. Check if this is the last instance and unregister routes if so
                 // 4. Then deactivate the slice
                 unpublishEndpoints(sliceKey)
-                    .onResultRun(() -> {
-                        unregisterSliceFromInvocation(sliceKey);
-                        unregisterRoutesIfLastInstance(sliceKey);
-                        executeWithStateTransition(
-                                sliceKey,
-                                SliceState.DEACTIVATING,
-                                sliceStore.deactivateSlice(sliceKey.artifact()),
-                                SliceState.LOADED,
-                                SliceState.FAILED
-                        );
-                    });
+                .onResultRun(() -> {
+                                 unregisterSliceFromInvocation(sliceKey);
+                                 unregisterRoutesIfLastInstance(sliceKey);
+                                 executeWithStateTransition(
+                sliceKey,
+                SliceState.DEACTIVATING,
+                sliceStore.deactivateSlice(sliceKey.artifact()),
+                SliceState.LOADED,
+                SliceState.FAILED);
+                             });
             }
 
             private void unregisterRoutesIfLastInstance(SliceNodeKey sliceKey) {
                 var artifact = sliceKey.artifact();
-
                 // Count active instances of this artifact across all nodes
-                var activeCount = kvStore.snapshot().entrySet().stream()
-                        .filter(e -> e.getKey() instanceof SliceNodeKey snk && snk.artifact().equals(artifact))
-                        .filter(e -> e.getValue() instanceof SliceNodeValue snv && snv.state() == SliceState.ACTIVE)
-                        .filter(e -> !((SliceNodeKey) e.getKey()).nodeId().equals(self)) // Exclude ourselves
-                        .count();
-
+                var activeCount = kvStore.snapshot()
+                                         .entrySet()
+                                         .stream()
+                                         .filter(e -> e.getKey() instanceof SliceNodeKey snk && snk.artifact()
+                                                                                                   .equals(artifact))
+                                         .filter(e -> e.getValue() instanceof SliceNodeValue snv && snv.state() == SliceState.ACTIVE)
+                                         .filter(e -> !((SliceNodeKey) e.getKey()).nodeId()
+                                                                        .equals(self))
+                                         .count();
                 if (activeCount == 0) {
                     // This is the last active instance, unregister routes
                     log.info("Last instance of {} deactivating, unregistering routes", artifact.asString());
                     routeRegistry.unregister(artifact)
-                                 .onSuccess(_ -> log.debug("Routes unregistered for {}", artifact.asString()))
+                                 .onSuccess(_ -> log.debug("Routes unregistered for {}",
+                                                           artifact.asString()))
                                  .onFailure(cause -> log.error("Failed to unregister routes for {}: {}",
-                                                               artifact.asString(), cause.message()));
-                } else {
+                                                               artifact.asString(),
+                                                               cause.message()));
+                }else {
                     log.debug("Slice {} has {} other active instances, keeping routes", artifact.asString(), activeCount);
                 }
             }
 
             private Promise<Unit> unpublishEndpoints(SliceNodeKey sliceKey) {
                 var artifact = sliceKey.artifact();
-                var loadedSlice = sliceStore.loaded().stream()
-                        .filter(ls -> ls.artifact().equals(artifact))
-                        .findFirst();
-
+                var loadedSlice = sliceStore.loaded()
+                                            .stream()
+                                            .filter(ls -> ls.artifact()
+                                                            .equals(artifact))
+                                            .findFirst();
                 if (loadedSlice.isEmpty()) {
                     return Promise.success(Unit.unit());
                 }
-
                 var ls = loadedSlice.get();
                 var slice = ls.slice();
                 var methods = slice.methods();
-                int instanceNumber = Math.abs(self.id().hashCode());
-
+                int instanceNumber = Math.abs(self.id()
+                                                  .hashCode());
                 var commands = methods.stream()
-                        .map(method -> createEndpointRemoveCommand(artifact, method.name(), instanceNumber))
-                        .toList();
-
+                                      .map(method -> createEndpointRemoveCommand(artifact,
+                                                                                 method.name(),
+                                                                                 instanceNumber))
+                                      .toList();
                 if (commands.isEmpty()) {
                     return Promise.success(Unit.unit());
                 }
-
                 return cluster.apply(commands)
-                       .map(_ -> {
-                           log.info("Unpublished {} endpoints for slice {}", methods.size(), artifact);
-                           return Unit.unit();
-                       })
-                       .mapError(cause -> {
-                           log.error("Failed to unpublish endpoints for {}: {}", artifact, cause.message());
-                           return cause;
-                       });
+                              .map(_ -> {
+                                       log.info("Unpublished {} endpoints for slice {}",
+                                                methods.size(),
+                                                artifact);
+                                       return Unit.unit();
+                                   })
+                              .mapError(cause -> {
+                                            log.error("Failed to unpublish endpoints for {}: {}",
+                                                      artifact,
+                                                      cause.message());
+                                            return cause;
+                                        });
             }
 
             private KVCommand<AetherKey> createEndpointRemoveCommand(org.pragmatica.aether.artifact.Artifact artifact,
-                                                                      MethodName methodName,
-                                                                      int instanceNumber) {
+                                                                     MethodName methodName,
+                                                                     int instanceNumber) {
                 var key = new EndpointKey(artifact, methodName, instanceNumber);
                 return new KVCommand.Remove<>(key);
             }
 
-            private void handleFailed(SliceNodeKey sliceKey) {
-                // Slice has failed - cleanup and prepare for unloading
-                // Log the failure and await UNLOAD command
-                // Note: DeploymentFailed event is emitted in recordDeployment() where we have access to previousState
-            }
+            private void handleFailed(SliceNodeKey sliceKey) {}
 
             private void handleUnloading(SliceNodeKey sliceKey) {
                 // TODO: move timeouts to SliceStore.
@@ -439,28 +454,22 @@ private void handleUnloading(SliceNodeKey sliceKey) {
                 //  This may result in incorrect handling of subsequent operations as they will
                 //  be executed only when original operation is completed.
                 configuration.timeoutFor(SliceState.UNLOADING)
-                             .onSuccess(timeout ->
-                                                sliceStore.unloadSlice(sliceKey.artifact())
-                                                          .timeout(timeout)
-                                                          .onSuccess(_ -> removeFromDeployments(sliceKey))
-                                                          .onFailure(cause -> handleUnloadFailure(sliceKey, cause))
-                                       )
+                             .onSuccess(timeout -> sliceStore.unloadSlice(sliceKey.artifact())
+                                                             .timeout(timeout)
+                                                             .onSuccess(_ -> removeFromDeployments(sliceKey))
+                                                             .onFailure(cause -> handleUnloadFailure(sliceKey, cause)))
                              .onFailure(cause -> handleUnloadFailure(sliceKey, cause));
             }
 
-            private void executeWithStateTransition(
-                    SliceNodeKey sliceKey,
-                    SliceState currentState,
-                    Promise<?> operation,
-                    SliceState successState,
-                    SliceState failureState
-                                                   ) {
+            private void executeWithStateTransition(SliceNodeKey sliceKey,
+                                                    SliceState currentState,
+                                                    Promise< ? > operation,
+                                                    SliceState successState,
+                                                    SliceState failureState) {
                 configuration.timeoutFor(currentState)
-                             .onSuccess(timeout ->
-                                                operation.timeout(timeout)
-                                                         .onSuccess(_ -> transitionTo(sliceKey, successState))
-                                                         .onFailure(_ -> transitionTo(sliceKey, failureState))
-                                       )
+                             .onSuccess(timeout -> operation.timeout(timeout)
+                                                            .onSuccess(_ -> transitionTo(sliceKey, successState))
+                                                            .onFailure(_ -> transitionTo(sliceKey, failureState)))
                              .onFailure(cause -> logStateUpdateFailure(sliceKey, cause));
             }
 
@@ -480,7 +489,6 @@ private void handleUnloadFailure(SliceNodeKey sliceKey, Cause cause) {
             private void updateSliceState(SliceNodeKey sliceKey, SliceState newState) {
                 var value = new SliceNodeValue(newState);
                 KVCommand<AetherKey> command = new KVCommand.Put<>(sliceKey, value);
-
                 // Submit command to cluster for consensus
                 cluster.apply(List.of(command))
                        .onFailure(cause -> logStateUpdateFailure(sliceKey, cause));
@@ -491,7 +499,9 @@ private void logStateUpdateFailure(SliceNodeKey sliceKey, Cause cause) {
             }
 
             private void logError(Fn1<Cause, SliceNodeKey> errorTemplate, SliceNodeKey sliceKey, Cause cause) {
-                log.error(errorTemplate.apply(sliceKey).message() + ": {}", cause.message());
+                log.error(errorTemplate.apply(sliceKey)
+                                       .message() + ": {}",
+                          cause.message());
             }
         }
     }
@@ -503,7 +513,14 @@ static NodeDeploymentManager nodeDeploymentManager(NodeId self,
                                                        KVStore<AetherKey, AetherValue> kvStore,
                                                        InvocationHandler invocationHandler,
                                                        RouteRegistry routeRegistry) {
-        return nodeDeploymentManager(self, router, sliceStore, cluster, kvStore, invocationHandler, routeRegistry, SliceActionConfig.defaultConfiguration());
+        return nodeDeploymentManager(self,
+                                     router,
+                                     sliceStore,
+                                     cluster,
+                                     kvStore,
+                                     invocationHandler,
+                                     routeRegistry,
+                                     SliceActionConfig.defaultConfiguration());
     }
 
     static NodeDeploymentManager nodeDeploymentManager(NodeId self,
@@ -515,60 +532,59 @@ static NodeDeploymentManager nodeDeploymentManager(NodeId self,
                                                        RouteRegistry routeRegistry,
                                                        SliceActionConfig configuration) {
         record deploymentManager(
-                NodeId self,
-                SliceStore sliceStore,
-                ClusterNode<KVCommand<AetherKey>> cluster,
-                KVStore<AetherKey, AetherValue> kvStore,
-                InvocationHandler invocationHandler,
-                RouteRegistry routeRegistry,
-                SliceActionConfig configuration,
-                MessageRouter router,
-                AtomicReference<NodeDeploymentState> state
-        ) implements NodeDeploymentManager {
-
+        NodeId self,
+        SliceStore sliceStore,
+        ClusterNode<KVCommand<AetherKey>> cluster,
+        KVStore<AetherKey, AetherValue> kvStore,
+        InvocationHandler invocationHandler,
+        RouteRegistry routeRegistry,
+        SliceActionConfig configuration,
+        MessageRouter router,
+        AtomicReference<NodeDeploymentState> state) implements NodeDeploymentManager {
             @Override
             public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-                state.get().onValuePut(valuePut);
+                state.get()
+                     .onValuePut(valuePut);
             }
 
             @Override
             public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-                state.get().onValueRemove(valueRemove);
+                state.get()
+                     .onValueRemove(valueRemove);
             }
 
             @Override
             public void onQuorumStateChange(QuorumStateNotification quorumStateNotification) {
                 switch (quorumStateNotification) {
-                    case ESTABLISHED -> state().set(new NodeDeploymentState.ActiveNodeDeploymentState(
-                            self(),
-                            sliceStore(),
-                            configuration(),
-                            cluster(),
-                            kvStore(),
-                            invocationHandler(),
-                            routeRegistry(),
-                            router(),
-                            new ConcurrentHashMap<>()
-                    ));
+                    case ESTABLISHED -> state()
+                                        .set(new NodeDeploymentState.ActiveNodeDeploymentState(
+                    self(),
+                    sliceStore(),
+                    configuration(),
+                    cluster(),
+                    kvStore(),
+                    invocationHandler(),
+                    routeRegistry(),
+                    router(),
+                    new ConcurrentHashMap<>()));
                     case DISAPPEARED -> {
                         // Clean up any pending operations before going dormant
                         // Individual Promise timeouts will handle their own cleanup
-                        state().set(new NodeDeploymentState.DormantNodeDeploymentState());
+                        state()
+                        .set(new NodeDeploymentState.DormantNodeDeploymentState());
                     }
                 }
             }
         }
-
         return new deploymentManager(
-                self,
-                sliceStore,
-                cluster,
-                kvStore,
-                invocationHandler,
-                routeRegistry,
-                configuration,
-                router,
-                new AtomicReference<>(new NodeDeploymentState.DormantNodeDeploymentState())
-        );
+        self,
+        sliceStore,
+        cluster,
+        kvStore,
+        invocationHandler,
+        routeRegistry,
+        configuration,
+        router,
+        new AtomicReference<>(new NodeDeploymentState.DormantNodeDeploymentState()));
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
index a0b9198e..027ae04d 100644
--- a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
@@ -11,8 +11,6 @@
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
 import org.pragmatica.lang.Option;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.Comparator;
 import java.util.List;
@@ -20,6 +18,9 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Passive KV-Store watcher that maintains a local cache of all cluster endpoints.
  *
@@ -35,7 +36,6 @@
  * Slices automatically publish/unpublish endpoints via consensus.
  */
 public interface EndpointRegistry {
-
     @MessageReceiver
     void onValuePut(ValuePut<AetherKey, AetherValue> valuePut);
 
@@ -62,11 +62,10 @@ public interface EndpointRegistry {
      * Endpoint representation with location information.
      */
     record Endpoint(
-            Artifact artifact,
-            MethodName methodName,
-            int instanceNumber,
-            NodeId nodeId
-    ) {
+    Artifact artifact,
+    MethodName methodName,
+    int instanceNumber,
+    NodeId nodeId) {
         public EndpointKey toKey() {
             return new EndpointKey(artifact, methodName, instanceNumber);
         }
@@ -77,25 +76,22 @@ public EndpointKey toKey() {
      */
     static EndpointRegistry endpointRegistry() {
         record endpointRegistry(
-                Map<EndpointKey, Endpoint> endpoints,
-                Map<String, AtomicInteger> roundRobinCounters
-        ) implements EndpointRegistry {
-
+        Map<EndpointKey, Endpoint> endpoints,
+        Map<String, AtomicInteger> roundRobinCounters) implements EndpointRegistry {
             private static final Logger log = LoggerFactory.getLogger(endpointRegistry.class);
 
             @Override
             public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-                var key = valuePut.cause().key();
-                var value = valuePut.cause().value();
-
+                var key = valuePut.cause()
+                                  .key();
+                var value = valuePut.cause()
+                                    .value();
                 if (key instanceof EndpointKey endpointKey && value instanceof EndpointValue endpointValue) {
                     var endpoint = new Endpoint(
-                            endpointKey.artifact(),
-                            endpointKey.methodName(),
-                            endpointKey.instanceNumber(),
-                            endpointValue.nodeId()
-                    );
-
+                    endpointKey.artifact(),
+                    endpointKey.methodName(),
+                    endpointKey.instanceNumber(),
+                    endpointValue.nodeId());
                     endpoints.put(endpointKey, endpoint);
                     log.debug("Registered endpoint: {}", endpoint);
                 }
@@ -103,8 +99,8 @@ public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
 
             @Override
             public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-                var key = valueRemove.cause().key();
-
+                var key = valueRemove.cause()
+                                     .key();
                 if (key instanceof EndpointKey endpointKey) {
                     var removed = endpoints.remove(endpointKey);
                     if (removed != null) {
@@ -115,27 +111,29 @@ public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
 
             @Override
             public List<Endpoint> findEndpoints(Artifact artifact, MethodName methodName) {
-                return endpoints.values().stream()
-                                .filter(e -> e.artifact().equals(artifact) && e.methodName().equals(methodName))
+                return endpoints.values()
+                                .stream()
+                                .filter(e -> e.artifact()
+                                              .equals(artifact) && e.methodName()
+                                                                    .equals(methodName))
                                 .toList();
             }
 
             @Override
             public Option<Endpoint> selectEndpoint(Artifact artifact, MethodName methodName) {
                 // Sort endpoints to ensure consistent round-robin order across calls
-                var available = findEndpoints(artifact, methodName).stream()
-                        .sorted(Comparator.comparing(e -> e.nodeId().id()))
-                        .toList();
-
+                var available = findEndpoints(artifact, methodName)
+                                .stream()
+                                .sorted(Comparator.comparing(e -> e.nodeId()
+                                                                   .id()))
+                                .toList();
                 if (available.isEmpty()) {
                     return Option.none();
                 }
-
                 var lookupKey = artifact.asString() + "/" + methodName.name();
                 var counter = roundRobinCounters.computeIfAbsent(lookupKey, _ -> new AtomicInteger(0));
                 // Use bitmask to ensure positive value (handles Integer.MIN_VALUE edge case)
                 var index = (counter.getAndIncrement() & 0x7FFFFFFF) % available.size();
-
                 return Option.option(available.get(index));
             }
 
@@ -144,10 +142,7 @@ public List<Endpoint> allEndpoints() {
                 return List.copyOf(endpoints.values());
             }
         }
-
         return new endpointRegistry(
-                new ConcurrentHashMap<>(),
-                new ConcurrentHashMap<>()
-        );
+        new ConcurrentHashMap<>(), new ConcurrentHashMap<>());
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java b/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
index 0a124321..14bf3a75 100644
--- a/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
+++ b/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
@@ -13,7 +13,6 @@
  * Resolves route bindings from request context to build method parameters.
  */
 public interface BindingResolver {
-
     /**
      * Resolve all bindings for a route from the request context.
      *
@@ -32,7 +31,6 @@ static BindingResolver bindingResolver(Deserializer deserializer) {
 }
 
 class BindingResolverImpl implements BindingResolver {
-
     private final Deserializer deserializer;
 
     BindingResolverImpl(Deserializer deserializer) {
@@ -42,7 +40,6 @@ class BindingResolverImpl implements BindingResolver {
     @Override
     public Result<Map<String, Object>> resolve(List<Binding> bindings, RequestContext context) {
         var result = new HashMap<String, Object>();
-
         for (var binding : bindings) {
             var valueResult = resolveBinding(binding, context);
             if (valueResult.isFailure()) {
@@ -50,42 +47,35 @@ public Result<Map<String, Object>> resolve(List<Binding> bindings, RequestContex
             }
             valueResult.onSuccess(value -> result.put(binding.param(), value));
         }
-
         return Result.success(result);
     }
 
     private Result<Object> resolveBinding(Binding binding, RequestContext context) {
         var source = binding.source();
-
         return switch (source) {
             case BindingSource.PathVar pv -> context.pathVariable(pv.name())
-                    .<Object>map(s -> s)
-                    .toResult(new HttpRouterError.BindingFailed(binding.param(), "Path variable not found: " + pv.name()));
-
+                                                    .<Object> map(s -> s)
+                                                    .toResult(new HttpRouterError.BindingFailed(binding.param(),
+                                                                                                "Path variable not found: " + pv.name()));
             case BindingSource.QueryVar qv -> context.queryParam(qv.name())
-                    .<Object>map(s -> s)
-                    .toResult(new HttpRouterError.BindingFailed(binding.param(), "Query parameter not found: " + qv.name()));
-
+                                                     .<Object> map(s -> s)
+                                                     .toResult(new HttpRouterError.BindingFailed(binding.param(),
+                                                                                                 "Query parameter not found: " + qv.name()));
             case BindingSource.Header h -> context.header(h.name())
-                    .<Object>map(s -> s)
-                    .toResult(new HttpRouterError.BindingFailed(binding.param(), "Header not found: " + h.name()));
-
+                                                  .<Object> map(s -> s)
+                                                  .toResult(new HttpRouterError.BindingFailed(binding.param(),
+                                                                                              "Header not found: " + h.name()));
             case BindingSource.Body ignored -> parseBody(context.body());
-
             case BindingSource.Cookie c -> Result.failure(
-                    new HttpRouterError.BindingFailed(binding.param(), "Cookie binding not implemented: " + c.name()));
-
+            new HttpRouterError.BindingFailed(binding.param(), "Cookie binding not implemented: " + c.name()));
             case BindingSource.Value ignored -> Result.failure(
-                    new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: value"));
-
+            new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: value"));
             case BindingSource.Key ignored -> Result.failure(
-                    new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: key"));
-
+            new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: key"));
             case BindingSource.Metadata ignored -> Result.failure(
-                    new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: metadata"));
-
+            new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: metadata"));
             case BindingSource.RequestField ignored -> Result.failure(
-                    new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: request"));
+            new HttpRouterError.BindingFailed(binding.param(), "Unsupported binding source for HTTP: request"));
         };
     }
 
@@ -93,13 +83,12 @@ private Result<Object> parseBody(byte[] body) {
         if (body == null || body.length == 0) {
             return Result.failure(new HttpRouterError.BindingFailed("body", "Request body is empty"));
         }
-
-        try {
+        try{
             var buf = io.netty.buffer.Unpooled.wrappedBuffer(body);
             return Result.success(deserializer.read(buf));
         } catch (Exception e) {
             return Result.failure(new HttpRouterError.DeserializationFailed(
-                    org.pragmatica.lang.utils.Causes.fromThrowable(e)));
+            org.pragmatica.lang.utils.Causes.fromThrowable(e)));
         }
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java b/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
index 26d3f16b..28c737c4 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
@@ -13,16 +13,15 @@ public enum HttpMethod {
     PATCH,
     HEAD,
     OPTIONS;
-
     public static HttpMethod fromString(String method) {
         return switch (method.toUpperCase(Locale.ROOT)) {
-            case "GET" -> GET;
-            case "POST" -> POST;
-            case "PUT" -> PUT;
-            case "DELETE" -> DELETE;
-            case "PATCH" -> PATCH;
-            case "HEAD" -> HEAD;
-            case "OPTIONS" -> OPTIONS;
+            case"GET" -> GET;
+            case"POST" -> POST;
+            case"PUT" -> PUT;
+            case"DELETE" -> DELETE;
+            case"PATCH" -> PATCH;
+            case"HEAD" -> HEAD;
+            case"OPTIONS" -> OPTIONS;
             default -> throw new IllegalArgumentException("Unknown HTTP method: " + method);
         };
     }
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpRouterError.java b/node/src/main/java/org/pragmatica/aether/http/HttpRouterError.java
index 6b8c8a56..659f5a4b 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpRouterError.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpRouterError.java
@@ -6,7 +6,6 @@
  * Errors that can occur during HTTP request processing.
  */
 public sealed interface HttpRouterError extends Cause {
-
     record RouteNotFound(String path) implements HttpRouterError {
         @Override
         public String message() {
diff --git a/node/src/main/java/org/pragmatica/aether/http/MatchResult.java b/node/src/main/java/org/pragmatica/aether/http/MatchResult.java
index f4269800..f92663d8 100644
--- a/node/src/main/java/org/pragmatica/aether/http/MatchResult.java
+++ b/node/src/main/java/org/pragmatica/aether/http/MatchResult.java
@@ -8,9 +8,8 @@
  * Result of matching a request to a route.
  */
 public record MatchResult(
-        Route route,
-        Map<String, String> pathVariables
-) {
+ Route route,
+ Map<String, String> pathVariables) {
     public static MatchResult matchResult(Route route, Map<String, String> pathVariables) {
         return new MatchResult(route, pathVariables);
     }
diff --git a/node/src/main/java/org/pragmatica/aether/http/PathPattern.java b/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
index afcd0f98..2eb77597 100644
--- a/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
+++ b/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
@@ -14,31 +14,26 @@
  * Supports path variables like {id}, {userId}, etc.
  */
 public record PathPattern(
-        HttpMethod method,
-        String originalPattern,
-        Pattern regex,
-        List<String> variableNames
-) {
+ HttpMethod method,
+ String originalPattern,
+ Pattern regex,
+ List<String> variableNames) {
     private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{([^}]+)}");
 
     public static PathPattern compile(String routePattern) {
         // Parse "GET:/api/users/{userId}" format
         var colonIndex = routePattern.indexOf(':');
-        if (colonIndex == -1) {
+        if (colonIndex == - 1) {
             throw new IllegalArgumentException("Route pattern must include method: " + routePattern);
         }
-
         var methodStr = routePattern.substring(0, colonIndex);
         var pathPattern = routePattern.substring(colonIndex + 1);
-
         var method = HttpMethod.fromString(methodStr);
         var variableNames = new ArrayList<String>();
-
         // Convert path pattern to regex
         var regexBuilder = new StringBuilder("^");
         var matcher = VARIABLE_PATTERN.matcher(pathPattern);
         var lastEnd = 0;
-
         while (matcher.find()) {
             // Escape literal part
             regexBuilder.append(Pattern.quote(pathPattern.substring(lastEnd, matcher.start())));
@@ -47,29 +42,27 @@ public static PathPattern compile(String routePattern) {
             variableNames.add(matcher.group(1));
             lastEnd = matcher.end();
         }
-
         // Add remaining literal part
         regexBuilder.append(Pattern.quote(pathPattern.substring(lastEnd)));
         regexBuilder.append("$");
-
-        return new PathPattern(method, routePattern, Pattern.compile(regexBuilder.toString()), variableNames);
+        return new PathPattern(method,
+                               routePattern,
+                               Pattern.compile(regexBuilder.toString()),
+                               variableNames);
     }
 
     public Option<Map<String, String>> match(HttpMethod requestMethod, String path) {
         if (requestMethod != method) {
             return Option.none();
         }
-
         Matcher matcher = regex.matcher(path);
         if (!matcher.matches()) {
             return Option.none();
         }
-
         var variables = new HashMap<String, String>();
-        for (int i = 0; i < variableNames.size(); i++) {
+        for (int i = 0; i < variableNames.size(); i++ ) {
             variables.put(variableNames.get(i), matcher.group(i + 1));
         }
-
         return Option.some(variables);
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/http/RequestContext.java b/node/src/main/java/org/pragmatica/aether/http/RequestContext.java
index 5d2db8ed..646b95db 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RequestContext.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RequestContext.java
@@ -9,13 +9,12 @@
  * Context for an incoming HTTP request containing all relevant data.
  */
 public record RequestContext(
-        HttpMethod method,
-        String path,
-        Map<String, String> pathVariables,
-        Map<String, List<String>> queryParams,
-        Map<String, String> headers,
-        byte[] body
-) {
+ HttpMethod method,
+ String path,
+ Map<String, String> pathVariables,
+ Map<String, List<String>> queryParams,
+ Map<String, String> headers,
+ byte[] body) {
     public Option<String> queryParam(String name) {
         var values = queryParams.get(name);
         return values != null && !values.isEmpty()
diff --git a/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java b/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
index 7638ed4b..d1255d4e 100644
--- a/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
+++ b/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
@@ -1,5 +1,8 @@
 package org.pragmatica.aether.http;
 
+import org.pragmatica.lang.Cause;
+import org.pragmatica.net.serialization.Serializer;
+
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelFutureListener;
@@ -9,14 +12,11 @@
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.util.CharsetUtil;
-import org.pragmatica.lang.Cause;
-import org.pragmatica.net.serialization.Serializer;
 
 /**
  * Writes HTTP responses to the channel.
  */
 public interface ResponseWriter {
-
     /**
      * Write a successful response with the given body.
      */
@@ -36,7 +36,6 @@ static ResponseWriter responseWriter(Serializer serializer) {
 }
 
 class ResponseWriterImpl implements ResponseWriter {
-
     private static final String CONTENT_TYPE_JSON = "application/json";
 
     private final Serializer serializer;
@@ -50,28 +49,32 @@ public void writeSuccess(ChannelHandlerContext ctx, Object body) {
         ByteBuf content;
         if (body == null) {
             content = Unpooled.EMPTY_BUFFER;
-        } else {
+        }else {
             content = Unpooled.buffer();
             serializer.write(content, body);
         }
-
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
-
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
+        response.headers()
+                .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                        content.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     @Override
     public void writeError(ChannelHandlerContext ctx, HttpResponseStatus status, Cause cause) {
         var errorJson = "{\"error\":\"" + escapeJson(cause.message()) + "\"}";
         var content = Unpooled.copiedBuffer(errorJson, CharsetUtil.UTF_8);
-
         var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, status, content);
-        response.headers().set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
-        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
-
-        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+        response.headers()
+                .set(HttpHeaderNames.CONTENT_TYPE, CONTENT_TYPE_JSON);
+        response.headers()
+                .setInt(HttpHeaderNames.CONTENT_LENGTH,
+                        content.readableBytes());
+        ctx.writeAndFlush(response)
+           .addListener(ChannelFutureListener.CLOSE);
     }
 
     private String escapeJson(String s) {
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
index 9ccb0ab6..7a7bb9a4 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
@@ -19,13 +19,14 @@
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Registry for HTTP routes stored in consensus KV-Store.
  *
@@ -45,7 +46,6 @@
  * </ul>
  */
 public interface RouteRegistry {
-
     @MessageReceiver
     void onValuePut(ValuePut<AetherKey, AetherValue> valuePut);
 
@@ -56,13 +56,11 @@ public interface RouteRegistry {
      * Register a route. Idempotent - succeeds if route already exists with same target.
      * Fails with RouteConflict if route exists with different target.
      */
-    Promise<Unit> register(
-        Artifact artifact,
-        String methodName,
-        String httpMethod,
-        String pathPattern,
-        List<Binding> bindings
-    );
+    Promise<Unit> register(Artifact artifact,
+                           String methodName,
+                           String httpMethod,
+                           String pathPattern,
+                           List<Binding> bindings);
 
     /**
      * Unregister all routes for a given artifact.
@@ -84,33 +82,34 @@ Promise<Unit> register(
      * A registered route with its metadata.
      */
     record RegisteredRoute(
-        RouteKey key,
-        RouteValue value,
-        PathPattern compiledPattern
-    ) {}
+    RouteKey key,
+    RouteValue value,
+    PathPattern compiledPattern) {}
 
     /**
      * Route registration errors.
      */
     sealed interface RouteRegistryError extends Cause {
-        Fn1<Cause, String> ROUTE_CONFLICT_ERROR = Causes.forOneValue(
-            "Route conflict: %s"
-        );
+        Fn1<Cause, String>ROUTE_CONFLICT_ERROR = Causes.forOneValue(
+        "Route conflict: %s");
 
         record RouteConflict(
-            String httpMethod,
-            String pathPattern,
-            RouteValue existing,
-            RouteValue attempted
-        ) implements RouteRegistryError {
+        String httpMethod,
+        String pathPattern,
+        RouteValue existing,
+        RouteValue attempted) implements RouteRegistryError {
             @Override
             public String message() {
                 return String.format(
-                    "Route %s %s already registered to %s:%s, cannot register to %s:%s",
-                    httpMethod, pathPattern,
-                    existing.artifact().asString(), existing.methodName(),
-                    attempted.artifact().asString(), attempted.methodName()
-                );
+                "Route %s %s already registered to %s:%s, cannot register to %s:%s",
+                httpMethod,
+                pathPattern,
+                existing.artifact()
+                        .asString(),
+                existing.methodName(),
+                attempted.artifact()
+                         .asString(),
+                attempted.methodName());
             }
         }
     }
@@ -118,35 +117,31 @@ public String message() {
     /**
      * Create a new route registry.
      */
-    static RouteRegistry routeRegistry(
-        ClusterNode<KVCommand<AetherKey>> cluster,
-        KVStore<AetherKey, AetherValue> kvStore
-    ) {
+    static RouteRegistry routeRegistry(ClusterNode<KVCommand<AetherKey>> cluster,
+                                       KVStore<AetherKey, AetherValue> kvStore) {
         return new RouteRegistryImpl(cluster, kvStore);
     }
 }
 
 class RouteRegistryImpl implements RouteRegistry {
-
     private static final Logger log = LoggerFactory.getLogger(RouteRegistryImpl.class);
 
     private final ClusterNode<KVCommand<AetherKey>> cluster;
     private final KVStore<AetherKey, AetherValue> kvStore;
     private final Map<RouteKey, RegisteredRoute> routes = new ConcurrentHashMap<>();
 
-    RouteRegistryImpl(
-        ClusterNode<KVCommand<AetherKey>> cluster,
-        KVStore<AetherKey, AetherValue> kvStore
-    ) {
+    RouteRegistryImpl(ClusterNode<KVCommand<AetherKey>> cluster,
+                      KVStore<AetherKey, AetherValue> kvStore) {
         this.cluster = cluster;
         this.kvStore = kvStore;
     }
 
     @Override
     public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
-        var key = valuePut.cause().key();
-        var value = valuePut.cause().value();
-
+        var key = valuePut.cause()
+                          .key();
+        var value = valuePut.cause()
+                            .value();
         if (key instanceof RouteKey routeKey && value instanceof RouteValue routeValue) {
             addRoute(routeKey, routeValue);
         }
@@ -154,8 +149,8 @@ public void onValuePut(ValuePut<AetherKey, AetherValue> valuePut) {
 
     @Override
     public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
-        var key = valueRemove.cause().key();
-
+        var key = valueRemove.cause()
+                             .key();
         if (key instanceof RouteKey routeKey) {
             routes.remove(routeKey);
             log.debug("Removed route: {} {}", routeKey.method(), routeKey.pathHash());
@@ -163,114 +158,108 @@ public void onValueRemove(ValueRemove<AetherKey, AetherValue> valueRemove) {
     }
 
     @Override
-    public Promise<Unit> register(
-        Artifact artifact,
-        String methodName,
-        String httpMethod,
-        String pathPattern,
-        List<Binding> bindings
-    ) {
+    public Promise<Unit> register(Artifact artifact,
+                                  String methodName,
+                                  String httpMethod,
+                                  String pathPattern,
+                                  List<Binding> bindings) {
         var routeKey = RouteKey.routeKey(httpMethod, pathPattern);
         var routeValue = new RouteValue(artifact, methodName, httpMethod, pathPattern, bindings);
-
         // Check if route already exists in local cache
         var existing = routes.get(routeKey);
         if (existing != null) {
             return validateExisting(existing.value(), routeValue);
         }
-
         // Check KV-Store directly (in case we missed a notification)
         return kvStore.get(routeKey)
-            .map(value -> (RouteValue) value)
-            .fold(
-                () -> submitRoute(routeKey, routeValue),
-                stored -> validateExisting(stored, routeValue)
-            );
+                      .map(value -> (RouteValue) value)
+                      .fold(() -> submitRoute(routeKey, routeValue),
+                            stored -> validateExisting(stored, routeValue));
     }
 
     private Promise<Unit> validateExisting(RouteValue existing, RouteValue attempted) {
         if (existing.matches(attempted)) {
-            log.debug("Route already registered (idempotent): {} {}",
-                attempted.httpMethod(), attempted.pathPattern());
+            log.debug("Route already registered (idempotent): {} {}", attempted.httpMethod(), attempted.pathPattern());
             return Promise.success(Unit.unit());
         }
-
         // Conflict - same path but different target
         return new RouteRegistryError.RouteConflict(
-            attempted.httpMethod(),
-            attempted.pathPattern(),
-            existing,
-            attempted
-        ).promise();
+        attempted.httpMethod(), attempted.pathPattern(), existing, attempted).promise();
     }
 
     private Promise<Unit> submitRoute(RouteKey key, RouteValue value) {
         log.info("Registering route: {} {} -> {}:{}",
-            value.httpMethod(), value.pathPattern(),
-            value.artifact().asString(), value.methodName());
-
+                 value.httpMethod(),
+                 value.pathPattern(),
+                 value.artifact()
+                      .asString(),
+                 value.methodName());
         var command = new KVCommand.Put<AetherKey, AetherValue>(key, value);
-
         return cluster.apply(List.of(command))
-            .mapToUnit();
+                      .mapToUnit();
     }
 
     @Override
     public Promise<Unit> unregister(Artifact artifact) {
         // Find all routes belonging to this artifact
-        var routesToRemove = routes.values().stream()
-            .filter(r -> r.value().artifact().equals(artifact))
-            .toList();
-
+        var routesToRemove = routes.values()
+                                   .stream()
+                                   .filter(r -> r.value()
+                                                 .artifact()
+                                                 .equals(artifact))
+                                   .toList();
         if (routesToRemove.isEmpty()) {
             return Promise.success(Unit.unit());
         }
-
         log.info("Unregistering {} routes for artifact {}", routesToRemove.size(), artifact.asString());
-
         List<KVCommand<AetherKey>> commands = routesToRemove.stream()
-            .<KVCommand<AetherKey>>map(r -> new KVCommand.Remove<>(r.key()))
-            .toList();
-
+                                                            .<KVCommand<AetherKey>> map(r -> new KVCommand.Remove<>(r.key()))
+                                                            .toList();
         return cluster.apply(commands)
-            .map(_ -> {
-                log.info("Unregistered {} routes for artifact {}", routesToRemove.size(), artifact.asString());
-                return Unit.unit();
-            });
+                      .map(_ -> {
+                               log.info("Unregistered {} routes for artifact {}",
+                                        routesToRemove.size(),
+                                        artifact.asString());
+                               return Unit.unit();
+                           });
     }
 
     private void addRoute(RouteKey key, RouteValue value) {
-        try {
+        try{
             // Create the pattern from "METHOD:path"
             var pattern = PathPattern.compile(value.httpMethod() + ":" + value.pathPattern());
             var registered = new RegisteredRoute(key, value, pattern);
-
             routes.put(key, registered);
             log.debug("Added route: {} {} -> {}:{}",
-                value.httpMethod(), value.pathPattern(),
-                value.artifact().asString(), value.methodName());
+                      value.httpMethod(),
+                      value.pathPattern(),
+                      value.artifact()
+                           .asString(),
+                      value.methodName());
         } catch (Exception e) {
-            log.error("Failed to compile route pattern: {} {}",
-                value.httpMethod(), value.pathPattern(), e);
+            log.error("Failed to compile route pattern: {} {}", value.httpMethod(), value.pathPattern(), e);
         }
     }
 
     @Override
     public Option<MatchResult> match(HttpMethod method, String path) {
         for (var registered : routes.values()) {
-            var matchOpt = registered.compiledPattern().match(method, path);
+            var matchOpt = registered.compiledPattern()
+                                     .match(method, path);
             if (matchOpt.isPresent()) {
                 // Convert RouteValue to Route for MatchResult compatibility
                 var routeValue = registered.value();
                 var route = new Route(
-                    routeValue.httpMethod() + ":" + routeValue.pathPattern(),
-                    new org.pragmatica.aether.slice.routing.RouteTarget(
-                        routeValue.artifact().asString(),
-                        routeValue.methodName(),
-                        routeValue.bindings().stream().map(Binding::param).toList()
-                    ),
-                    routeValue.bindings()
-                );
+                routeValue.httpMethod() + ":" + routeValue.pathPattern(),
+                new org.pragmatica.aether.slice.routing.RouteTarget(
+                routeValue.artifact()
+                          .asString(),
+                routeValue.methodName(),
+                routeValue.bindings()
+                          .stream()
+                          .map(Binding::param)
+                          .toList()),
+                routeValue.bindings());
                 return matchOpt.map(vars -> MatchResult.matchResult(route, vars));
             }
         }
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
index 4858e008..1762ce25 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
@@ -1,15 +1,14 @@
 package org.pragmatica.aether.http;
-
 /**
  * Configuration for the HTTP router.
  */
 public record RouterConfig(
-        int port,
-        int maxContentLength
-) {
+ int port,
+ int maxContentLength) {
     public static final int DEFAULT_PORT = 8081;
-    public static final int DEFAULT_MAX_CONTENT_LENGTH = 1024 * 1024; // 1MB
+    public static final int DEFAULT_MAX_CONTENT_LENGTH = 1024 * 1024;
 
+    // 1MB
     public static RouterConfig defaultConfig() {
         return new RouterConfig(DEFAULT_PORT, DEFAULT_MAX_CONTENT_LENGTH);
     }
diff --git a/node/src/main/java/org/pragmatica/aether/http/SliceDispatcher.java b/node/src/main/java/org/pragmatica/aether/http/SliceDispatcher.java
index e066a040..3918a7bc 100644
--- a/node/src/main/java/org/pragmatica/aether/http/SliceDispatcher.java
+++ b/node/src/main/java/org/pragmatica/aether/http/SliceDispatcher.java
@@ -12,7 +12,6 @@
  * Dispatches HTTP requests to slice methods.
  */
 public interface SliceDispatcher {
-
     /**
      * Dispatch a request to a slice method.
      *
@@ -39,7 +38,6 @@ interface ArtifactResolver {
 }
 
 class SliceDispatcherImpl implements SliceDispatcher {
-
     private final SliceInvoker invoker;
     private final SliceDispatcher.ArtifactResolver artifactResolver;
 
@@ -53,33 +51,36 @@ public Promise<Object> dispatch(Route route, Map<String, Object> resolvedParams)
         var target = route.target();
         var sliceId = target.sliceId();
         var methodName = target.methodName();
-
         var artifact = artifactResolver.resolve(sliceId);
         if (artifact == null) {
             return new HttpRouterError.SliceNotFound(sliceId).promise();
         }
-
         // Build request object from resolved params
         // For simplicity, if there's a single param (body), use it directly
         // Otherwise, we'd need to construct a request object
         Object request;
         if (resolvedParams.size() == 1) {
-            request = resolvedParams.values().iterator().next();
-        } else {
+            request = resolvedParams.values()
+                                    .iterator()
+                                    .next();
+        }else {
             // Empty or multiple params - use the map (empty map is safer than null)
             request = resolvedParams;
         }
-
         var finalRequest = request;
         return MethodName.methodName(methodName)
-                .async()
-                .flatMap(method -> {
-                    Promise<Object> invokePromise = invoker.invokeLocal(artifact, method, finalRequest, Object.class);
-                    return Promise.promise(promise -> {
-                        invokePromise
-                                .onSuccess(promise::succeed)
-                                .onFailure(cause -> promise.fail(new HttpRouterError.InvocationFailed(sliceId, methodName, cause)));
-                    });
-                });
+                         .async()
+                         .flatMap(method -> {
+                                      Promise<Object> invokePromise = invoker.invokeLocal(artifact,
+                                                                                          method,
+                                                                                          finalRequest,
+                                                                                          Object.class);
+                                      return Promise.promise(promise -> {
+                                                                 invokePromise.onSuccess(promise::succeed)
+                                                                              .onFailure(cause -> promise.fail(new HttpRouterError.InvocationFailed(sliceId,
+                                                                                                                                                    methodName,
+                                                                                                                                                    cause)));
+                                                             });
+                                  });
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
index 08358ae0..7117e6a1 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
@@ -9,13 +9,14 @@
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.lang.Option;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.nio.charset.StandardCharsets;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Server-side component that handles incoming slice invocation requests.
  *
@@ -24,7 +25,6 @@
  * the response back.
  */
 public interface InvocationHandler {
-
     /**
      * Handle incoming invocation request.
      */
@@ -70,14 +70,14 @@ static InvocationHandler invocationHandler(NodeId self, ClusterNetwork network)
      *
      * @param metricsCollector The metrics collector to use
      */
-    static InvocationHandler invocationHandler(NodeId self, ClusterNetwork network,
-                                                InvocationMetricsCollector metricsCollector) {
+    static InvocationHandler invocationHandler(NodeId self,
+                                               ClusterNetwork network,
+                                               InvocationMetricsCollector metricsCollector) {
         return new InvocationHandlerImpl(self, network, Option.option(metricsCollector));
     }
 }
 
 class InvocationHandlerImpl implements InvocationHandler {
-
     private static final Logger log = LoggerFactory.getLogger(InvocationHandlerImpl.class);
 
     private final NodeId self;
@@ -118,10 +118,10 @@ public Option<InvocationMetricsCollector> metricsCollector() {
     @Override
     public void onInvokeRequest(InvokeRequest request) {
         log.debug("Received invocation request [{}]: {}.{}",
-                  request.correlationId(), request.targetSlice(), request.method());
-
+                  request.correlationId(),
+                  request.targetSlice(),
+                  request.method());
         var bridge = localSlices.get(request.targetSlice());
-
         if (bridge == null) {
             log.warn("Slice not found for invocation: {}", request.targetSlice());
             if (request.expectResponse()) {
@@ -129,7 +129,6 @@ public void onInvokeRequest(InvokeRequest request) {
             }
             return;
         }
-
         // Invoke the slice method
         invokeSliceMethod(request, bridge);
     }
@@ -137,55 +136,52 @@ public void onInvokeRequest(InvokeRequest request) {
     private void invokeSliceMethod(InvokeRequest request, SliceBridge bridge) {
         var startTime = System.nanoTime();
         var requestBytes = request.payload().length;
-
         // SliceBridge uses byte[] directly - no ByteBuf conversion needed
-        bridge.invoke(request.method().name(), request.payload())
+        bridge.invoke(request.method()
+                             .name(),
+                      request.payload())
               .onSuccess(responseData -> {
-                  var durationNs = System.nanoTime() - startTime;
-                  var responseBytes = responseData.length;
-
-                  if (request.expectResponse()) {
-                      sendSuccessResponse(request, responseData);
-                  }
-
-                  // Record success metrics
-                  metricsCollector.onPresent(mc ->
-                      mc.recordSuccess(request.targetSlice(), request.method(),
-                                       durationNs, requestBytes, responseBytes));
-              })
+                             var durationNs = System.nanoTime() - startTime;
+                             var responseBytes = responseData.length;
+                             if (request.expectResponse()) {
+                             sendSuccessResponse(request, responseData);
+                         }
+                             // Record success metrics
+        metricsCollector.onPresent(mc -> mc.recordSuccess(request.targetSlice(),
+                                                          request.method(),
+                                                          durationNs,
+                                                          requestBytes,
+                                                          responseBytes));
+                         })
               .onFailure(cause -> {
-                  var durationNs = System.nanoTime() - startTime;
-                  log.error("Invocation failed [{}]: {}",
-                            request.correlationId(), cause.message());
-                  if (request.expectResponse()) {
-                      sendErrorResponse(request, cause.message());
-                  }
-
-                  // Record failure metrics
-                  metricsCollector.onPresent(mc ->
-                      mc.recordFailure(request.targetSlice(), request.method(),
-                                       durationNs, requestBytes, cause.getClass().getSimpleName()));
-              });
+                             var durationNs = System.nanoTime() - startTime;
+                             log.error("Invocation failed [{}]: {}",
+                                       request.correlationId(),
+                                       cause.message());
+                             if (request.expectResponse()) {
+                             sendErrorResponse(request,
+                                               cause.message());
+                         }
+                             // Record failure metrics
+        metricsCollector.onPresent(mc -> mc.recordFailure(request.targetSlice(),
+                                                          request.method(),
+                                                          durationNs,
+                                                          requestBytes,
+                                                          cause.getClass()
+                                                               .getSimpleName()));
+                         });
     }
 
     private void sendSuccessResponse(InvokeRequest request, byte[] payload) {
         var response = new InvokeResponse(
-                self,
-                request.correlationId(),
-                true,
-                payload
-        );
+        self, request.correlationId(), true, payload);
         network.send(request.sender(), response);
         log.debug("Sent success response [{}]", request.correlationId());
     }
 
     private void sendErrorResponse(InvokeRequest request, String errorMessage) {
         var response = new InvokeResponse(
-                self,
-                request.correlationId(),
-                false,
-                errorMessage.getBytes(StandardCharsets.UTF_8)
-        );
+        self, request.correlationId(), false, errorMessage.getBytes(StandardCharsets.UTF_8));
         network.send(request.sender(), response);
         log.debug("Sent error response [{}]: {}", request.correlationId(), errorMessage);
     }
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java b/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
index 67513486..403ab24f 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
@@ -15,7 +15,6 @@
  * </ul>
  */
 public sealed interface InvocationMessage extends ProtocolMessage {
-
     /**
      * Request to invoke a method on a remote slice.
      *
@@ -27,13 +26,12 @@ public sealed interface InvocationMessage extends ProtocolMessage {
      * @param expectResponse Whether caller expects a response
      */
     record InvokeRequest(
-            NodeId sender,
-            String correlationId,
-            Artifact targetSlice,
-            MethodName method,
-            byte[] payload,
-            boolean expectResponse
-    ) implements InvocationMessage {}
+    NodeId sender,
+    String correlationId,
+    Artifact targetSlice,
+    MethodName method,
+    byte[] payload,
+    boolean expectResponse) implements InvocationMessage {}
 
     /**
      * Response from a remote slice invocation.
@@ -44,9 +42,8 @@ record InvokeRequest(
      * @param payload       Serialized response (if success) or error message (if failure)
      */
     record InvokeResponse(
-            NodeId sender,
-            String correlationId,
-            boolean success,
-            byte[] payload
-    ) implements InvocationMessage {}
+    NodeId sender,
+    String correlationId,
+    boolean success,
+    byte[] payload) implements InvocationMessage {}
 }
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
index 5fefd4b9..f143d677 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
@@ -1,6 +1,5 @@
 package org.pragmatica.aether.invoke;
 
-import io.netty.buffer.Unpooled;
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.endpoint.EndpointRegistry;
 import org.pragmatica.aether.endpoint.EndpointRegistry.Endpoint;
@@ -20,14 +19,16 @@
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 import org.pragmatica.utility.ULID;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 
+import io.netty.buffer.Unpooled;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.lang.Unit.unit;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
@@ -44,20 +45,23 @@
  * and routes the invocation via the ClusterNetwork.
  */
 public interface SliceInvoker extends SliceInvokerFacade {
-
     /**
      * Implementation of SliceInvokerFacade for use by slices via SliceRuntime.
      * Parses string artifact/method and delegates to typed methods.
      */
     @Override
-    default <R> Promise<R> invokeAndWait(String sliceArtifact, String methodName, Object request, Class<R> responseType) {
+    default <R> Promise<R> invokeAndWait(String sliceArtifact,
+                                         String methodName,
+                                         Object request,
+                                         Class<R> responseType) {
         return Artifact.artifact(sliceArtifact)
-                .flatMap(artifact -> MethodName.methodName(methodName)
-                        .map(method -> new ArtifactMethod(artifact, method)))
-                .fold(
-                        cause -> cause.promise(),
-                        am -> invokeAndWait(am.artifact(), am.method(), request, responseType)
-                );
+                       .flatMap(artifact -> MethodName.methodName(methodName)
+                                                      .map(method -> new ArtifactMethod(artifact, method)))
+                       .fold(cause -> cause.promise(),
+                             am -> invokeAndWait(am.artifact(),
+                                                 am.method(),
+                                                 request,
+                                                 responseType));
     }
 
     record ArtifactMethod(Artifact artifact, MethodName method) {}
@@ -96,7 +100,11 @@ record ArtifactMethod(Artifact artifact, MethodName method) {}
      * @param <R>          Response type
      * @return Promise resolving to response
      */
-    <R> Promise<R> invokeWithRetry(Artifact slice, MethodName method, Object request, Class<R> responseType, int maxRetries);
+    <R> Promise<R> invokeWithRetry(Artifact slice,
+                                   MethodName method,
+                                   Object request,
+                                   Class<R> responseType,
+                                   int maxRetries);
 
     /**
      * Local invocation - invokes a slice on the local node without network round-trip.
@@ -151,38 +159,48 @@ record ArtifactMethod(Artifact artifact, MethodName method) {}
      * Create a new SliceInvoker.
      */
     static SliceInvoker sliceInvoker(NodeId self,
-                                      ClusterNetwork network,
-                                      EndpointRegistry endpointRegistry,
-                                      InvocationHandler invocationHandler,
-                                      Serializer serializer,
-                                      Deserializer deserializer) {
-        return new SliceInvokerImpl(self, network, endpointRegistry, invocationHandler,
-                                    serializer, deserializer, DEFAULT_TIMEOUT_MS);
+                                     ClusterNetwork network,
+                                     EndpointRegistry endpointRegistry,
+                                     InvocationHandler invocationHandler,
+                                     Serializer serializer,
+                                     Deserializer deserializer) {
+        return new SliceInvokerImpl(self,
+                                    network,
+                                    endpointRegistry,
+                                    invocationHandler,
+                                    serializer,
+                                    deserializer,
+                                    DEFAULT_TIMEOUT_MS);
     }
 
     /**
      * Create with custom timeout.
      */
     static SliceInvoker sliceInvoker(NodeId self,
-                                      ClusterNetwork network,
-                                      EndpointRegistry endpointRegistry,
-                                      InvocationHandler invocationHandler,
-                                      Serializer serializer,
-                                      Deserializer deserializer,
-                                      long timeoutMs) {
-        return new SliceInvokerImpl(self, network, endpointRegistry, invocationHandler,
-                                    serializer, deserializer, timeoutMs);
+                                     ClusterNetwork network,
+                                     EndpointRegistry endpointRegistry,
+                                     InvocationHandler invocationHandler,
+                                     Serializer serializer,
+                                     Deserializer deserializer,
+                                     long timeoutMs) {
+        return new SliceInvokerImpl(self,
+                                    network,
+                                    endpointRegistry,
+                                    invocationHandler,
+                                    serializer,
+                                    deserializer,
+                                    timeoutMs);
     }
 }
 
 class SliceInvokerImpl implements SliceInvoker {
-
     private static final Logger log = LoggerFactory.getLogger(SliceInvokerImpl.class);
     private static final Cause NO_ENDPOINT_FOUND = Causes.cause("No endpoint found for slice/method");
     private static final Cause SLICE_NOT_FOUND = Causes.cause("Slice not found locally");
     private static final Cause INVOKER_STOPPED = Causes.cause("SliceInvoker has been stopped");
-    private static final long CLEANUP_INTERVAL_MS = 60_000; // Clean up stale entries every minute
+    private static final long CLEANUP_INTERVAL_MS = 60_000;
 
+    // Clean up stale entries every minute
     private final NodeId self;
     private final ClusterNetwork network;
     private final EndpointRegistry endpointRegistry;
@@ -215,29 +233,33 @@ record PendingInvocation(Promise<Object> promise, long createdAtMs) {}
         this.deserializer = deserializer;
         this.timeoutMs = timeoutMs;
         this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-            var t = new Thread(r, "slice-invoker-scheduler");
-            t.setDaemon(true);
-            return t;
-        });
-
+                                                                        var t = new Thread(r, "slice-invoker-scheduler");
+                                                                        t.setDaemon(true);
+                                                                        return t;
+                                                                    });
         // Schedule periodic cleanup of stale pending invocations
         scheduler.scheduleAtFixedRate(this::cleanupStaleInvocations,
-                                      CLEANUP_INTERVAL_MS, CLEANUP_INTERVAL_MS, TimeUnit.MILLISECONDS);
+                                      CLEANUP_INTERVAL_MS,
+                                      CLEANUP_INTERVAL_MS,
+                                      TimeUnit.MILLISECONDS);
     }
 
     private void cleanupStaleInvocations() {
         var now = System.currentTimeMillis();
-        var staleThreshold = now - (timeoutMs * 2); // 2x timeout to be safe
-
-        pendingInvocations.entrySet().removeIf(entry -> {
-            var pending = entry.getValue();
-            if (pending.createdAtMs() < staleThreshold) {
-                log.warn("Cleaning up stale pending invocation: {}", entry.getKey());
-                pending.promise().resolve(Result.failure(Causes.cause("Invocation timed out (cleanup)")));
-                return true;
-            }
-            return false;
-        });
+        var staleThreshold = now - (timeoutMs * 2);
+        // 2x timeout to be safe
+        pendingInvocations.entrySet()
+                          .removeIf(entry -> {
+                                        var pending = entry.getValue();
+                                        if (pending.createdAtMs() < staleThreshold) {
+                                        log.warn("Cleaning up stale pending invocation: {}",
+                                                 entry.getKey());
+                                        pending.promise()
+                                               .resolve(Result.failure(Causes.cause("Invocation timed out (cleanup)")));
+                                        return true;
+                                    }
+                                        return false;
+                                    });
     }
 
     @Override
@@ -246,26 +268,24 @@ public Promise<Unit> stop() {
             return Promise.success(unit());
         }
         stopped = true;
-
         log.info("Stopping SliceInvoker with {} pending invocations", pendingInvocations.size());
-
         // Cancel all pending invocations
         pendingInvocations.forEach((id, pending) -> {
-            pending.promise().resolve(Result.failure(INVOKER_STOPPED));
+            pending.promise()
+                   .resolve(Result.failure(INVOKER_STOPPED));
         });
         pendingInvocations.clear();
-
         // Shutdown scheduler
         scheduler.shutdown();
-        try {
+        try{
             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                 scheduler.shutdownNow();
             }
         } catch (InterruptedException e) {
             scheduler.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
-
         log.info("SliceInvoker stopped");
         return Promise.success(unit());
     }
@@ -278,20 +298,20 @@ public int pendingCount() {
     @Override
     public Promise<Unit> invoke(Artifact slice, MethodName method, Object request) {
         return selectEndpoint(slice, method)
-                .flatMap(endpoint -> {
-                    var payload = serializeRequest(request);
-                    var correlationId = ULID.randomULID().toString();
-
-                    var invokeRequest = new InvokeRequest(
-                            self, correlationId, slice, method, payload, false
-                    );
-
-                    network.send(endpoint.nodeId(), invokeRequest);
-                    log.debug("Sent fire-and-forget invocation to {}: {}.{}",
-                              endpoint.nodeId(), slice, method);
-
-                    return Promise.success(unit());
-                });
+               .flatMap(endpoint -> {
+                            var payload = serializeRequest(request);
+                            var correlationId = ULID.randomULID()
+                                                    .toString();
+                            var invokeRequest = new InvokeRequest(
+        self, correlationId, slice, method, payload, false);
+                            network.send(endpoint.nodeId(),
+                                         invokeRequest);
+                            log.debug("Sent fire-and-forget invocation to {}: {}.{}",
+                                      endpoint.nodeId(),
+                                      slice,
+                                      method);
+                            return Promise.success(unit());
+                        });
     }
 
     @Override
@@ -300,119 +320,134 @@ public <R> Promise<R> invokeAndWait(Artifact slice, MethodName method, Object re
         if (stopped) {
             return INVOKER_STOPPED.promise();
         }
-
         return selectEndpoint(slice, method)
-                .flatMap(endpoint -> {
-                    var payload = serializeRequest(request);
-                    var correlationId = ULID.randomULID().toString();
-
-                    // Create pending promise using callback pattern
-                    return Promise.<R>promise(pendingPromise -> {
-                        // Store with timestamp for cleanup
-                        var pending = new PendingInvocation(
-                                (Promise<Object>) (Promise<?>) pendingPromise,
-                                System.currentTimeMillis()
-                        );
-                        pendingInvocations.put(correlationId, pending);
-
-                        // Set timeout to clean up if no response
-                        pendingPromise.timeout(timeSpan(timeoutMs).millis())
-                                      .onResult(_ -> pendingInvocations.remove(correlationId));
-
-                        // Send request
-                        var invokeRequest = new InvokeRequest(
-                                self, correlationId, slice, method, payload, true
-                        );
-                        network.send(endpoint.nodeId(), invokeRequest);
-
-                        log.debug("Sent request-response invocation to {}: {}.{} [{}]",
-                                  endpoint.nodeId(), slice, method, correlationId);
-                    });
-                });
+               .flatMap(endpoint -> {
+                            var payload = serializeRequest(request);
+                            var correlationId = ULID.randomULID()
+                                                    .toString();
+                            // Create pending promise using callback pattern
+        return Promise.<R>promise(pendingPromise -> {
+                                      // Store with timestamp for cleanup
+        var pending = new PendingInvocation(
+        (Promise<Object>)(Promise< ? >) pendingPromise,
+        System.currentTimeMillis());
+                                      pendingInvocations.put(correlationId, pending);
+                                      // Set timeout to clean up if no response
+        pendingPromise.timeout(timeSpan(timeoutMs)
+                               .millis())
+                      .onResult(_ -> pendingInvocations.remove(correlationId));
+                                      // Send request
+        var invokeRequest = new InvokeRequest(
+        self, correlationId, slice, method, payload, true);
+                                      network.send(endpoint.nodeId(),
+                                                   invokeRequest);
+                                      log.debug("Sent request-response invocation to {}: {}.{} [{}]",
+                                                endpoint.nodeId(),
+                                                slice,
+                                                method,
+                                                correlationId);
+                                  });
+                        });
     }
 
     @Override
-    public <R> Promise<R> invokeWithRetry(Artifact slice, MethodName method, Object request, Class<R> responseType, int maxRetries) {
+    public <R> Promise<R> invokeWithRetry(Artifact slice,
+                                          MethodName method,
+                                          Object request,
+                                          Class<R> responseType,
+                                          int maxRetries) {
         return invokeWithRetryInternal(slice, method, request, responseType, 0, maxRetries);
     }
 
-    private <R> Promise<R> invokeWithRetryInternal(Artifact slice, MethodName method, Object request,
-                                                    Class<R> responseType, int attempt, int maxRetries) {
+    private <R> Promise<R> invokeWithRetryInternal(Artifact slice,
+                                                   MethodName method,
+                                                   Object request,
+                                                   Class<R> responseType,
+                                                   int attempt,
+                                                   int maxRetries) {
         if (stopped) {
             return INVOKER_STOPPED.promise();
         }
-
         return Promise.promise(promise -> {
-            invokeAndWait(slice, method, request, responseType)
-                    .onSuccess(promise::succeed)
-                    .onFailure(cause -> {
-                        if (stopped) {
-                            promise.fail(INVOKER_STOPPED);
-                            return;
-                        }
-                        if (attempt < maxRetries) {
-                            var nextAttempt = attempt + 1;
-                            var delayMs = BASE_RETRY_DELAY_MS * (1L << attempt); // Exponential backoff: 100, 200, 400, 800...
-
-                            log.debug("Invocation failed, scheduling retry {}/{} in {}ms: {}.{} - {}",
-                                      nextAttempt, maxRetries, delayMs, slice, method, cause.message());
-
-                            scheduler.schedule(() -> {
-                                invokeWithRetryInternal(slice, method, request, responseType, nextAttempt, maxRetries)
-                                        .onSuccess(promise::succeed)
-                                        .onFailure(promise::fail);
-                            }, delayMs, TimeUnit.MILLISECONDS);
-                        } else {
-                            log.warn("Invocation failed after {} retries: {}.{} - {}",
-                                     maxRetries, slice, method, cause.message());
-                            promise.fail(cause);
-                        }
-                    });
-        });
+                                   invokeAndWait(slice, method, request, responseType)
+                                   .onSuccess(promise::succeed)
+                                   .onFailure(cause -> {
+                                                  if (stopped) {
+                                                  promise.fail(INVOKER_STOPPED);
+                                                  return;
+                                              }
+                                                  if (attempt < maxRetries) {
+                                                  var nextAttempt = attempt + 1;
+                                                  var delayMs = BASE_RETRY_DELAY_MS * (1L<< attempt);
+                                                  // Exponential backoff: 100, 200, 400, 800...
+        log.debug("Invocation failed, scheduling retry {}/{} in {}ms: {}.{} - {}",
+                  nextAttempt,
+                  maxRetries,
+                  delayMs,
+                  slice,
+                  method,
+                  cause.message());
+                                                  scheduler.schedule(() -> {
+                                                                         invokeWithRetryInternal(slice,
+                                                                                                 method,
+                                                                                                 request,
+                                                                                                 responseType,
+                                                                                                 nextAttempt,
+                                                                                                 maxRetries)
+                                                                         .onSuccess(promise::succeed)
+                                                                         .onFailure(promise::fail);
+                                                                     },
+                                                                     delayMs,
+                                                                     TimeUnit.MILLISECONDS);
+                                              }else {
+                                                  log.warn("Invocation failed after {} retries: {}.{} - {}",
+                                                           maxRetries,
+                                                           slice,
+                                                           method,
+                                                           cause.message());
+                                                  promise.fail(cause);
+                                              }
+                                              });
+                               });
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public <R> Promise<R> invokeLocal(Artifact slice, MethodName method, Object request, Class<R> responseType) {
         return invocationHandler.getLocalSlice(slice)
-                .fold(
-                        () -> SLICE_NOT_FOUND.<R>promise(),
-                        bridge -> {
-                            // Encode request to byte array
-                            var inputBytes = serializer.encode(request);
-
-                            // Invoke via SliceBridge using byte[] interface
-                            return bridge.invoke(method.name(), inputBytes)
-                                    .map(outputBytes -> (R) deserializer.decode(outputBytes));
-                        }
-                );
+                                .fold(() -> SLICE_NOT_FOUND.<R>promise(),
+                                      bridge -> {
+                                          // Encode request to byte array
+        var inputBytes = serializer.encode(request);
+                                          // Invoke via SliceBridge using byte[] interface
+        return bridge.invoke(method.name(),
+                             inputBytes)
+                     .map(outputBytes -> (R) deserializer.decode(outputBytes));
+                                      });
     }
 
     @Override
     @SuppressWarnings("unchecked")
     public void onInvokeResponse(InvokeResponse response) {
         var pending = pendingInvocations.remove(response.correlationId());
-
         if (pending == null) {
             log.warn("Received response for unknown correlationId: {}", response.correlationId());
             return;
         }
-
         var promise = pending.promise();
-
         if (response.success()) {
-            try {
+            try{
                 var buf = Unpooled.wrappedBuffer(response.payload());
                 var result = deserializer.read(buf);
-                buf.release(); // Release the wrapped buffer
+                buf.release();
+                // Release the wrapped buffer
                 promise.resolve(Result.success(result));
                 log.debug("Completed invocation [{}]", response.correlationId());
             } catch (Exception e) {
                 promise.resolve(Result.failure(Causes.fromThrowable(e)));
-                log.error("Failed to deserialize response [{}]: {}",
-                          response.correlationId(), e.getMessage());
+                log.error("Failed to deserialize response [{}]: {}", response.correlationId(), e.getMessage());
             }
-        } else {
+        }else {
             var errorMessage = new String(response.payload());
             promise.resolve(Result.failure(new InvocationError(errorMessage)));
             log.debug("Invocation failed [{}]: {}", response.correlationId(), errorMessage);
@@ -421,10 +456,8 @@ public void onInvokeResponse(InvokeResponse response) {
 
     private Promise<Endpoint> selectEndpoint(Artifact slice, MethodName method) {
         return endpointRegistry.selectEndpoint(slice, method)
-                               .fold(
-                                       () -> NO_ENDPOINT_FOUND.promise(),
-                                       Promise::success
-                               );
+                               .fold(() -> NO_ENDPOINT_FOUND.promise(),
+                                     Promise::success);
     }
 
     private byte[] serializeRequest(Object request) {
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
index dae9d6f4..ac278c1f 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
@@ -31,7 +31,6 @@
  * <p>Metrics are stored in-memory with a sliding window for historical data.
  */
 public interface MetricsCollector {
-
     // Standard metric names
     String CPU_USAGE = "cpu.usage";
     String HEAP_USED = "heap.used";
@@ -93,7 +92,6 @@ static MetricsCollector metricsCollector(NodeId self, ClusterNetwork network) {
  * Implementation of MetricsCollector.
  */
 class MetricsCollectorImpl implements MetricsCollector {
-
     // Sliding window duration: 2 hours in milliseconds
     private static final long SLIDING_WINDOW_MS = 2 * 60 * 60 * 1000L;
 
@@ -126,41 +124,39 @@ class MetricsCollectorImpl implements MetricsCollector {
     @Override
     public Map<String, Double> collectLocal() {
         var metrics = new ConcurrentHashMap<String, Double>();
-
         // CPU usage (system load average normalized by processors)
         double systemLoad = osMxBean.getSystemLoadAverage();
         if (systemLoad >= 0) {
             int processors = osMxBean.getAvailableProcessors();
             metrics.put(CPU_USAGE, Math.min(1.0, systemLoad / processors));
         }
-
         // Heap memory
         var heapUsage = memoryMxBean.getHeapMemoryUsage();
         metrics.put(HEAP_USED, (double) heapUsage.getUsed());
         metrics.put(HEAP_MAX, (double) heapUsage.getMax());
         if (heapUsage.getMax() > 0) {
-            metrics.put(HEAP_USAGE, (double) heapUsage.getUsed() / heapUsage.getMax());
+            metrics.put(HEAP_USAGE,
+                        (double) heapUsage.getUsed() / heapUsage.getMax());
         }
-
         // Add call stats
         callStats.forEach((method, stats) -> {
-            var prefix = "method." + method.name() + ".";
-            metrics.put(prefix + "calls", (double) stats.count.sum());
-            metrics.put(prefix + "duration.total", stats.totalDuration.sum());
-            if (stats.count.sum() > 0) {
-                metrics.put(prefix + "duration.avg", stats.totalDuration.sum() / stats.count.sum());
-            }
-        });
-
+                              var prefix = "method." + method.name() + ".";
+                              metrics.put(prefix + "calls", (double) stats.count.sum());
+                              metrics.put(prefix + "duration.total", stats.totalDuration.sum());
+                              if (stats.count.sum() > 0) {
+                              metrics.put(prefix + "duration.avg",
+                                          stats.totalDuration.sum() / stats.count.sum());
+                          }
+                          });
         // Add custom metrics
         metrics.putAll(customMetrics);
-
         return metrics;
     }
 
     @Override
     public void recordCall(MethodName method, long durationMs) {
-        callStats.computeIfAbsent(method, _ -> new CallStats())
+        callStats.computeIfAbsent(method,
+                                  _ -> new CallStats())
                  .record(durationMs);
     }
 
@@ -188,28 +184,26 @@ public Map<String, Double> metricsFor(NodeId nodeId) {
     public Map<NodeId, java.util.List<MetricsSnapshot>> historicalMetrics() {
         var cutoff = System.currentTimeMillis() - SLIDING_WINDOW_MS;
         var result = new ConcurrentHashMap<NodeId, java.util.List<MetricsSnapshot>>();
-
         historicalMetricsMap.forEach((nodeId, snapshots) -> {
-            // Filter to only include snapshots within the window
-            var filtered = snapshots.stream()
-                    .filter(s -> s.timestamp() >= cutoff)
-                    .toList();
-            if (!filtered.isEmpty()) {
-                result.put(nodeId, filtered);
-            }
-        });
-
+                                         // Filter to only include snapshots within the window
+        var filtered = snapshots.stream()
+                                .filter(s -> s.timestamp() >= cutoff)
+                                .toList();
+                                         if (!filtered.isEmpty()) {
+                                         result.put(nodeId, filtered);
+                                     }
+                                     });
         return result;
     }
 
     @Override
     public void onMetricsPing(MetricsPing ping) {
         // Store sender's metrics (but don't overwrite our own)
-        if (!ping.sender().equals(self)) {
+        if (!ping.sender()
+                 .equals(self)) {
             remoteMetrics.put(ping.sender(), ping.metrics());
             addToHistory(ping.sender(), ping.metrics());
         }
-
         // Respond with our metrics
         network.send(ping.sender(), new MetricsPong(self, collectLocal()));
     }
@@ -217,7 +211,8 @@ public void onMetricsPing(MetricsPing ping) {
     @Override
     public void onMetricsPong(MetricsPong pong) {
         // Store responder's metrics (but don't overwrite our own)
-        if (!pong.sender().equals(self)) {
+        if (!pong.sender()
+                 .equals(self)) {
             remoteMetrics.put(pong.sender(), pong.metrics());
             addToHistory(pong.sender(), pong.metrics());
         }
@@ -228,13 +223,9 @@ public void onMetricsPong(MetricsPong pong) {
      */
     private void addToHistory(NodeId nodeId, Map<String, Double> metrics) {
         var snapshots = historicalMetricsMap.computeIfAbsent(
-                nodeId,
-                _ -> new java.util.concurrent.CopyOnWriteArrayList<>()
-        );
-
+        nodeId, _ -> new java.util.concurrent.CopyOnWriteArrayList<>());
         var now = System.currentTimeMillis();
         snapshots.add(new MetricsSnapshot(now, metrics));
-
         // Cleanup old entries outside the sliding window
         var cutoff = now - SLIDING_WINDOW_MS;
         snapshots.removeIf(s -> s.timestamp() < cutoff);
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
index d8ff1194..35f482e3 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
@@ -8,13 +8,14 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Scheduler for metrics collection that runs on the leader node.
  *
@@ -22,7 +23,6 @@
  * Each node responds with MetricsPong containing their metrics.
  */
 public interface MetricsScheduler {
-
     @MessageReceiver
     void onLeaderChange(LeaderChange leaderChange);
 
@@ -43,9 +43,9 @@ public interface MetricsScheduler {
      * @param intervalMs       Ping interval in milliseconds
      */
     static MetricsScheduler metricsScheduler(NodeId self,
-                                              ClusterNetwork network,
-                                              MetricsCollector metricsCollector,
-                                              long intervalMs) {
+                                             ClusterNetwork network,
+                                             MetricsCollector metricsCollector,
+                                             long intervalMs) {
         return new MetricsSchedulerImpl(self, network, metricsCollector, intervalMs);
     }
 
@@ -53,14 +53,13 @@ static MetricsScheduler metricsScheduler(NodeId self,
      * Create with default 1-second interval.
      */
     static MetricsScheduler metricsScheduler(NodeId self,
-                                              ClusterNetwork network,
-                                              MetricsCollector metricsCollector) {
+                                             ClusterNetwork network,
+                                             MetricsCollector metricsCollector) {
         return metricsScheduler(self, network, metricsCollector, 1000);
     }
 }
 
 class MetricsSchedulerImpl implements MetricsScheduler {
-
     private static final Logger log = LoggerFactory.getLogger(MetricsSchedulerImpl.class);
 
     private final NodeId self;
@@ -69,18 +68,19 @@ class MetricsSchedulerImpl implements MetricsScheduler {
     private final long intervalMs;
 
     private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-        var thread = new Thread(r, "metrics-scheduler");
-        thread.setDaemon(true);
-        return thread;
-    });
+                                                                                                      var thread = new Thread(r,
+                                                                                                                              "metrics-scheduler");
+                                                                                                      thread.setDaemon(true);
+                                                                                                      return thread;
+                                                                                                  });
 
-    private final AtomicReference<ScheduledFuture<?>> pingTask = new AtomicReference<>();
+    private final AtomicReference<ScheduledFuture< ? >> pingTask = new AtomicReference<>();
     private final AtomicReference<List<NodeId>> topology = new AtomicReference<>(List.of());
 
     MetricsSchedulerImpl(NodeId self,
-                          ClusterNetwork network,
-                          MetricsCollector metricsCollector,
-                          long intervalMs) {
+                         ClusterNetwork network,
+                         MetricsCollector metricsCollector,
+                         long intervalMs) {
         this.self = self;
         this.network = network;
         this.metricsCollector = metricsCollector;
@@ -92,7 +92,7 @@ public void onLeaderChange(LeaderChange leaderChange) {
         if (leaderChange.localNodeIsLeader()) {
             log.info("Node {} became leader, starting metrics scheduler", self);
             startPinging();
-        } else {
+        }else {
             log.info("Node {} is no longer leader, stopping metrics scheduler", self);
             stopPinging();
         }
@@ -111,23 +111,22 @@ public void onTopologyChange(TopologyChangeNotification topologyChange) {
     public void stop() {
         stopPinging();
         scheduler.shutdown();
-        try {
+        try{
             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                 scheduler.shutdownNow();
             }
         } catch (InterruptedException e) {
             scheduler.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
     private void startPinging() {
-        stopPinging(); // Cancel any existing task
-
+        stopPinging();
+        // Cancel any existing task
         var task = scheduler.scheduleAtFixedRate(
-                this::sendPingsToAllNodes,
-                0, intervalMs, TimeUnit.MILLISECONDS
-        );
+        this::sendPingsToAllNodes, 0, intervalMs, TimeUnit.MILLISECONDS);
         pingTask.set(task);
     }
 
@@ -139,21 +138,18 @@ private void stopPinging() {
     }
 
     private void sendPingsToAllNodes() {
-        try {
+        try{
             var currentTopology = topology.get();
             if (currentTopology.isEmpty()) {
                 return;
             }
-
             var localMetrics = metricsCollector.collectLocal();
             var ping = new MetricsPing(self, localMetrics);
-
             for (var nodeId : currentTopology) {
                 if (!nodeId.equals(self)) {
                     network.send(nodeId, ping);
                 }
             }
-
             log.trace("Sent MetricsPing to {} nodes", currentTopology.size() - 1);
         } catch (Exception e) {
             log.warn("Failed to send metrics ping: {}", e.getMessage());
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
index 77d83708..945451da 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
@@ -10,7 +10,6 @@
  * These events are dispatched locally via MessageRouter.
  */
 public sealed interface DeploymentEvent extends Message.Local {
-
     /**
      * Emitted when a deployment is initiated (blueprint change triggers LOAD command).
      */
@@ -20,12 +19,11 @@ record DeploymentStarted(Artifact artifact, NodeId targetNode, long timestamp) i
      * Emitted on each state transition during deployment.
      */
     record StateTransition(
-        Artifact artifact,
-        NodeId nodeId,
-        SliceState from,
-        SliceState to,
-        long timestamp
-    ) implements DeploymentEvent {}
+    Artifact artifact,
+    NodeId nodeId,
+    SliceState from,
+    SliceState to,
+    long timestamp) implements DeploymentEvent {}
 
     /**
      * Emitted when deployment completes (reaches ACTIVE state).
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
index a5cdb4c4..7a06830c 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
@@ -12,28 +12,30 @@
  * Tracks timestamps for each state transition to calculate latencies.
  */
 public record DeploymentMetrics(
-    Artifact artifact,
-    NodeId nodeId,
-    long startTime,           // T0: Blueprint change / LOAD command issued
-    long loadTime,            // T1: LOAD state received by node
-    long loadedTime,          // T2: LOADED state committed
-    long activateTime,        // T3: ACTIVATE state committed
-    long activeTime,          // T4: ACTIVE state committed (0 if not reached)
-    DeploymentStatus status
-) {
-
+ Artifact artifact,
+ NodeId nodeId,
+ long startTime,
+ // T0: Blueprint change / LOAD command issued
+long loadTime,
+ // T1: LOAD state received by node
+long loadedTime,
+ // T2: LOADED state committed
+long activateTime,
+ // T3: ACTIVATE state committed
+long activeTime,
+ // T4: ACTIVE state committed (0 if not reached)
+DeploymentStatus status) {
     public enum DeploymentStatus {
         IN_PROGRESS,
         SUCCESS,
         FAILED_LOADING,
         FAILED_ACTIVATING;
-
         public static DeploymentStatus fromString(String value) {
             return switch (value) {
-                case "IN_PROGRESS" -> IN_PROGRESS;
-                case "SUCCESS" -> SUCCESS;
-                case "FAILED_LOADING" -> FAILED_LOADING;
-                case "FAILED_ACTIVATING" -> FAILED_ACTIVATING;
+                case"IN_PROGRESS" -> IN_PROGRESS;
+                case"SUCCESS" -> SUCCESS;
+                case"FAILED_LOADING" -> FAILED_LOADING;
+                case"FAILED_ACTIVATING" -> FAILED_ACTIVATING;
                 default -> IN_PROGRESS;
             };
         }
@@ -44,7 +46,9 @@ public static DeploymentStatus fromString(String value) {
      * Returns -1 if deployment not yet complete.
      */
     public long fullDeploymentTime() {
-        return activeTime > 0 ? activeTime - startTime : -1;
+        return activeTime > 0
+               ? activeTime - startTime
+               : - 1;
     }
 
     /**
@@ -52,7 +56,9 @@ public long fullDeploymentTime() {
      * Returns -1 if deployment not yet complete.
      */
     public long netDeploymentTime() {
-        return activeTime > 0 && loadedTime > 0 ? activeTime - loadedTime : -1;
+        return activeTime > 0 && loadedTime > 0
+               ? activeTime - loadedTime
+               : - 1;
     }
 
     /**
@@ -60,7 +66,6 @@ public long netDeploymentTime() {
      */
     public Map<String, Long> transitionLatencies() {
         var latencies = new LinkedHashMap<String, Long>();
-
         if (loadTime > 0 && startTime > 0) {
             latencies.put("START_TO_LOAD", loadTime - startTime);
         }
@@ -73,7 +78,6 @@ public Map<String, Long> transitionLatencies() {
         if (activeTime > 0 && activateTime > 0) {
             latencies.put("ACTIVATE_TO_ACTIVE", activeTime - activateTime);
         }
-
         return latencies;
     }
 
@@ -82,15 +86,7 @@ public Map<String, Long> transitionLatencies() {
      */
     public DeploymentMetricsEntry toEntry() {
         return new DeploymentMetricsEntry(
-            artifact.asString(),
-            nodeId.id(),
-            startTime,
-            loadTime,
-            loadedTime,
-            activateTime,
-            activeTime,
-            status.name()
-        );
+        artifact.asString(), nodeId.id(), startTime, loadTime, loadedTime, activateTime, activeTime, status.name());
     }
 
     /**
@@ -99,19 +95,16 @@ public DeploymentMetricsEntry toEntry() {
      */
     public static DeploymentMetrics fromEntry(DeploymentMetricsEntry entry) {
         return Artifact.artifact(entry.artifact())
-            .fold(
-                _ -> null,
-                artifact -> new DeploymentMetrics(
-                    artifact,
-                    NodeId.nodeId(entry.nodeId()),
-                    entry.startTime(),
-                    entry.loadTime(),
-                    entry.loadedTime(),
-                    entry.activateTime(),
-                    entry.activeTime(),
-                    DeploymentStatus.fromString(entry.status())
-                )
-            );
+                       .fold(_ -> null,
+                             artifact -> new DeploymentMetrics(
+        artifact,
+        NodeId.nodeId(entry.nodeId()),
+        entry.startTime(),
+        entry.loadTime(),
+        entry.loadedTime(),
+        entry.activateTime(),
+        entry.activeTime(),
+        DeploymentStatus.fromString(entry.status())));
     }
 
     /**
@@ -119,8 +112,7 @@ public static DeploymentMetrics fromEntry(DeploymentMetricsEntry entry) {
      */
     public static DeploymentMetrics started(Artifact artifact, NodeId nodeId, long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, timestamp, 0, 0, 0, 0, DeploymentStatus.IN_PROGRESS
-        );
+        artifact, nodeId, timestamp, 0, 0, 0, 0, DeploymentStatus.IN_PROGRESS);
     }
 
     /**
@@ -128,8 +120,7 @@ public static DeploymentMetrics started(Artifact artifact, NodeId nodeId, long t
      */
     public DeploymentMetrics withLoadTime(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, timestamp, loadedTime, activateTime, activeTime, status
-        );
+        artifact, nodeId, startTime, timestamp, loadedTime, activateTime, activeTime, status);
     }
 
     /**
@@ -137,8 +128,7 @@ public DeploymentMetrics withLoadTime(long timestamp) {
      */
     public DeploymentMetrics withLoadedTime(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, loadTime, timestamp, activateTime, activeTime, status
-        );
+        artifact, nodeId, startTime, loadTime, timestamp, activateTime, activeTime, status);
     }
 
     /**
@@ -146,8 +136,7 @@ public DeploymentMetrics withLoadedTime(long timestamp) {
      */
     public DeploymentMetrics withActivateTime(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, loadTime, loadedTime, timestamp, activeTime, status
-        );
+        artifact, nodeId, startTime, loadTime, loadedTime, timestamp, activeTime, status);
     }
 
     /**
@@ -155,8 +144,7 @@ public DeploymentMetrics withActivateTime(long timestamp) {
      */
     public DeploymentMetrics completed(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, loadTime, loadedTime, activateTime, timestamp, DeploymentStatus.SUCCESS
-        );
+        artifact, nodeId, startTime, loadTime, loadedTime, activateTime, timestamp, DeploymentStatus.SUCCESS);
     }
 
     /**
@@ -164,8 +152,7 @@ public DeploymentMetrics completed(long timestamp) {
      */
     public DeploymentMetrics failedLoading(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, loadTime, timestamp, 0, 0, DeploymentStatus.FAILED_LOADING
-        );
+        artifact, nodeId, startTime, loadTime, timestamp, 0, 0, DeploymentStatus.FAILED_LOADING);
     }
 
     /**
@@ -173,7 +160,6 @@ public DeploymentMetrics failedLoading(long timestamp) {
      */
     public DeploymentMetrics failedActivating(long timestamp) {
         return new DeploymentMetrics(
-            artifact, nodeId, startTime, loadTime, loadedTime, activateTime, timestamp, DeploymentStatus.FAILED_ACTIVATING
-        );
+        artifact, nodeId, startTime, loadTime, loadedTime, activateTime, timestamp, DeploymentStatus.FAILED_ACTIVATING);
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
index 2c7f0144..594c122b 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
@@ -11,12 +11,13 @@
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.topology.TopologyChangeNotification;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Collects and manages deployment timing metrics for slice deployments.
  *
@@ -30,7 +31,6 @@
  * <p>Metrics are stored in-memory. Completed deployments retain last N entries per artifact.
  */
 public interface DeploymentMetricsCollector {
-
     /**
      * Default number of completed deployments to retain per artifact.
      */
@@ -107,13 +107,14 @@ static DeploymentMetricsCollector deploymentMetricsCollector(NodeId self, Cluste
     /**
      * Create a new DeploymentMetricsCollector with custom retention count.
      */
-    static DeploymentMetricsCollector deploymentMetricsCollector(NodeId self, ClusterNetwork network, int retentionCount) {
+    static DeploymentMetricsCollector deploymentMetricsCollector(NodeId self,
+                                                                 ClusterNetwork network,
+                                                                 int retentionCount) {
         return new DeploymentMetricsCollectorImpl(self, network, retentionCount);
     }
 }
 
 class DeploymentMetricsCollectorImpl implements DeploymentMetricsCollector {
-
     private static final Logger log = LoggerFactory.getLogger(DeploymentMetricsCollectorImpl.class);
 
     private final NodeId self;
@@ -146,11 +147,18 @@ public void onDeploymentStarted(DeploymentStarted event) {
     @Override
     public void onStateTransition(StateTransition event) {
         var key = new DeploymentKey(event.artifact(), event.nodeId());
-        inProgress.computeIfPresent(key, (_, metrics) -> updateMetricsForTransition(metrics, event.from(), event.to(), event.timestamp()));
+        inProgress.computeIfPresent(key,
+                                    (_, metrics) -> updateMetricsForTransition(metrics,
+                                                                               event.from(),
+                                                                               event.to(),
+                                                                               event.timestamp()));
         log.trace("State transition: {} on {} from {} to {}", event.artifact(), event.nodeId(), event.from(), event.to());
     }
 
-    private DeploymentMetrics updateMetricsForTransition(DeploymentMetrics metrics, SliceState from, SliceState to, long timestamp) {
+    private DeploymentMetrics updateMetricsForTransition(DeploymentMetrics metrics,
+                                                         SliceState from,
+                                                         SliceState to,
+                                                         long timestamp) {
         return switch (to) {
             case LOAD -> metrics.withLoadTime(timestamp);
             case LOADED -> metrics.withLoadedTime(timestamp);
@@ -163,12 +171,13 @@ private DeploymentMetrics updateMetricsForTransition(DeploymentMetrics metrics,
     public void onDeploymentCompleted(DeploymentCompleted event) {
         var key = new DeploymentKey(event.artifact(), event.nodeId());
         var metrics = inProgress.remove(key);
-
         if (metrics != null) {
             var completedMetrics = metrics.completed(event.timestamp());
             addToCompleted(event.artifact(), completedMetrics);
             log.info("Deployment completed: {} on {} in {}ms",
-                event.artifact(), event.nodeId(), completedMetrics.fullDeploymentTime());
+                     event.artifact(),
+                     event.nodeId(),
+                     completedMetrics.fullDeploymentTime());
         }
     }
 
@@ -176,7 +185,6 @@ public void onDeploymentCompleted(DeploymentCompleted event) {
     public void onDeploymentFailed(DeploymentFailed event) {
         var key = new DeploymentKey(event.artifact(), event.nodeId());
         var metrics = inProgress.remove(key);
-
         if (metrics != null) {
             var failedMetrics = switch (event.failedAt()) {
                 case LOADING -> metrics.failedLoading(event.timestamp());
@@ -184,47 +192,49 @@ public void onDeploymentFailed(DeploymentFailed event) {
                 default -> metrics.failedLoading(event.timestamp());
             };
             addToCompleted(event.artifact(), failedMetrics);
-            log.warn("Deployment failed: {} on {} at state {}",
-                event.artifact(), event.nodeId(), event.failedAt());
+            log.warn("Deployment failed: {} on {} at state {}", event.artifact(), event.nodeId(), event.failedAt());
         }
     }
 
     private void addToCompleted(Artifact artifact, DeploymentMetrics metrics) {
-        completed.compute(artifact, (_, list) -> {
-            var newList = new ArrayList<>(list != null ? list : List.of());
-            newList.addFirst(metrics); // Most recent first
-            // Trim to retention count
-            while (newList.size() > retentionCount) {
-                newList.removeLast();
-            }
-            return List.copyOf(newList);
-        });
+        completed.compute(artifact,
+                          (_, list) -> {
+                              var newList = new ArrayList<>(list != null
+                                                            ? list
+                                                            : List.of());
+                              newList.addFirst(metrics);
+                              // Most recent first
+        // Trim to retention count
+        while (newList.size() > retentionCount) {
+                              newList.removeLast();
+                          }
+                              return List.copyOf(newList);
+                          });
     }
 
     @Override
     public Map<Artifact, List<DeploymentMetrics>> allDeploymentMetrics() {
         var result = new HashMap<Artifact, List<DeploymentMetrics>>();
-
         // Add local completed metrics (sorted by startTime)
         completed.forEach((artifact, list) -> {
-            var sorted = new ArrayList<>(list);
-            sorted.sort((a, b) -> Long.compare(b.startTime(), a.startTime()));
-            result.put(artifact, sorted);
-        });
-
+                              var sorted = new ArrayList<>(list);
+                              sorted.sort((a, b) -> Long.compare(b.startTime(), a.startTime()));
+                              result.put(artifact, sorted);
+                          });
         // Merge remote metrics
         remoteMetrics.forEach((artifact, remoteList) -> {
-            result.merge(artifact, remoteList, (local, remote) -> {
-                var merged = new ArrayList<>(local);
-                merged.addAll(remote);
-                // Sort by startTime descending (most recent first), keep top N
-                merged.sort((a, b) -> Long.compare(b.startTime(), a.startTime()));
-                return merged.size() > retentionCount
-                    ? merged.subList(0, retentionCount)
-                    : merged;
-            });
-        });
-
+                                  result.merge(artifact,
+                                               remoteList,
+                                               (local, remote) -> {
+                                                   var merged = new ArrayList<>(local);
+                                                   merged.addAll(remote);
+                                                   // Sort by startTime descending (most recent first), keep top N
+        merged.sort((a, b) -> Long.compare(b.startTime(), a.startTime()));
+                                                   return merged.size() > retentionCount
+                                                          ? merged.subList(0, retentionCount)
+                                                          : merged;
+                                               });
+                              });
         return result;
     }
 
@@ -232,18 +242,16 @@ public Map<Artifact, List<DeploymentMetrics>> allDeploymentMetrics() {
     public List<DeploymentMetrics> metricsFor(Artifact artifact) {
         var local = completed.getOrDefault(artifact, List.of());
         var remote = remoteMetrics.getOrDefault(artifact, List.of());
-
         if (remote.isEmpty() && local.isEmpty()) {
             return List.of();
         }
-
         var merged = new ArrayList<>(local);
         merged.addAll(remote);
         // Always sort by startTime descending (most recent first)
         merged.sort((a, b) -> Long.compare(b.startTime(), a.startTime()));
         return merged.size() > retentionCount
-            ? merged.subList(0, retentionCount)
-            : merged;
+               ? merged.subList(0, retentionCount)
+               : merged;
     }
 
     @Override
@@ -254,10 +262,10 @@ public Map<DeploymentKey, DeploymentMetrics> inProgressDeployments() {
     @Override
     public void onDeploymentMetricsPing(DeploymentMetricsPing ping) {
         // Store sender's metrics (but don't overwrite our own)
-        if (!ping.sender().equals(self)) {
+        if (!ping.sender()
+                 .equals(self)) {
             storeRemoteMetrics(ping.metrics());
         }
-
         // Respond with our metrics
         network.send(ping.sender(), new DeploymentMetricsPong(self, collectLocalEntries()));
     }
@@ -265,7 +273,8 @@ public void onDeploymentMetricsPing(DeploymentMetricsPing ping) {
     @Override
     public void onDeploymentMetricsPong(DeploymentMetricsPong pong) {
         // Store responder's metrics (but don't overwrite our own)
-        if (!pong.sender().equals(self)) {
+        if (!pong.sender()
+                 .equals(self)) {
             storeRemoteMetrics(pong.metrics());
         }
     }
@@ -280,20 +289,21 @@ public void onTopologyChange(TopologyChangeNotification topologyChange) {
 
     private void removeMetricsForNode(NodeId nodeId) {
         // Remove from in-progress
-        var inProgressToRemove = inProgress.keySet().stream()
-            .filter(key -> key.nodeId().equals(nodeId))
-            .toList();
+        var inProgressToRemove = inProgress.keySet()
+                                           .stream()
+                                           .filter(key -> key.nodeId()
+                                                             .equals(nodeId))
+                                           .toList();
         inProgressToRemove.forEach(inProgress::remove);
-
         // Remove from remote metrics
-        remoteMetrics.replaceAll((artifact, metricsList) ->
-            metricsList.stream()
-                .filter(m -> !m.nodeId().equals(nodeId))
-                .toList()
-        );
+        remoteMetrics.replaceAll((artifact, metricsList) -> metricsList.stream()
+                                                                       .filter(m -> !m.nodeId()
+                                                                                      .equals(nodeId))
+                                                                       .toList());
         // Clean up empty entries
-        remoteMetrics.entrySet().removeIf(e -> e.getValue().isEmpty());
-
+        remoteMetrics.entrySet()
+                     .removeIf(e -> e.getValue()
+                                     .isEmpty());
         if (!inProgressToRemove.isEmpty() || !remoteMetrics.isEmpty()) {
             log.debug("Cleaned up metrics for departed node {}", nodeId);
         }
@@ -301,35 +311,33 @@ private void removeMetricsForNode(NodeId nodeId) {
 
     private void storeRemoteMetrics(Map<String, List<DeploymentMetricsEntry>> entries) {
         entries.forEach((artifactStr, entryList) -> {
-            Artifact.artifact(artifactStr).onSuccess(artifact -> {
-                var metricsList = entryList.stream()
-                    .map(DeploymentMetrics::fromEntry)
-                    .filter(m -> m != null)
-                    .toList();
-
-                // Only store if not from our node
-                var filteredList = metricsList.stream()
-                    .filter(m -> !m.nodeId().equals(self))
-                    .toList();
-
-                if (!filteredList.isEmpty()) {
-                    remoteMetrics.put(artifact, filteredList);
-                }
-            });
-        });
+                            Artifact.artifact(artifactStr)
+                                    .onSuccess(artifact -> {
+                                                   var metricsList = entryList.stream()
+                                                                              .map(DeploymentMetrics::fromEntry)
+                                                                              .filter(m -> m != null)
+                                                                              .toList();
+                                                   // Only store if not from our node
+        var filteredList = metricsList.stream()
+                                      .filter(m -> !m.nodeId()
+                                                     .equals(self))
+                                      .toList();
+                                                   if (!filteredList.isEmpty()) {
+                                                   remoteMetrics.put(artifact, filteredList);
+                                               }
+                                               });
+                        });
     }
 
     @Override
     public Map<String, List<DeploymentMetricsEntry>> collectLocalEntries() {
         var result = new HashMap<String, List<DeploymentMetricsEntry>>();
-
         completed.forEach((artifact, metricsList) -> {
-            var entries = metricsList.stream()
-                .map(DeploymentMetrics::toEntry)
-                .toList();
-            result.put(artifact.asString(), entries);
-        });
-
+                              var entries = metricsList.stream()
+                                                       .map(DeploymentMetrics::toEntry)
+                                                       .toList();
+                              result.put(artifact.asString(), entries);
+                          });
         return result;
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
index 5804cdd8..02b96065 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
@@ -8,13 +8,14 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.message.MessageReceiver;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicReference;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Scheduler for deployment metrics broadcast that runs on the leader node.
  *
@@ -22,7 +23,6 @@
  * Each node responds with DeploymentMetricsPong containing their deployment metrics.
  */
 public interface DeploymentMetricsScheduler {
-
     /**
      * Default broadcast interval: 5 seconds.
      */
@@ -42,27 +42,24 @@ public interface DeploymentMetricsScheduler {
     /**
      * Create a new DeploymentMetricsScheduler with default 5-second interval.
      */
-    static DeploymentMetricsScheduler deploymentMetricsScheduler(
-            NodeId self,
-            ClusterNetwork network,
-            DeploymentMetricsCollector collector) {
+    static DeploymentMetricsScheduler deploymentMetricsScheduler(NodeId self,
+                                                                 ClusterNetwork network,
+                                                                 DeploymentMetricsCollector collector) {
         return deploymentMetricsScheduler(self, network, collector, DEFAULT_INTERVAL_MS);
     }
 
     /**
      * Create a new DeploymentMetricsScheduler with custom interval.
      */
-    static DeploymentMetricsScheduler deploymentMetricsScheduler(
-            NodeId self,
-            ClusterNetwork network,
-            DeploymentMetricsCollector collector,
-            long intervalMs) {
+    static DeploymentMetricsScheduler deploymentMetricsScheduler(NodeId self,
+                                                                 ClusterNetwork network,
+                                                                 DeploymentMetricsCollector collector,
+                                                                 long intervalMs) {
         return new DeploymentMetricsSchedulerImpl(self, network, collector, intervalMs);
     }
 }
 
 class DeploymentMetricsSchedulerImpl implements DeploymentMetricsScheduler {
-
     private static final Logger log = LoggerFactory.getLogger(DeploymentMetricsSchedulerImpl.class);
 
     private final NodeId self;
@@ -71,19 +68,19 @@ class DeploymentMetricsSchedulerImpl implements DeploymentMetricsScheduler {
     private final long intervalMs;
 
     private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-        var thread = new Thread(r, "deployment-metrics-scheduler");
-        thread.setDaemon(true);
-        return thread;
-    });
+                                                                                                      var thread = new Thread(r,
+                                                                                                                              "deployment-metrics-scheduler");
+                                                                                                      thread.setDaemon(true);
+                                                                                                      return thread;
+                                                                                                  });
 
-    private final AtomicReference<ScheduledFuture<?>> pingTask = new AtomicReference<>();
+    private final AtomicReference<ScheduledFuture< ? >> pingTask = new AtomicReference<>();
     private final AtomicReference<List<NodeId>> topology = new AtomicReference<>(List.of());
 
-    DeploymentMetricsSchedulerImpl(
-            NodeId self,
-            ClusterNetwork network,
-            DeploymentMetricsCollector collector,
-            long intervalMs) {
+    DeploymentMetricsSchedulerImpl(NodeId self,
+                                   ClusterNetwork network,
+                                   DeploymentMetricsCollector collector,
+                                   long intervalMs) {
         this.self = self;
         this.network = network;
         this.collector = collector;
@@ -95,7 +92,7 @@ public void onLeaderChange(LeaderChange leaderChange) {
         if (leaderChange.localNodeIsLeader()) {
             log.info("Node {} became leader, starting deployment metrics scheduler", self);
             startPinging();
-        } else {
+        }else {
             log.info("Node {} is no longer leader, stopping deployment metrics scheduler", self);
             stopPinging();
         }
@@ -114,23 +111,22 @@ public void onTopologyChange(TopologyChangeNotification topologyChange) {
     public void stop() {
         stopPinging();
         scheduler.shutdown();
-        try {
+        try{
             if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
                 scheduler.shutdownNow();
             }
         } catch (InterruptedException e) {
             scheduler.shutdownNow();
-            Thread.currentThread().interrupt();
+            Thread.currentThread()
+                  .interrupt();
         }
     }
 
     private void startPinging() {
-        stopPinging(); // Cancel any existing task
-
+        stopPinging();
+        // Cancel any existing task
         var task = scheduler.scheduleAtFixedRate(
-                this::sendPingsToAllNodes,
-                0, intervalMs, TimeUnit.MILLISECONDS
-        );
+        this::sendPingsToAllNodes, 0, intervalMs, TimeUnit.MILLISECONDS);
         pingTask.set(task);
     }
 
@@ -142,21 +138,18 @@ private void stopPinging() {
     }
 
     private void sendPingsToAllNodes() {
-        try {
+        try{
             var currentTopology = topology.get();
             if (currentTopology.isEmpty()) {
                 return;
             }
-
             var localMetrics = collector.collectLocalEntries();
             var ping = new DeploymentMetricsPing(self, localMetrics);
-
             for (var nodeId : currentTopology) {
                 if (!nodeId.equals(self)) {
                     network.send(nodeId, ping);
                 }
             }
-
             log.trace("Sent DeploymentMetricsPing to {} nodes", currentTopology.size() - 1);
         } catch (Exception e) {
             log.warn("Failed to send deployment metrics ping: {}", e.getMessage());
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/invocation/InvocationMetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/invocation/InvocationMetricsCollector.java
index 8ceae489..8c48d0c2 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/invocation/InvocationMetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/invocation/InvocationMetricsCollector.java
@@ -33,7 +33,6 @@
  * }</pre>
  */
 public final class InvocationMetricsCollector {
-
     /**
      * Maximum slow invocations to retain per method per snapshot interval.
      */
@@ -42,8 +41,7 @@ public final class InvocationMetricsCollector {
     private final ThresholdStrategy thresholdStrategy;
 
     // Per-method metrics: Map<sliceArtifact, Map<methodName, metrics>>
-    private final Map<Artifact, Map<MethodName, MethodMetricsWithSlowCalls>> metricsMap =
-            new ConcurrentHashMap<>();
+    private final Map<Artifact, Map<MethodName, MethodMetricsWithSlowCalls>> metricsMap = new ConcurrentHashMap<>();
 
     private InvocationMetricsCollector(ThresholdStrategy thresholdStrategy) {
         this.thresholdStrategy = thresholdStrategy;
@@ -74,22 +72,27 @@ public static InvocationMetricsCollector invocationMetricsCollector() {
      * @param responseBytes Size of serialized response (0 for fire-and-forget or failures)
      * @param errorType     Error type class name if failed
      */
-    public void record(Artifact artifact, MethodName method, long durationNs, boolean success,
-                       int requestBytes, int responseBytes, Option<String> errorType) {
+    public void record(Artifact artifact,
+                       MethodName method,
+                       long durationNs,
+                       boolean success,
+                       int requestBytes,
+                       int responseBytes,
+                       Option<String> errorType) {
         var methodMetrics = getOrCreateMetrics(artifact, method);
-
         // Tier 1: Always record to aggregated metrics
         methodMetrics.metrics.record(durationNs, success);
-
         // Update adaptive threshold
         thresholdStrategy.observe(method, durationNs);
-
         // Tier 2: Capture if slow
         if (thresholdStrategy.isSlow(method, durationNs)) {
             var slow = success
-                    ? SlowInvocation.success(method, System.nanoTime(), durationNs, requestBytes, responseBytes)
-                    : SlowInvocation.failure(method, System.nanoTime(), durationNs, requestBytes,
-                                             errorType.fold(() -> "Unknown", e -> e));
+                       ? SlowInvocation.success(method, System.nanoTime(), durationNs, requestBytes, responseBytes)
+                       : SlowInvocation.failure(method,
+                                                System.nanoTime(),
+                                                durationNs,
+                                                requestBytes,
+                                                errorType.fold(() -> "Unknown", e -> e));
             methodMetrics.addSlowInvocation(slow);
         }
     }
@@ -97,16 +100,22 @@ public void record(Artifact artifact, MethodName method, long durationNs, boolea
     /**
      * Convenience method for recording success.
      */
-    public void recordSuccess(Artifact artifact, MethodName method, long durationNs,
-                              int requestBytes, int responseBytes) {
+    public void recordSuccess(Artifact artifact,
+                              MethodName method,
+                              long durationNs,
+                              int requestBytes,
+                              int responseBytes) {
         record(artifact, method, durationNs, true, requestBytes, responseBytes, Option.empty());
     }
 
     /**
      * Convenience method for recording failure.
      */
-    public void recordFailure(Artifact artifact, MethodName method, long durationNs,
-                              int requestBytes, String errorType) {
+    public void recordFailure(Artifact artifact,
+                              MethodName method,
+                              long durationNs,
+                              int requestBytes,
+                              String errorType) {
         record(artifact, method, durationNs, false, requestBytes, 0, Option.option(errorType));
     }
 
@@ -117,17 +126,17 @@ public void recordFailure(Artifact artifact, MethodName method, long durationNs,
      */
     public List<MethodSnapshot> snapshotAndReset() {
         var result = new ArrayList<MethodSnapshot>();
-
         metricsMap.forEach((artifact, methods) -> {
-            methods.forEach((method, collector) -> {
-                var metricsSnapshot = collector.metrics.snapshotAndReset();
-                var slowCalls = collector.drainSlowInvocations();
-                var threshold = thresholdStrategy.thresholdNs(method);
-
-                result.add(new MethodSnapshot(artifact, metricsSnapshot, slowCalls, threshold));
-            });
-        });
-
+                               methods.forEach((method, collector) -> {
+                                                   var metricsSnapshot = collector.metrics.snapshotAndReset();
+                                                   var slowCalls = collector.drainSlowInvocations();
+                                                   var threshold = thresholdStrategy.thresholdNs(method);
+                                                   result.add(new MethodSnapshot(artifact,
+                                                                                 metricsSnapshot,
+                                                                                 slowCalls,
+                                                                                 threshold));
+                                               });
+                           });
         return result;
     }
 
@@ -136,17 +145,17 @@ public List<MethodSnapshot> snapshotAndReset() {
      */
     public List<MethodSnapshot> snapshot() {
         var result = new ArrayList<MethodSnapshot>();
-
         metricsMap.forEach((artifact, methods) -> {
-            methods.forEach((method, collector) -> {
-                var metricsSnapshot = collector.metrics.snapshot();
-                var slowCalls = collector.copySlowInvocations();
-                var threshold = thresholdStrategy.thresholdNs(method);
-
-                result.add(new MethodSnapshot(artifact, metricsSnapshot, slowCalls, threshold));
-            });
-        });
-
+                               methods.forEach((method, collector) -> {
+                                                   var metricsSnapshot = collector.metrics.snapshot();
+                                                   var slowCalls = collector.copySlowInvocations();
+                                                   var threshold = thresholdStrategy.thresholdNs(method);
+                                                   result.add(new MethodSnapshot(artifact,
+                                                                                 metricsSnapshot,
+                                                                                 slowCalls,
+                                                                                 threshold));
+                                               });
+                           });
         return result;
     }
 
@@ -165,9 +174,9 @@ public ThresholdStrategy thresholdStrategy() {
     }
 
     private MethodMetricsWithSlowCalls getOrCreateMetrics(Artifact artifact, MethodName method) {
-        return metricsMap
-                .computeIfAbsent(artifact, _ -> new ConcurrentHashMap<>())
-                .computeIfAbsent(method, MethodMetricsWithSlowCalls::new);
+        return metricsMap.computeIfAbsent(artifact,
+                                          _ -> new ConcurrentHashMap<>())
+                         .computeIfAbsent(method, MethodMetricsWithSlowCalls::new);
     }
 
     /**
@@ -187,7 +196,7 @@ void addSlowInvocation(SlowInvocation slow) {
             var idx = writeIndex.getAndIncrement() % MAX_SLOW_INVOCATIONS_PER_METHOD;
             slowBuffer[idx] = slow;
             if (count < MAX_SLOW_INVOCATIONS_PER_METHOD) {
-                count++;
+                count++ ;
             }
         }
 
@@ -196,7 +205,7 @@ List<SlowInvocation> drainSlowInvocations() {
             // Reset
             writeIndex.set(0);
             count = 0;
-            for (int i = 0; i < MAX_SLOW_INVOCATIONS_PER_METHOD; i++) {
+            for (int i = 0; i < MAX_SLOW_INVOCATIONS_PER_METHOD; i++ ) {
                 slowBuffer[i] = null;
             }
             return result;
@@ -206,10 +215,9 @@ List<SlowInvocation> copySlowInvocations() {
             var result = new ArrayList<SlowInvocation>(count);
             var currentCount = Math.min(count, MAX_SLOW_INVOCATIONS_PER_METHOD);
             var startIdx = writeIndex.get() >= MAX_SLOW_INVOCATIONS_PER_METHOD
-                    ? writeIndex.get() % MAX_SLOW_INVOCATIONS_PER_METHOD
-                    : 0;
-
-            for (int i = 0; i < currentCount; i++) {
+                           ? writeIndex.get() % MAX_SLOW_INVOCATIONS_PER_METHOD
+                           : 0;
+            for (int i = 0; i < currentCount; i++ ) {
                 var idx = (startIdx + i) % MAX_SLOW_INVOCATIONS_PER_METHOD;
                 var slow = slowBuffer[idx];
                 if (slow != null) {
@@ -224,11 +232,10 @@ List<SlowInvocation> copySlowInvocations() {
      * Combined snapshot of method metrics and slow invocations.
      */
     public record MethodSnapshot(
-            Artifact artifact,
-            MethodMetrics.Snapshot metrics,
-            List<SlowInvocation> slowInvocations,
-            long currentThresholdNs
-    ) {
+    Artifact artifact,
+    MethodMetrics.Snapshot metrics,
+    List<SlowInvocation> slowInvocations,
+    long currentThresholdNs) {
         /**
          * Method name from the metrics.
          */
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/invocation/MethodMetrics.java b/node/src/main/java/org/pragmatica/aether/metrics/invocation/MethodMetrics.java
index c71cd9f3..9e979dcf 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/invocation/MethodMetrics.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/invocation/MethodMetrics.java
@@ -21,7 +21,6 @@
  * </ul>
  */
 public final class MethodMetrics {
-
     // Histogram bucket thresholds in nanoseconds
     private static final long BUCKET_1MS = 1_000_000L;
     private static final long BUCKET_10MS = 10_000_000L;
@@ -40,7 +39,7 @@ public final class MethodMetrics {
     public MethodMetrics(MethodName methodName) {
         this.methodName = methodName;
         this.histogram = new AtomicInteger[HISTOGRAM_SIZE];
-        for (int i = 0; i < HISTOGRAM_SIZE; i++) {
+        for (int i = 0; i < HISTOGRAM_SIZE; i++ ) {
             histogram[i] = new AtomicInteger();
         }
     }
@@ -55,11 +54,12 @@ public void record(long durationNs, boolean success) {
         count.incrementAndGet();
         if (success) {
             successCount.incrementAndGet();
-        } else {
+        }else {
             failureCount.incrementAndGet();
         }
         totalDurationNs.addAndGet(durationNs);
-        histogram[bucketFor(durationNs)].incrementAndGet();
+        histogram[bucketFor(durationNs)]
+        .incrementAndGet();
     }
 
     /**
@@ -73,18 +73,11 @@ public Snapshot snapshotAndReset() {
         var snapshotFailure = failureCount.getAndSet(0);
         var snapshotDuration = totalDurationNs.getAndSet(0);
         var snapshotHistogram = new int[HISTOGRAM_SIZE];
-        for (int i = 0; i < HISTOGRAM_SIZE; i++) {
+        for (int i = 0; i < HISTOGRAM_SIZE; i++ ) {
             snapshotHistogram[i] = histogram[i].getAndSet(0);
         }
-
         return new Snapshot(
-                methodName,
-                snapshotCount,
-                snapshotSuccess,
-                snapshotFailure,
-                snapshotDuration,
-                snapshotHistogram
-        );
+        methodName, snapshotCount, snapshotSuccess, snapshotFailure, snapshotDuration, snapshotHistogram);
     }
 
     /**
@@ -92,18 +85,11 @@ public Snapshot snapshotAndReset() {
      */
     public Snapshot snapshot() {
         var snapshotHistogram = new int[HISTOGRAM_SIZE];
-        for (int i = 0; i < HISTOGRAM_SIZE; i++) {
+        for (int i = 0; i < HISTOGRAM_SIZE; i++ ) {
             snapshotHistogram[i] = histogram[i].get();
         }
-
         return new Snapshot(
-                methodName,
-                count.get(),
-                successCount.get(),
-                failureCount.get(),
-                totalDurationNs.get(),
-                snapshotHistogram
-        );
+        methodName, count.get(), successCount.get(), failureCount.get(), totalDurationNs.get(), snapshotHistogram);
     }
 
     public MethodName methodName() {
@@ -130,25 +116,28 @@ private static int bucketFor(long durationNs) {
      * Immutable snapshot of method metrics.
      */
     public record Snapshot(
-            MethodName methodName,
-            long count,
-            long successCount,
-            long failureCount,
-            long totalDurationNs,
-            int[] histogram
-    ) {
+    MethodName methodName,
+    long count,
+    long successCount,
+    long failureCount,
+    long totalDurationNs,
+    int[] histogram) {
         /**
          * Calculate average latency in nanoseconds.
          */
         public long averageLatencyNs() {
-            return count > 0 ? totalDurationNs / count : 0;
+            return count > 0
+                   ? totalDurationNs / count
+                   : 0;
         }
 
         /**
          * Calculate success rate (0.0 to 1.0).
          */
         public double successRate() {
-            return count > 0 ? (double) successCount / count : 1.0;
+            return count > 0
+                   ? (double) successCount / count
+                   : 1.0;
         }
 
         /**
@@ -160,17 +149,15 @@ public double successRate() {
          */
         public long estimatePercentileNs(int percentile) {
             if (count == 0) return 0;
-
             long target = (count * percentile) / 100;
             long cumulative = 0;
-
-            for (int i = 0; i < histogram.length; i++) {
+            for (int i = 0; i < histogram.length; i++ ) {
                 cumulative += histogram[i];
                 if (cumulative >= target) {
                     return bucketUpperBound(i);
                 }
             }
-            return BUCKET_1S; // Default to 1s if all in last bucket
+            return BUCKET_1S;
         }
 
         private static long bucketUpperBound(int bucket) {
@@ -179,7 +166,7 @@ private static long bucketUpperBound(int bucket) {
                 case 1 -> BUCKET_10MS;
                 case 2 -> BUCKET_100MS;
                 case 3 -> BUCKET_1S;
-                default -> BUCKET_1S * 10; // 10s for overflow bucket
+                default -> BUCKET_1S * 10;
             };
         }
     }
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/invocation/SlowInvocation.java b/node/src/main/java/org/pragmatica/aether/metrics/invocation/SlowInvocation.java
index b7ea2647..90587e15 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/invocation/SlowInvocation.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/invocation/SlowInvocation.java
@@ -19,30 +19,33 @@
  * @param errorType     Error type if failed (class name of the Cause)
  */
 public record SlowInvocation(
-        MethodName methodName,
-        long timestampNs,
-        long durationNs,
-        int requestBytes,
-        int responseBytes,
-        boolean success,
-        Option<String> errorType
-) {
+ MethodName methodName,
+ long timestampNs,
+ long durationNs,
+ int requestBytes,
+ int responseBytes,
+ boolean success,
+ Option<String> errorType) {
     /**
      * Create a successful slow invocation record.
      */
-    public static SlowInvocation success(MethodName method, long timestampNs, long durationNs,
-                                          int requestBytes, int responseBytes) {
-        return new SlowInvocation(method, timestampNs, durationNs, requestBytes, responseBytes,
-                                  true, Option.empty());
+    public static SlowInvocation success(MethodName method,
+                                         long timestampNs,
+                                         long durationNs,
+                                         int requestBytes,
+                                         int responseBytes) {
+        return new SlowInvocation(method, timestampNs, durationNs, requestBytes, responseBytes, true, Option.empty());
     }
 
     /**
      * Create a failed slow invocation record.
      */
-    public static SlowInvocation failure(MethodName method, long timestampNs, long durationNs,
-                                          int requestBytes, String errorType) {
-        return new SlowInvocation(method, timestampNs, durationNs, requestBytes, 0,
-                                  false, Option.option(errorType));
+    public static SlowInvocation failure(MethodName method,
+                                         long timestampNs,
+                                         long durationNs,
+                                         int requestBytes,
+                                         String errorType) {
+        return new SlowInvocation(method, timestampNs, durationNs, requestBytes, 0, false, Option.option(errorType));
     }
 
     /**
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/invocation/ThresholdStrategy.java b/node/src/main/java/org/pragmatica/aether/metrics/invocation/ThresholdStrategy.java
index d9477958..3417800d 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/invocation/ThresholdStrategy.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/invocation/ThresholdStrategy.java
@@ -13,7 +13,6 @@
  * contribute to aggregated metrics.
  */
 public sealed interface ThresholdStrategy {
-
     /**
      * Determine if a duration qualifies as slow for the given method.
      *
@@ -30,9 +29,7 @@ public sealed interface ThresholdStrategy {
      * @param method     The method that was invoked
      * @param durationNs Duration in nanoseconds
      */
-    default void observe(MethodName method, long durationNs) {
-        // Default: no-op for non-adaptive strategies
-    }
+    default void observe(MethodName method, long durationNs) {}
 
     /**
      * Get the current threshold for a method (for monitoring).
@@ -43,7 +40,6 @@ default void observe(MethodName method, long durationNs) {
     long thresholdNs(MethodName method);
 
     // ========== Factory methods ==========
-
     /**
      * Fixed threshold strategy - same threshold for all methods.
      *
@@ -88,7 +84,8 @@ static PerMethod perMethod(long defaultThresholdMs) {
      * Composite strategy - uses per-method thresholds with adaptive fallback.
      */
     static ThresholdStrategy composite(Map<MethodName, Long> methodThresholdsMs,
-                                        long defaultMinMs, long defaultMaxMs) {
+                                       long defaultMinMs,
+                                       long defaultMaxMs) {
         var adaptive = adaptive(defaultMinMs, defaultMaxMs);
         var methodThresholdsNs = new ConcurrentHashMap<MethodName, Long>();
         methodThresholdsMs.forEach((k, v) -> methodThresholdsNs.put(k, v * 1_000_000));
@@ -96,7 +93,6 @@ static ThresholdStrategy composite(Map<MethodName, Long> methodThresholdsMs,
     }
 
     // ========== Implementations ==========
-
     /**
      * Fixed threshold - same for all methods.
      */
@@ -156,7 +152,7 @@ public long thresholdNs(MethodName method) {
 
         private long computeThreshold(MethodStats stats) {
             var avgNs = stats.averageNs();
-            var threshold = (long) (avgNs * multiplier);
+            var threshold = (long)(avgNs * multiplier);
             return Math.max(minThresholdNs, Math.min(maxThresholdNs, threshold));
         }
 
@@ -164,16 +160,18 @@ private long computeThreshold(MethodStats stats) {
          * Per-method statistics using exponential moving average.
          */
         private static final class MethodStats {
-            private static final double ALPHA = 0.1; // Smoothing factor
+            private static final double ALPHA = 0.1;
 
+            // Smoothing factor
             private final AtomicLong count = new AtomicLong();
-            private volatile double ema = 0; // Exponential moving average
+            private volatile double ema = 0;
 
+            // Exponential moving average
             void update(long durationNs) {
                 var c = count.incrementAndGet();
                 if (c == 1) {
                     ema = durationNs;
-                } else {
+                }else {
                     // Thread-safe EMA update (approximate, but good enough for thresholds)
                     ema = ALPHA * durationNs + (1 - ALPHA) * ema;
                 }
@@ -230,9 +228,8 @@ public long thresholdNs(MethodName method) {
      * Composite strategy - per-method overrides with adaptive fallback.
      */
     record Composite(
-            Map<MethodName, Long> methodThresholdsNs,
-            ThresholdStrategy fallback
-    ) implements ThresholdStrategy {
+    Map<MethodName, Long> methodThresholdsNs,
+    ThresholdStrategy fallback) implements ThresholdStrategy {
         @Override
         public boolean isSlow(MethodName method, long durationNs) {
             var explicit = methodThresholdsNs.get(method);
@@ -252,7 +249,9 @@ public void observe(MethodName method, long durationNs) {
         @Override
         public long thresholdNs(MethodName method) {
             var explicit = methodThresholdsNs.get(method);
-            return explicit != null ? explicit : fallback.thresholdNs(method);
+            return explicit != null
+                   ? explicit
+                   : fallback.thresholdNs(method);
         }
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherCustomClasses.java b/node/src/main/java/org/pragmatica/aether/node/AetherCustomClasses.java
index 1ca115fc..b1fe8813 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherCustomClasses.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherCustomClasses.java
@@ -27,26 +27,24 @@
  * Registers Aether-specific classes for serialization.
  */
 public interface AetherCustomClasses {
-
-    static void configure(Consumer<Class<?>> consumer) {
+    static void configure(Consumer<Class< ? >> consumer) {
         // Include base Rabia classes
         CustomClasses.configure(consumer);
-
         // Aether key/value types
-        concreteSubtypes(AetherKey.class).forEach(consumer);
-        concreteSubtypes(AetherValue.class).forEach(consumer);
-        concreteSubtypes(AetherKey.AetherKeyPattern.class).forEach(consumer);
-
+        concreteSubtypes(AetherKey.class)
+        .forEach(consumer);
+        concreteSubtypes(AetherValue.class)
+        .forEach(consumer);
+        concreteSubtypes(AetherKey.AetherKeyPattern.class)
+        .forEach(consumer);
         // Artifact types
         consumer.accept(Artifact.class);
         consumer.accept(GroupId.class);
         consumer.accept(ArtifactId.class);
         consumer.accept(Version.class);
-
         // Slice types
         consumer.accept(SliceState.class);
         consumer.accept(MethodName.class);
-
         // Blueprint types
         consumer.accept(BlueprintId.class);
         consumer.accept(ExpandedBlueprint.class);
@@ -54,12 +52,13 @@ static void configure(Consumer<Class<?>> consumer) {
         consumer.accept(Route.class);
         consumer.accept(RouteTarget.class);
         consumer.accept(Binding.class);
-        concreteSubtypes(BindingSource.class).forEach(consumer);
-
+        concreteSubtypes(BindingSource.class)
+        .forEach(consumer);
         // Metrics types
-        concreteSubtypes(MetricsMessage.class).forEach(consumer);
-
+        concreteSubtypes(MetricsMessage.class)
+        .forEach(consumer);
         // Invocation types
-        concreteSubtypes(InvocationMessage.class).forEach(consumer);
+        concreteSubtypes(InvocationMessage.class)
+        .forEach(consumer);
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index b56ed44d..e609c732 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -51,11 +51,12 @@
 import org.pragmatica.message.MessageRouter;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
 import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
 
@@ -64,7 +65,6 @@
  * Assembles all components: consensus, KV-store, slice management, deployment managers.
  */
 public interface AetherNode {
-
     NodeId self();
 
     Promise<Unit> start();
@@ -100,7 +100,6 @@ static AetherNode aetherNode(AetherNodeConfig config) {
         var router = MessageRouter.mutable();
         var serializer = furySerializer(AetherCustomClasses::configure);
         var deserializer = furyDeserializer(AetherCustomClasses::configure);
-
         return aetherNode(config, router, serializer, deserializer);
     }
 
@@ -109,27 +108,26 @@ static AetherNode aetherNode(AetherNodeConfig config,
                                  Serializer serializer,
                                  Deserializer deserializer) {
         record aetherNode(
-                AetherNodeConfig config,
-                MessageRouter.MutableRouter router,
-                KVStore<AetherKey, AetherValue> kvStore,
-                SliceRegistry sliceRegistry,
-                SliceStore sliceStore,
-                RabiaNode<KVCommand<AetherKey>> clusterNode,
-                NodeDeploymentManager nodeDeploymentManager,
-                ClusterDeploymentManager clusterDeploymentManager,
-                EndpointRegistry endpointRegistry,
-                MetricsCollector metricsCollector,
-                MetricsScheduler metricsScheduler,
-                DeploymentMetricsCollector deploymentMetricsCollector,
-                DeploymentMetricsScheduler deploymentMetricsScheduler,
-                ControlLoop controlLoop,
-                SliceInvoker sliceInvoker,
-                InvocationHandler invocationHandler,
-                BlueprintService blueprintService,
-                MavenProtocolHandler mavenProtocolHandler,
-                Option<ManagementServer> managementServer,
-                Option<HttpRouter> httpRouter
-        ) implements AetherNode {
+        AetherNodeConfig config,
+        MessageRouter.MutableRouter router,
+        KVStore<AetherKey, AetherValue> kvStore,
+        SliceRegistry sliceRegistry,
+        SliceStore sliceStore,
+        RabiaNode<KVCommand<AetherKey>> clusterNode,
+        NodeDeploymentManager nodeDeploymentManager,
+        ClusterDeploymentManager clusterDeploymentManager,
+        EndpointRegistry endpointRegistry,
+        MetricsCollector metricsCollector,
+        MetricsScheduler metricsScheduler,
+        DeploymentMetricsCollector deploymentMetricsCollector,
+        DeploymentMetricsScheduler deploymentMetricsScheduler,
+        ControlLoop controlLoop,
+        SliceInvoker sliceInvoker,
+        InvocationHandler invocationHandler,
+        BlueprintService blueprintService,
+        MavenProtocolHandler mavenProtocolHandler,
+        Option<ManagementServer> managementServer,
+        Option<HttpRouter> httpRouter) implements AetherNode {
             private static final Logger log = LoggerFactory.getLogger(aetherNode.class);
 
             @Override
@@ -140,20 +138,17 @@ public NodeId self() {
             @Override
             public Promise<Unit> start() {
                 log.info("Starting Aether node {}", self());
-
                 // Configure SliceRuntime so slices can access runtime services
                 SliceRuntime.setSliceInvoker(sliceInvoker);
-
                 return clusterNode.start()
                                   .flatMap(_ -> managementServer.fold(
-                                          () -> Promise.success(Unit.unit()),
-                                          ManagementServer::start
-                                  ))
+                () -> Promise.success(Unit.unit()),
+                ManagementServer::start))
                                   .flatMap(_ -> httpRouter.fold(
-                                          () -> Promise.success(Unit.unit()),
-                                          HttpRouter::start
-                                  ))
-                                  .onSuccess(_ -> log.info("Aether node {} started successfully", self()));
+                () -> Promise.success(Unit.unit()),
+                HttpRouter::start))
+                                  .onSuccess(_ -> log.info("Aether node {} started successfully",
+                                                           self()));
             }
 
             @Override
@@ -163,17 +158,15 @@ public Promise<Unit> stop() {
                 metricsScheduler.stop();
                 deploymentMetricsScheduler.stop();
                 SliceRuntime.clear();
-                return httpRouter.fold(
-                               () -> Promise.success(Unit.unit()),
-                               HttpRouter::stop
-                       )
-                       .flatMap(_ -> managementServer.fold(
-                               () -> Promise.success(Unit.unit()),
-                               ManagementServer::stop
-                       ))
-                       .flatMap(_ -> sliceInvoker.stop())
-                       .flatMap(_ -> clusterNode.stop())
-                       .onSuccess(_ -> log.info("Aether node {} stopped", self()));
+                return httpRouter.fold(() -> Promise.success(Unit.unit()),
+                                       HttpRouter::stop)
+                                 .flatMap(_ -> managementServer.fold(
+                () -> Promise.success(Unit.unit()),
+                ManagementServer::stop))
+                                 .flatMap(_ -> sliceInvoker.stop())
+                                 .flatMap(_ -> clusterNode.stop())
+                                 .onSuccess(_ -> log.info("Aether node {} stopped",
+                                                          self()));
             }
 
             @Override
@@ -181,120 +174,134 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
                 return clusterNode.apply(commands);
             }
         }
-
         // Create KVStore (state machine for consensus)
         var kvStore = new KVStore<AetherKey, AetherValue>(router, serializer, deserializer);
-
         // Create slice management components
         var sliceRegistry = SliceRegistry.create();
         var sharedLibraryLoader = createSharedLibraryLoader(config);
-        var sliceStore = SliceStore.sliceStore(sliceRegistry, config.sliceAction().repositories(), sharedLibraryLoader);
-
+        var sliceStore = SliceStore.sliceStore(sliceRegistry,
+                                               config.sliceAction()
+                                                     .repositories(),
+                                               sharedLibraryLoader);
         // Create Rabia cluster node
         var nodeConfig = NodeConfig.nodeConfig(config.protocol(), config.topology());
         var clusterNode = RabiaNode.rabiaNode(nodeConfig, router, kvStore, serializer, deserializer);
-
         // Create invocation handler BEFORE deployment manager (needed for slice registration)
         var invocationHandler = InvocationHandler.invocationHandler(config.self(), clusterNode.network());
-
         // Create route registry for dynamic route registration (before node deployment manager)
         var routeRegistry = RouteRegistry.routeRegistry(clusterNode, kvStore);
-
         // Create deployment metrics components
         var deploymentMetricsCollector = DeploymentMetricsCollector.deploymentMetricsCollector(
-                config.self(), clusterNode.network()
-        );
+        config.self(), clusterNode.network());
         var deploymentMetricsScheduler = DeploymentMetricsScheduler.deploymentMetricsScheduler(
-                config.self(), clusterNode.network(), deploymentMetricsCollector
-        );
-
+        config.self(), clusterNode.network(), deploymentMetricsCollector);
         // Create deployment managers
         var nodeDeploymentManager = NodeDeploymentManager.nodeDeploymentManager(
-                config.self(), router, sliceStore, clusterNode, kvStore, invocationHandler, routeRegistry, config.sliceAction()
-        );
-
+        config.self(), router, sliceStore, clusterNode, kvStore, invocationHandler, routeRegistry, config.sliceAction());
         var clusterDeploymentManager = ClusterDeploymentManager.clusterDeploymentManager(
-                config.self(), clusterNode, kvStore, router
-        );
-
+        config.self(), clusterNode, kvStore, router);
         // Create endpoint registry
         var endpointRegistry = EndpointRegistry.endpointRegistry();
-
         // Create metrics components
         var metricsCollector = MetricsCollector.metricsCollector(config.self(), clusterNode.network());
         var metricsScheduler = MetricsScheduler.metricsScheduler(
-                config.self(), clusterNode.network(), metricsCollector
-        );
-
+        config.self(), clusterNode.network(), metricsCollector);
         // Create controller and control loop
         var controller = DecisionTreeController.decisionTreeController();
         var controlLoop = ControlLoop.controlLoop(
-                config.self(), controller, metricsCollector, clusterNode
-        );
-
+        config.self(), controller, metricsCollector, clusterNode);
         // Create slice invoker (invocationHandler already created above)
         var sliceInvoker = SliceInvoker.sliceInvoker(
-                config.self(), clusterNode.network(), endpointRegistry, invocationHandler, serializer, deserializer
-        );
-
+        config.self(), clusterNode.network(), endpointRegistry, invocationHandler, serializer, deserializer);
         // Create blueprint service using composite repository from configuration
         var blueprintService = BlueprintServiceImpl.blueprintService(
-                clusterNode, kvStore, compositeRepository(config.sliceAction().repositories())
-        );
-
+        clusterNode,
+        kvStore,
+        compositeRepository(config.sliceAction()
+                                  .repositories()));
         // Create DHT and artifact repository
         var dhtStorage = MemoryStorageEngine.create();
         var dhtRing = ConsistentHashRing.<String>create();
-        dhtRing.addNode(config.self().id());
-        var dhtNode = DHTNode.create(config.self().id(), dhtStorage, dhtRing, config.artifactRepo());
+        dhtRing.addNode(config.self()
+                              .id());
+        var dhtNode = DHTNode.create(config.self()
+                                           .id(),
+                                     dhtStorage,
+                                     dhtRing,
+                                     config.artifactRepo());
         var dhtClient = LocalDHTClient.create(dhtNode);
         var artifactStore = ArtifactStore.artifactStore(dhtClient);
         var mavenProtocolHandler = MavenProtocolHandler.mavenProtocolHandler(artifactStore);
-
         // Wire up message routing
-        configureRoutes(router, kvStore, nodeDeploymentManager, clusterDeploymentManager,
-                        endpointRegistry, routeRegistry, metricsCollector, metricsScheduler,
-                        deploymentMetricsCollector, deploymentMetricsScheduler,
-                        controlLoop, sliceInvoker, invocationHandler);
-
+        configureRoutes(router,
+                        kvStore,
+                        nodeDeploymentManager,
+                        clusterDeploymentManager,
+                        endpointRegistry,
+                        routeRegistry,
+                        metricsCollector,
+                        metricsScheduler,
+                        deploymentMetricsCollector,
+                        deploymentMetricsScheduler,
+                        controlLoop,
+                        sliceInvoker,
+                        invocationHandler);
         // Create HTTP router if configured
-        Option<HttpRouter> httpRouter = config.httpRouter().map(routerConfig -> {
-            // Create artifact resolver that parses slice ID strings to Artifact
-            SliceDispatcher.ArtifactResolver artifactResolver = sliceId ->
-                    Artifact.artifact(sliceId)
-                            .fold(cause -> null, artifact -> artifact);
-
-            return HttpRouter.httpRouter(
-                    routerConfig,
-                    routeRegistry,
-                    sliceInvoker,
-                    artifactResolver,
-                    serializer,
-                    deserializer
-            );
-        });
-
+        Option<HttpRouter> httpRouter = config.httpRouter()
+                                              .map(routerConfig -> {
+                                                       // Create artifact resolver that parses slice ID strings to Artifact
+        SliceDispatcher.ArtifactResolver artifactResolver = sliceId -> Artifact.artifact(sliceId)
+                                                                               .fold(cause -> null, artifact -> artifact);
+                                                       return HttpRouter.httpRouter(
+        routerConfig, routeRegistry, sliceInvoker, artifactResolver, serializer, deserializer);
+                                                   });
         // Create the node first (without management server reference)
         var node = new aetherNode(
-                config, router, kvStore, sliceRegistry, sliceStore,
-                clusterNode, nodeDeploymentManager, clusterDeploymentManager, endpointRegistry,
-                metricsCollector, metricsScheduler, deploymentMetricsCollector, deploymentMetricsScheduler,
-                controlLoop, sliceInvoker, invocationHandler,
-                blueprintService, mavenProtocolHandler, Option.empty(), httpRouter
-        );
-
+        config,
+        router,
+        kvStore,
+        sliceRegistry,
+        sliceStore,
+        clusterNode,
+        nodeDeploymentManager,
+        clusterDeploymentManager,
+        endpointRegistry,
+        metricsCollector,
+        metricsScheduler,
+        deploymentMetricsCollector,
+        deploymentMetricsScheduler,
+        controlLoop,
+        sliceInvoker,
+        invocationHandler,
+        blueprintService,
+        mavenProtocolHandler,
+        Option.empty(),
+        httpRouter);
         // Create management server if enabled
         if (config.managementPort() > 0) {
             var managementServer = ManagementServer.managementServer(config.managementPort(), () -> node);
             return new aetherNode(
-                    config, router, kvStore, sliceRegistry, sliceStore,
-                    clusterNode, nodeDeploymentManager, clusterDeploymentManager, endpointRegistry,
-                    metricsCollector, metricsScheduler, deploymentMetricsCollector, deploymentMetricsScheduler,
-                    controlLoop, sliceInvoker, invocationHandler,
-                    blueprintService, mavenProtocolHandler, Option.some(managementServer), httpRouter
-            );
+            config,
+            router,
+            kvStore,
+            sliceRegistry,
+            sliceStore,
+            clusterNode,
+            nodeDeploymentManager,
+            clusterDeploymentManager,
+            endpointRegistry,
+            metricsCollector,
+            metricsScheduler,
+            deploymentMetricsCollector,
+            deploymentMetricsScheduler,
+            controlLoop,
+            sliceInvoker,
+            invocationHandler,
+            blueprintService,
+            mavenProtocolHandler,
+            Option.some(managementServer),
+            httpRouter);
         }
-
         return node;
     }
 
@@ -316,48 +323,40 @@ private static void configureRoutes(MessageRouter.MutableRouter router,
         router.addRoute(KVStoreNotification.ValuePut.class, clusterDeploymentManager::onValuePut);
         router.addRoute(KVStoreNotification.ValuePut.class, endpointRegistry::onValuePut);
         router.addRoute(KVStoreNotification.ValuePut.class, routeRegistry::onValuePut);
-
         router.addRoute(KVStoreNotification.ValueRemove.class, nodeDeploymentManager::onValueRemove);
         router.addRoute(KVStoreNotification.ValueRemove.class, clusterDeploymentManager::onValueRemove);
         router.addRoute(KVStoreNotification.ValueRemove.class, endpointRegistry::onValueRemove);
         router.addRoute(KVStoreNotification.ValueRemove.class, routeRegistry::onValueRemove);
-
         // Quorum state notifications
         router.addRoute(QuorumStateNotification.class, nodeDeploymentManager::onQuorumStateChange);
-
         // Leader change notifications
         router.addRoute(LeaderNotification.LeaderChange.class, clusterDeploymentManager::onLeaderChange);
         router.addRoute(LeaderNotification.LeaderChange.class, metricsScheduler::onLeaderChange);
         router.addRoute(LeaderNotification.LeaderChange.class, controlLoop::onLeaderChange);
-
         // Topology change notifications
         router.addRoute(TopologyChangeNotification.class, clusterDeploymentManager::onTopologyChange);
         router.addRoute(TopologyChangeNotification.class, metricsScheduler::onTopologyChange);
         router.addRoute(TopologyChangeNotification.class, controlLoop::onTopologyChange);
-
         // Metrics messages
         router.addRoute(MetricsMessage.MetricsPing.class, metricsCollector::onMetricsPing);
         router.addRoute(MetricsMessage.MetricsPong.class, metricsCollector::onMetricsPong);
-
         // Deployment metrics messages
-        router.addRoute(DeploymentMetricsMessage.DeploymentMetricsPing.class, deploymentMetricsCollector::onDeploymentMetricsPing);
-        router.addRoute(DeploymentMetricsMessage.DeploymentMetricsPong.class, deploymentMetricsCollector::onDeploymentMetricsPong);
+        router.addRoute(DeploymentMetricsMessage.DeploymentMetricsPing.class,
+                        deploymentMetricsCollector::onDeploymentMetricsPing);
+        router.addRoute(DeploymentMetricsMessage.DeploymentMetricsPong.class,
+                        deploymentMetricsCollector::onDeploymentMetricsPong);
         router.addRoute(TopologyChangeNotification.class, deploymentMetricsCollector::onTopologyChange);
-
         // Deployment events (dispatched locally via MessageRouter)
         router.addRoute(DeploymentEvent.DeploymentStarted.class, deploymentMetricsCollector::onDeploymentStarted);
         router.addRoute(DeploymentEvent.StateTransition.class, deploymentMetricsCollector::onStateTransition);
         router.addRoute(DeploymentEvent.DeploymentCompleted.class, deploymentMetricsCollector::onDeploymentCompleted);
         router.addRoute(DeploymentEvent.DeploymentFailed.class, deploymentMetricsCollector::onDeploymentFailed);
-
         // Deployment metrics scheduler leader/topology notifications
         router.addRoute(LeaderNotification.LeaderChange.class, deploymentMetricsScheduler::onLeaderChange);
         router.addRoute(TopologyChangeNotification.class, deploymentMetricsScheduler::onTopologyChange);
-
         // Invocation messages
         router.addRoute(InvocationMessage.InvokeRequest.class, invocationHandler::onInvokeRequest);
         router.addRoute(InvocationMessage.InvokeResponse.class, sliceInvoker::onInvokeResponse);
-
         // KVStore local operations
         kvStore.configure(router);
     }
@@ -370,29 +369,27 @@ private static void configureRoutes(MessageRouter.MutableRouter router,
      */
     private static SharedLibraryClassLoader createSharedLibraryLoader(AetherNodeConfig config) {
         var log = LoggerFactory.getLogger(AetherNode.class);
-
-        return config.sliceAction().frameworkJarsPath()
-                .fold(
-                        // No framework path configured - use Application ClassLoader
-                        () -> {
-                            log.debug("No framework JARs path configured, using Application ClassLoader as parent");
-                            return new SharedLibraryClassLoader(AetherNode.class.getClassLoader());
-                        },
-                        // Framework path configured - try to create FrameworkClassLoader
-                        path -> FrameworkClassLoader.fromDirectory(path)
-                                .fold(
-                                        cause -> {
-                                            log.warn("Failed to create FrameworkClassLoader from {}: {}. " +
-                                                     "Falling back to Application ClassLoader.", path, cause.message());
-                                            return new SharedLibraryClassLoader(AetherNode.class.getClassLoader());
-                                        },
-                                        frameworkLoader -> {
-                                            log.info("Using FrameworkClassLoader with {} JARs as parent",
-                                                     frameworkLoader.getLoadedJars().size());
-                                            return new SharedLibraryClassLoader(frameworkLoader);
-                                        }
-                                )
-                );
+        return config.sliceAction()
+                     .frameworkJarsPath()
+                     .fold(() -> {
+                               log.debug("No framework JARs path configured, using Application ClassLoader as parent");
+                               return new SharedLibraryClassLoader(AetherNode.class.getClassLoader());
+                           },
+                           // Framework path configured - try to create FrameworkClassLoader
+        path -> FrameworkClassLoader.fromDirectory(path)
+                                    .fold(cause -> {
+                                              log.warn("Failed to create FrameworkClassLoader from {}: {}. "
+                                                       + "Falling back to Application ClassLoader.",
+                                                       path,
+                                                       cause.message());
+                                              return new SharedLibraryClassLoader(AetherNode.class.getClassLoader());
+                                          },
+                                          frameworkLoader -> {
+                                              log.info("Using FrameworkClassLoader with {} JARs as parent",
+                                                       frameworkLoader.getLoadedJars()
+                                                                      .size());
+                                              return new SharedLibraryClassLoader(frameworkLoader);
+                                          }));
     }
 
     /**
@@ -403,7 +400,8 @@ private static SharedLibraryClassLoader createSharedLibraryLoader(AetherNodeConf
      */
     private static Repository compositeRepository(java.util.List<Repository> repositories) {
         if (repositories.isEmpty()) {
-            return artifact -> org.pragmatica.lang.utils.Causes.cause("No repositories configured").promise();
+            return artifact -> org.pragmatica.lang.utils.Causes.cause("No repositories configured")
+                                  .promise();
         }
         // Use first repository (most configurations use a single repository)
         return repositories.getFirst();
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
index 85671b59..96bb9547 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
@@ -26,13 +26,12 @@
  * @param artifactRepo    DHT configuration for artifact repository (replication factor, 0 = full)
  */
 public record AetherNodeConfig(
-        TopologyConfig topology,
-        ProtocolConfig protocol,
-        SliceActionConfig sliceAction,
-        int managementPort,
-        Option<RouterConfig> httpRouter,
-        DHTConfig artifactRepo
-) {
+ TopologyConfig topology,
+ ProtocolConfig protocol,
+ SliceActionConfig sliceAction,
+ int managementPort,
+ Option<RouterConfig> httpRouter,
+ DHTConfig artifactRepo) {
     public static final int DEFAULT_MANAGEMENT_PORT = 8080;
     public static final int MANAGEMENT_DISABLED = 0;
 
@@ -43,14 +42,26 @@ private static SliceActionConfig defaultSliceConfig() {
     public static AetherNodeConfig aetherNodeConfig(NodeId self,
                                                     int port,
                                                     List<NodeInfo> coreNodes) {
-        return aetherNodeConfig(self, port, coreNodes, defaultSliceConfig(), DEFAULT_MANAGEMENT_PORT, Option.empty(), DHTConfig.DEFAULT);
+        return aetherNodeConfig(self,
+                                port,
+                                coreNodes,
+                                defaultSliceConfig(),
+                                DEFAULT_MANAGEMENT_PORT,
+                                Option.empty(),
+                                DHTConfig.DEFAULT);
     }
 
     public static AetherNodeConfig aetherNodeConfig(NodeId self,
                                                     int port,
                                                     List<NodeInfo> coreNodes,
                                                     SliceActionConfig sliceActionConfig) {
-        return aetherNodeConfig(self, port, coreNodes, sliceActionConfig, DEFAULT_MANAGEMENT_PORT, Option.empty(), DHTConfig.DEFAULT);
+        return aetherNodeConfig(self,
+                                port,
+                                coreNodes,
+                                sliceActionConfig,
+                                DEFAULT_MANAGEMENT_PORT,
+                                Option.empty(),
+                                DHTConfig.DEFAULT);
     }
 
     public static AetherNodeConfig aetherNodeConfig(NodeId self,
@@ -58,7 +69,13 @@ public static AetherNodeConfig aetherNodeConfig(NodeId self,
                                                     List<NodeInfo> coreNodes,
                                                     SliceActionConfig sliceActionConfig,
                                                     int managementPort) {
-        return aetherNodeConfig(self, port, coreNodes, sliceActionConfig, managementPort, Option.empty(), DHTConfig.DEFAULT);
+        return aetherNodeConfig(self,
+                                port,
+                                coreNodes,
+                                sliceActionConfig,
+                                managementPort,
+                                Option.empty(),
+                                DHTConfig.DEFAULT);
     }
 
     public static AetherNodeConfig aetherNodeConfig(NodeId self,
@@ -78,25 +95,29 @@ public static AetherNodeConfig aetherNodeConfig(NodeId self,
                                                     Option<RouterConfig> httpRouter,
                                                     DHTConfig artifactRepoConfig) {
         var topology = new TopologyConfig(
-                self,
-                timeSpan(5).seconds(),  // reconciliation interval
-                timeSpan(1).seconds(),  // ping interval
-                coreNodes
-        );
-
-        return new AetherNodeConfig(topology, ProtocolConfig.defaultConfig(), sliceActionConfig, managementPort, httpRouter, artifactRepoConfig);
+        self, timeSpan(5)
+             .seconds(), timeSpan(1)
+                        .seconds(), coreNodes);
+        return new AetherNodeConfig(topology,
+                                    ProtocolConfig.defaultConfig(),
+                                    sliceActionConfig,
+                                    managementPort,
+                                    httpRouter,
+                                    artifactRepoConfig);
     }
 
     public static AetherNodeConfig testConfig(NodeId self, int port, List<NodeInfo> coreNodes) {
         var topology = new TopologyConfig(
-                self,
-                timeSpan(500).millis(),
-                timeSpan(100).millis(),
-                coreNodes
-        );
-
+        self, timeSpan(500)
+             .millis(), timeSpan(100)
+                       .millis(), coreNodes);
         // Use full replication for tests - simpler, and tests typically have few nodes
-        return new AetherNodeConfig(topology, ProtocolConfig.testConfig(), defaultSliceConfig(), MANAGEMENT_DISABLED, Option.empty(), DHTConfig.FULL);
+        return new AetherNodeConfig(topology,
+                                    ProtocolConfig.testConfig(),
+                                    defaultSliceConfig(),
+                                    MANAGEMENT_DISABLED,
+                                    Option.empty(),
+                                    DHTConfig.FULL);
     }
 
     public NodeId self() {
diff --git a/pom.xml b/pom.xml
index f244a939..746e3706 100644
--- a/pom.xml
+++ b/pom.xml
@@ -20,7 +20,6 @@
     </licenses>
     <modules>
         <module>slice-annotations</module>
-        <module>http-server</module>
         <module>node</module>
         <module>slice-api</module>
         <module>slice</module>
diff --git a/slice-annotations/src/main/java/org/pragmatica/aether/slice/annotation/Slice.java b/slice-annotations/src/main/java/org/pragmatica/aether/slice/annotation/Slice.java
index 99abb19a..853c5884 100644
--- a/slice-annotations/src/main/java/org/pragmatica/aether/slice/annotation/Slice.java
+++ b/slice-annotations/src/main/java/org/pragmatica/aether/slice/annotation/Slice.java
@@ -56,7 +56,4 @@
  */
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
-public @interface Slice {
-    // Marker annotation - no parameters needed
-    // All metadata derived from interface structure
-}
+public @interface Slice {}
diff --git a/slice-api/src/main/java/org/pragmatica/aether/slice/Slice.java b/slice-api/src/main/java/org/pragmatica/aether/slice/Slice.java
index 294873f3..949679ac 100644
--- a/slice-api/src/main/java/org/pragmatica/aether/slice/Slice.java
+++ b/slice-api/src/main/java/org/pragmatica/aether/slice/Slice.java
@@ -8,14 +8,16 @@
 
 public interface Slice {
     default Promise<Unit> start() {
-        return Result.unitResult().async();
+        return Result.unitResult()
+                     .async();
     }
 
     default Promise<Unit> stop() {
-        return Result.unitResult().async();
+        return Result.unitResult()
+                     .async();
     }
 
-    List<SliceMethod<?, ?>> methods();
+    List<SliceMethod< ? , ? >> methods();
 
     /**
      * HTTP routes this slice handles.
diff --git a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceBridge.java b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceBridge.java
index 910d66fa..5756df44 100644
--- a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceBridge.java
+++ b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceBridge.java
@@ -41,7 +41,6 @@
  * @see Slice
  */
 public interface SliceBridge {
-
     /**
      * Invoke a method on the slice with serialized input.
      *
@@ -49,7 +48,7 @@ public interface SliceBridge {
      * @param input      Serialized input parameter (Fury format)
      * @return Promise resolving to serialized response (Fury format)
      */
-    Promise<byte[]> invoke(String methodName, byte[] input);
+    Promise<byte[] > invoke(String methodName, byte[] input);
 
     /**
      * Start the slice lifecycle.
diff --git a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceMethod.java b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceMethod.java
index 2ea9a8bb..a54d88fc 100644
--- a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceMethod.java
+++ b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceMethod.java
@@ -4,7 +4,9 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.type.TypeToken;
 
-public record SliceMethod<R, T>(MethodName name, Fn1<Promise<R>, T> method, TypeToken<R> returnType,
+public record SliceMethod<R, T>(MethodName name,
+                                Fn1<Promise<R>, T> method,
+                                TypeToken<R> returnType,
                                 TypeToken<T> parameterType) implements Fn1<Promise<R>, T> {
     @Override
     public Promise<R> apply(T param1) {
diff --git a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRoute.java b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRoute.java
index f28a1b28..fabc44a1 100644
--- a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRoute.java
+++ b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRoute.java
@@ -13,12 +13,10 @@
  * }</pre>
  */
 public record SliceRoute(
-    String httpMethod,
-    String pathPattern,
-    String methodName,
-    List<RouteBinding> bindings
-) {
-
+ String httpMethod,
+ String pathPattern,
+ String methodName,
+ List<RouteBinding> bindings) {
     /**
      * Create a GET route.
      */
@@ -61,8 +59,11 @@ public sealed interface RouteBinding {
         String paramName();
 
         record Body(String paramName) implements RouteBinding {}
+
         record PathVar(String paramName) implements RouteBinding {}
+
         record QueryVar(String paramName) implements RouteBinding {}
+
         record Header(String paramName, String headerName) implements RouteBinding {}
     }
 
diff --git a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRuntime.java b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRuntime.java
index 3d3b116f..4967384a 100644
--- a/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRuntime.java
+++ b/slice-api/src/main/java/org/pragmatica/aether/slice/SliceRuntime.java
@@ -21,12 +21,9 @@
  * acceptable for ambient runtime services that are set once at startup.
  */
 public final class SliceRuntime {
-
     private static volatile SliceInvokerFacade sliceInvoker;
 
-    private SliceRuntime() {
-        // Static utility class
-    }
+    private SliceRuntime() {}
 
     /**
      * Get the SliceInvoker for inter-slice communication.
@@ -37,8 +34,8 @@ private SliceRuntime() {
     public static SliceInvokerFacade sliceInvoker() {
         var invoker = sliceInvoker;
         if (invoker == null) {
-            throw new IllegalStateException("SliceInvoker not configured. " +
-                "This typically means the slice is being used outside of the Aether runtime.");
+            throw new IllegalStateException("SliceInvoker not configured. "
+                                            + "This typically means the slice is being used outside of the Aether runtime.");
         }
         return invoker;
     }
@@ -88,11 +85,9 @@ public interface SliceInvokerFacade {
          * @param <R>            Response type
          * @return Promise resolving to the response
          */
-        <R> org.pragmatica.lang.Promise<R> invokeAndWait(
-            String sliceArtifact,
-            String methodName,
-            Object request,
-            Class<R> responseType
-        );
+        <R> org.pragmatica.lang.Promise<R> invokeAndWait(String sliceArtifact,
+                                                         String methodName,
+                                                         Object request,
+                                                         Class<R> responseType);
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/artifact/Artifact.java b/slice/src/main/java/org/pragmatica/aether/artifact/Artifact.java
index a9043d74..c3d49fc0 100644
--- a/slice/src/main/java/org/pragmatica/aether/artifact/Artifact.java
+++ b/slice/src/main/java/org/pragmatica/aether/artifact/Artifact.java
@@ -6,17 +6,18 @@
 import org.pragmatica.lang.utils.Causes;
 
 public record Artifact(GroupId groupId, ArtifactId artifactId, Version version) {
-
-    private static final Fn1<Cause, String> INVALID_FORMAT = Causes.forOneValue("Invalid artifact format %s");
+    private static final Fn1<Cause, String>INVALID_FORMAT = Causes.forOneValue("Invalid artifact format %s");
 
     public static Result<Artifact> artifact(String artifactString) {
         var parts = artifactString.split(":", 3);
         if (parts.length != 3) {
-            return INVALID_FORMAT.apply(artifactString).result();
+            return INVALID_FORMAT.apply(artifactString)
+                                 .result();
         }
-
-        return Result.all(GroupId.groupId(parts[0]), ArtifactId.artifactId(parts[1]), Version.version(parts[2])).map(
-                Artifact::artifact);
+        return Result.all(GroupId.groupId(parts[0]),
+                          ArtifactId.artifactId(parts[1]),
+                          Version.version(parts[2]))
+                     .map(Artifact::artifact);
     }
 
     public static Artifact artifact(GroupId groupId, ArtifactId artifactId, Version version) {
diff --git a/slice/src/main/java/org/pragmatica/aether/artifact/Version.java b/slice/src/main/java/org/pragmatica/aether/artifact/Version.java
index 02b3e126..a0c51ad0 100644
--- a/slice/src/main/java/org/pragmatica/aether/artifact/Version.java
+++ b/slice/src/main/java/org/pragmatica/aether/artifact/Version.java
@@ -15,25 +15,22 @@
 public record Version(int major, int minor, int patch, String qualifier) {
     public static Result<Version> version(String versionString) {
         var parts = versionString.split("\\.");
-
         if (parts.length != 3) {
-            return FORMAT_ERROR.apply(versionString).result();
+            return FORMAT_ERROR.apply(versionString)
+                               .result();
         }
-
         int dashIndex = parts[2].indexOf('-');
-
-        if (dashIndex > 0 && (dashIndex + 1) == parts[2].length()) { // Only dash at the end of the string
-            return FORMAT_ERROR.apply(versionString).result();
+        if (dashIndex > 0 && (dashIndex + 1) == parts[2].length()) {
+            // Only dash at the end of the string
+            return FORMAT_ERROR.apply(versionString)
+                               .result();
         }
-
         var qualifier = (dashIndex > 0)
                         ? Option.option(parts[2].substring(dashIndex + 1))
                         : Option.<String>none();
-
         if (dashIndex > 0) {
             parts[2] = parts[2].substring(0, dashIndex);
         }
-
         return Result.all(Number.parseInt(parts[0]),
                           Number.parseInt(parts[1]),
                           Number.parseInt(parts[2]),
@@ -43,7 +40,6 @@ public static Result<Version> version(String versionString) {
 
     public static Result<Version> version(int major, int minor, int patch, Option<String> qualifier) {
         var innerQualifier = qualifier.or("");
-
         return Result.all(ensure(major, Is::greaterThanOrEqualTo, 0),
                           ensure(minor, Is::greaterThanOrEqualTo, 0),
                           ensure(patch, Is::greaterThanOrEqualTo, 0),
@@ -62,6 +58,7 @@ public String withQualifier() {
     }
 
     private static final Pattern QUALIFIER_PATTERN = Pattern.compile("^[\\-a-zA-Z0-9-_.]*$");
-    private static final Fn1<Cause, String> FORMAT_ERROR = Causes.forOneValue(
-            "Invalid version format: {0}, expected {major}.{minor}.{patch}[-{suffix}]");
+
+    private static final Fn1<Cause, String>FORMAT_ERROR = Causes.forOneValue(
+    "Invalid version format: {0}, expected {major}.{minor}.{patch}[-{suffix}]");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java b/slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java
index 61c9b494..d64c3155 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/FrameworkClassLoader.java
@@ -2,8 +2,6 @@
 
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.net.URL;
@@ -14,6 +12,9 @@
 import java.util.List;
 import java.util.stream.Stream;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * ClassLoader for framework classes shared by all slices.
  * <p>
@@ -55,7 +56,6 @@
  * @see SliceClassLoader
  */
 public class FrameworkClassLoader extends URLClassLoader {
-
     private static final Logger log = LoggerFactory.getLogger(FrameworkClassLoader.class);
 
     private final List<String> loadedJars = new ArrayList<>();
@@ -84,24 +84,24 @@ public FrameworkClassLoader(URL[] frameworkJars) {
      */
     public static Result<FrameworkClassLoader> fromDirectory(Path frameworkDir) {
         if (!Files.isDirectory(frameworkDir)) {
-            return Causes.cause("Framework directory does not exist: " + frameworkDir).result();
+            return Causes.cause("Framework directory does not exist: " + frameworkDir)
+                         .result();
         }
-
         try (Stream<Path> jarStream = Files.list(frameworkDir)) {
-            var jarUrls = jarStream
-                    .filter(path -> path.toString().endsWith(".jar"))
-                    .map(FrameworkClassLoader::toUrl)
-                    .filter(Result::isSuccess)
-                    .map(Result::unwrap)
-                    .toArray(URL[]::new);
-
+            var jarUrls = jarStream.filter(path -> path.toString()
+                                                       .endsWith(".jar"))
+                                   .map(FrameworkClassLoader::toUrl)
+                                   .filter(Result::isSuccess)
+                                   .map(Result::unwrap)
+                                   .toArray(URL[]::new);
             if (jarUrls.length == 0) {
-                return Causes.cause("No JAR files found in framework directory: " + frameworkDir).result();
+                return Causes.cause("No JAR files found in framework directory: " + frameworkDir)
+                             .result();
             }
-
             return Result.success(new FrameworkClassLoader(jarUrls));
         } catch (IOException e) {
-            return Causes.cause("Failed to scan framework directory: " + e.getMessage()).result();
+            return Causes.cause("Failed to scan framework directory: " + e.getMessage())
+                         .result();
         }
     }
 
@@ -114,21 +114,19 @@ public static Result<FrameworkClassLoader> fromDirectory(Path frameworkDir) {
     public static Result<FrameworkClassLoader> fromJars(Path... jarPaths) {
         var urls = new ArrayList<URL>();
         var errors = new ArrayList<String>();
-
         for (var jarPath : jarPaths) {
             if (!Files.exists(jarPath)) {
                 errors.add("JAR not found: " + jarPath);
                 continue;
             }
             toUrl(jarPath)
-                    .onSuccess(urls::add)
-                    .onFailure(cause -> errors.add(cause.message()));
+            .onSuccess(urls::add)
+            .onFailure(cause -> errors.add(cause.message()));
         }
-
         if (!errors.isEmpty()) {
-            return Causes.cause("Failed to load framework JARs: " + String.join(", ", errors)).result();
+            return Causes.cause("Failed to load framework JARs: " + String.join(", ", errors))
+                         .result();
         }
-
         return Result.success(new FrameworkClassLoader(urls.toArray(URL[]::new)));
     }
 
@@ -150,14 +148,16 @@ public void close() throws IOException {
 
     private static Result<URL> toUrl(Path path) {
         return Result.lift(
-                Causes::fromThrowable,
-                () -> path.toUri().toURL()
-        );
+        Causes::fromThrowable,
+        () -> path.toUri()
+                  .toURL());
     }
 
     private static String extractJarName(URL url) {
         var path = url.getPath();
         var lastSlash = path.lastIndexOf('/');
-        return lastSlash >= 0 ? path.substring(lastSlash + 1) : path;
+        return lastSlash >= 0
+               ? path.substring(lastSlash + 1)
+               : path;
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SharedLibraryClassLoader.java b/slice/src/main/java/org/pragmatica/aether/slice/SharedLibraryClassLoader.java
index f4bd3614..75a6d706 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SharedLibraryClassLoader.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SharedLibraryClassLoader.java
@@ -5,8 +5,6 @@
 import org.pragmatica.aether.slice.dependency.CompatibilityResult;
 import org.pragmatica.aether.slice.dependency.VersionPattern;
 import org.pragmatica.lang.Option;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.net.URL;
@@ -14,6 +12,9 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * ClassLoader for shared dependencies across all slices.
  * <p>
@@ -34,7 +35,6 @@
  * @see CompatibilityResult
  */
 public class SharedLibraryClassLoader extends URLClassLoader {
-
     private static final Logger log = LoggerFactory.getLogger(SharedLibraryClassLoader.class);
 
     /**
@@ -72,11 +72,9 @@ public Option<CompatibilityResult> checkCompatibility(ArtifactDependency depende
     public Option<CompatibilityResult> checkCompatibility(String groupId, String artifactId, VersionPattern required) {
         var key = artifactKey(groupId, artifactId);
         var loadedVersion = loadedArtifacts.get(key);
-
         if (loadedVersion == null) {
             return Option.empty();
         }
-
         return Option.some(CompatibilityResult.check(loadedVersion, required));
     }
 
@@ -93,16 +91,16 @@ public Option<CompatibilityResult> checkCompatibility(String groupId, String art
      */
     public synchronized void addArtifact(String groupId, String artifactId, Version version, URL jarUrl) {
         var key = artifactKey(groupId, artifactId);
-
         if (loadedArtifacts.containsKey(key)) {
             log.warn("Artifact {} already loaded with version {}, ignoring request to load version {}",
-                     key, loadedArtifacts.get(key).withQualifier(), version.withQualifier());
+                     key,
+                     loadedArtifacts.get(key)
+                                    .withQualifier(),
+                     version.withQualifier());
             return;
         }
-
         addURL(jarUrl);
         loadedArtifacts.put(key, version);
-
         log.debug("Added shared artifact {}:{} from {}", key, version.withQualifier(), jarUrl);
     }
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceActionConfig.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceActionConfig.java
index a237b75c..4a102b37 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceActionConfig.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceActionConfig.java
@@ -30,19 +30,29 @@
  *                            pragmatica-lite, slice-api, and serialization classes.
  *                            If empty, uses Application ClassLoader (no isolation).
  */
-public record SliceActionConfig(TimeSpan loadingTimeout, TimeSpan activatingTimeout, TimeSpan deactivatingTimeout,
-                                TimeSpan unloadingTimeout, TimeSpan startStopTimeout, List<Repository> repositories,
-                                SerializerFactoryProvider serializerProvider, Option<Path> frameworkJarsPath) {
+public record SliceActionConfig(TimeSpan loadingTimeout,
+                                TimeSpan activatingTimeout,
+                                TimeSpan deactivatingTimeout,
+                                TimeSpan unloadingTimeout,
+                                TimeSpan startStopTimeout,
+                                List<Repository> repositories,
+                                SerializerFactoryProvider serializerProvider,
+                                Option<Path> frameworkJarsPath) {
     public static SliceActionConfig defaultConfiguration() {
         return defaultConfiguration(null);
     }
 
     public static SliceActionConfig defaultConfiguration(SerializerFactoryProvider serializerProvider) {
-        return new SliceActionConfig(timeSpan(2).minutes(),
-                                     timeSpan(1).minutes(),
-                                     timeSpan(30).seconds(),
-                                     timeSpan(2).minutes(),
-                                     timeSpan(5).seconds(),
+        return new SliceActionConfig(timeSpan(2)
+                                     .minutes(),
+                                     timeSpan(1)
+                                     .minutes(),
+                                     timeSpan(30)
+                                     .seconds(),
+                                     timeSpan(2)
+                                     .minutes(),
+                                     timeSpan(5)
+                                     .seconds(),
                                      List.of(localRepository()),
                                      serializerProvider,
                                      Option.empty());
@@ -55,12 +65,18 @@ public static SliceActionConfig defaultConfiguration(SerializerFactoryProvider s
      * @param frameworkJarsPath  Path to directory containing framework JARs
      * @return Configuration with isolation enabled
      */
-    public static SliceActionConfig withIsolation(SerializerFactoryProvider serializerProvider, Path frameworkJarsPath) {
-        return new SliceActionConfig(timeSpan(2).minutes(),
-                                     timeSpan(1).minutes(),
-                                     timeSpan(30).seconds(),
-                                     timeSpan(2).minutes(),
-                                     timeSpan(5).seconds(),
+    public static SliceActionConfig withIsolation(SerializerFactoryProvider serializerProvider,
+                                                  Path frameworkJarsPath) {
+        return new SliceActionConfig(timeSpan(2)
+                                     .minutes(),
+                                     timeSpan(1)
+                                     .minutes(),
+                                     timeSpan(30)
+                                     .seconds(),
+                                     timeSpan(2)
+                                     .minutes(),
+                                     timeSpan(5)
+                                     .seconds(),
                                      List.of(localRepository()),
                                      serializerProvider,
                                      Option.option(frameworkJarsPath));
@@ -72,10 +88,11 @@ public Result<TimeSpan> timeoutFor(SliceState state) {
             case SliceState.ACTIVATING -> Result.success(activatingTimeout);
             case SliceState.DEACTIVATING -> Result.success(deactivatingTimeout);
             case SliceState.UNLOADING -> Result.success(unloadingTimeout);
-            default -> NO_TIMEOUT_CONFIGURED.apply(state).result();
+            default -> NO_TIMEOUT_CONFIGURED.apply(state)
+                                            .result();
         };
     }
 
-    private static final Fn1<Cause, SliceState> NO_TIMEOUT_CONFIGURED = Causes.forOneValue(
-            "No timeout configured for state: %s");
+    private static final Fn1<Cause, SliceState>NO_TIMEOUT_CONFIGURED = Causes.forOneValue(
+    "No timeout configured for state: %s");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
index d244a7cd..92be896c 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
@@ -39,20 +39,17 @@
  * @see Slice
  */
 public record SliceBridgeImpl(
-        Artifact artifact,
-        Slice slice,
-        Map<String, InternalMethod> methodMap,
-        SerializerFactory serializerFactory
-) implements SliceBridge {
-
+ Artifact artifact,
+ Slice slice,
+ Map<String, InternalMethod> methodMap,
+ SerializerFactory serializerFactory) implements SliceBridge {
     /**
      * Internal method descriptor containing type information for serialization.
      */
     public record InternalMethod(
-            SliceMethod<?, ?> method,
-            TypeToken<?> parameterType,
-            TypeToken<?> returnType
-    ) {}
+    SliceMethod< ? , ? > method,
+    TypeToken< ? > parameterType,
+    TypeToken< ? > returnType) {}
 
     /**
      * Create a SliceBridgeImpl from a Slice instance.
@@ -62,35 +59,32 @@ public record InternalMethod(
      * @param serializerFactory Factory for serialization
      * @return SliceBridgeImpl wrapping the slice
      */
-    public static SliceBridgeImpl sliceBridge(
-            Artifact artifact,
-            Slice slice,
-            SerializerFactory serializerFactory
-    ) {
-        var methodMap = slice.methods().stream()
-                .collect(java.util.stream.Collectors.toMap(
-                        m -> m.name().name(),
-                        m -> new InternalMethod(m, m.parameterType(), m.returnType())
-                ));
+    public static SliceBridgeImpl sliceBridge(Artifact artifact,
+                                              Slice slice,
+                                              SerializerFactory serializerFactory) {
+        var methodMap = slice.methods()
+                             .stream()
+                             .collect(java.util.stream.Collectors.toMap(
+        m -> m.name()
+              .name(),
+        m -> new InternalMethod(m,
+                                m.parameterType(),
+                                m.returnType())));
         return new SliceBridgeImpl(artifact, slice, Map.copyOf(methodMap), serializerFactory);
     }
 
     @Override
-    public Promise<byte[]> invoke(String methodName, byte[] input) {
+    public Promise<byte[] > invoke(String methodName, byte[] input) {
         return lookupMethod(methodName)
-                .async()
-                .flatMap(internalMethod ->
-                        acquireSerializationPair()
-                                .flatMap(pair ->
-                                        deserializeInput(pair.deserializer(), input, internalMethod.parameterType())
-                                                .flatMap(parameter ->
-                                                        invokeMethod(internalMethod.method(), parameter)
-                                                                .flatMap(response ->
-                                                                        serializeResponse(pair.serializer(), response)
-                                                                )
-                                                )
-                                )
-                );
+               .async()
+               .flatMap(internalMethod -> acquireSerializationPair()
+                                          .flatMap(pair -> deserializeInput(pair.deserializer(),
+                                                                            input,
+                                                                            internalMethod.parameterType())
+                                                           .flatMap(parameter -> invokeMethod(internalMethod.method(),
+                                                                                              parameter)
+                                                                                 .flatMap(response -> serializeResponse(pair.serializer(),
+                                                                                                                        response)))));
     }
 
     @Override
@@ -111,15 +105,15 @@ public List<String> methodNames() {
     private Result<InternalMethod> lookupMethod(String methodName) {
         var method = methodMap.get(methodName);
         return method != null
-                ? Result.success(method)
-                : METHOD_NOT_FOUND.apply(methodName).result();
+               ? Result.success(method)
+               : METHOD_NOT_FOUND.apply(methodName)
+                                 .result();
     }
 
     private Promise<SerializationPair> acquireSerializationPair() {
-        return Promise.all(
-                serializerFactory.serializer(),
-                serializerFactory.deserializer()
-        ).map(SerializationPair::new);
+        return Promise.all(serializerFactory.serializer(),
+                           serializerFactory.deserializer())
+                      .map(SerializationPair::new);
     }
 
     private record SerializationPair(Serializer serializer, Deserializer deserializer) {}
@@ -127,27 +121,21 @@ private record SerializationPair(Serializer serializer, Deserializer deserialize
     @SuppressWarnings("unchecked")
     private <T> Promise<T> deserializeInput(Deserializer deserializer, byte[] input, TypeToken<T> typeToken) {
         return Promise.lift(
-                Causes::fromThrowable,
-                () -> (T) deserializer.decode(input)
-        );
+        Causes::fromThrowable, () -> (T) deserializer.decode(input));
     }
 
     @SuppressWarnings("unchecked")
-    private <T, R> Promise<R> invokeMethod(SliceMethod<?, ?> method, T parameter) {
-        return Promise.lift(
-                Causes::fromThrowable,
-                () -> ((SliceMethod<R, T>) method).apply(parameter)
-        ).flatMap(promise -> promise);
+    private <T, R> Promise<R> invokeMethod(SliceMethod< ? , ? > method, T parameter) {
+        return Promise.lift(Causes::fromThrowable,
+                            () -> ((SliceMethod<R, T>) method).apply(parameter))
+                      .flatMap(promise -> promise);
     }
 
-    private <R> Promise<byte[]> serializeResponse(Serializer serializer, R response) {
+    private <R> Promise<byte[] > serializeResponse(Serializer serializer, R response) {
         return Promise.lift(
-                Causes::fromThrowable,
-                () -> serializer.encode(response)
-        );
+        Causes::fromThrowable, () -> serializer.encode(response));
     }
 
     // Error constants
-    private static final Fn1<Cause, String> METHOD_NOT_FOUND =
-            Causes.forOneValue("Method not found: {0}");
+    private static final Fn1<Cause, String>METHOD_NOT_FOUND = Causes.forOneValue("Method not found: {0}");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceClassLoader.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceClassLoader.java
index 33c40a3a..b74db2ae 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceClassLoader.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceClassLoader.java
@@ -25,7 +25,6 @@
  * @see SharedLibraryClassLoader
  */
 public class SliceClassLoader extends URLClassLoader {
-
     private static final String JAVA_PREFIX = "java.";
     private static final String JAVAX_PREFIX = "javax.";
     private static final String JDK_PREFIX = "jdk.";
@@ -42,22 +41,20 @@ public SliceClassLoader(URL[] urls, ClassLoader parent) {
     }
 
     @Override
-    protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
+    protected Class< ? > loadClass(String name, boolean resolve) throws ClassNotFoundException {
         synchronized (getClassLoadingLock(name)) {
             // Check if already loaded
             var loaded = findLoadedClass(name);
             if (loaded != null) {
                 return loaded;
             }
-
             // Parent-first for JDK classes (mandatory - cannot be overridden)
             if (isJdkClass(name)) {
                 return super.loadClass(name, resolve);
             }
-
             // Child-first for everything else (slice isolation)
             // This allows slice code and conflict overrides to shadow parent classes
-            try {
+            try{
                 var clazz = findClass(name);
                 if (resolve) {
                     resolveClass(clazz);
@@ -75,10 +72,7 @@ protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundE
      * These classes cannot be overridden in child classloaders.
      */
     private boolean isJdkClass(String name) {
-        return name.startsWith(JAVA_PREFIX)
-               || name.startsWith(JAVAX_PREFIX)
-               || name.startsWith(JDK_PREFIX)
-               || name.startsWith(SUN_PREFIX);
+        return name.startsWith(JAVA_PREFIX) || name.startsWith(JAVAX_PREFIX) || name.startsWith(JDK_PREFIX) || name.startsWith(SUN_PREFIX);
     }
 
     @Override
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
index c791671f..4b4cdf06 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
@@ -25,7 +25,6 @@
  * Loading will fail if manifest is missing or invalid.
  */
 public interface SliceManifest {
-
     String SLICE_ARTIFACT_ATTR = "Slice-Artifact";
     String SLICE_CLASS_ATTR = "Slice-Class";
 
@@ -37,7 +36,9 @@ public interface SliceManifest {
      * @return SliceManifestInfo or error if manifest is missing/invalid
      */
     static Result<SliceManifestInfo> read(URL jarUrl) {
-        return Result.lift(Causes::fromThrowable, () -> readManifest(jarUrl)).flatMap(SliceManifest::parseManifest);
+        return Result.lift(Causes::fromThrowable,
+                           () -> readManifest(jarUrl))
+                     .flatMap(SliceManifest::parseManifest);
     }
 
     /**
@@ -48,7 +49,8 @@ static Result<SliceManifestInfo> read(URL jarUrl) {
      * @return SliceManifestInfo or error if manifest is missing/invalid
      */
     static Result<SliceManifestInfo> readFromClassLoader(ClassLoader classLoader) {
-        return Result.lift(Causes::fromThrowable, () -> classLoader.getResource(JarFile.MANIFEST_NAME))
+        return Result.lift(Causes::fromThrowable,
+                           () -> classLoader.getResource(JarFile.MANIFEST_NAME))
                      .flatMap(url -> url == null
                                      ? MANIFEST_NOT_FOUND.result()
                                      : readManifestFromUrl(url))
@@ -64,7 +66,6 @@ private static Manifest readManifest(URL jarUrl) throws IOException {
         if (path.contains("!")) {
             path = path.substring(0, path.indexOf("!"));
         }
-
         try (var jarFile = new JarFile(path)) {
             var manifest = jarFile.getManifest();
             if (manifest == null) {
@@ -75,27 +76,26 @@ private static Manifest readManifest(URL jarUrl) throws IOException {
     }
 
     private static Result<Manifest> readManifestFromUrl(URL manifestUrl) {
-        return Result.lift(Causes::fromThrowable, () -> {
-            try (var is = manifestUrl.openStream()) {
-                return new Manifest(is);
-            }
-        });
+        return Result.lift(Causes::fromThrowable,
+                           () -> {
+                               try (var is = manifestUrl.openStream()) {
+                               return new Manifest(is);
+                           }
+                           });
     }
 
     private static Result<SliceManifestInfo> parseManifest(Manifest manifest) {
         var mainAttrs = manifest.getMainAttributes();
-
         var artifactStr = mainAttrs.getValue(SLICE_ARTIFACT_ATTR);
         if (artifactStr == null || artifactStr.isBlank()) {
             return MISSING_ARTIFACT_ATTR.result();
         }
-
         var sliceClass = mainAttrs.getValue(SLICE_CLASS_ATTR);
         if (sliceClass == null || sliceClass.isBlank()) {
             return MISSING_CLASS_ATTR.result();
         }
-
-        return Artifact.artifact(artifactStr).map(artifact -> new SliceManifestInfo(artifact, sliceClass));
+        return Artifact.artifact(artifactStr)
+                       .map(artifact -> new SliceManifestInfo(artifact, sliceClass));
     }
 
     /**
@@ -104,12 +104,10 @@ private static Result<SliceManifestInfo> parseManifest(Manifest manifest) {
     record SliceManifestInfo(Artifact artifact, String sliceClassName) {}
 
     // Error causes
-    Fn1<Cause, String> MANIFEST_NOT_FOUND_FN = Causes.forOneValue("Manifest not found in JAR: %s");
+    Fn1<Cause, String>MANIFEST_NOT_FOUND_FN = Causes.forOneValue("Manifest not found in JAR: %s");
     Cause MANIFEST_NOT_FOUND = Causes.cause("Manifest not found in ClassLoader resources");
-    Cause MISSING_ARTIFACT_ATTR = Causes.cause("Missing required manifest attribute: "
-                                               + SLICE_ARTIFACT_ATTR
+    Cause MISSING_ARTIFACT_ATTR = Causes.cause("Missing required manifest attribute: " + SLICE_ARTIFACT_ATTR
                                                + ". Slice JARs must declare artifact coordinates in manifest.");
-    Cause MISSING_CLASS_ATTR = Causes.cause("Missing required manifest attribute: "
-                                            + SLICE_CLASS_ATTR
+    Cause MISSING_CLASS_ATTR = Causes.cause("Missing required manifest attribute: " + SLICE_CLASS_ATTR
                                             + ". Slice JARs must declare the main slice class in manifest.");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceState.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceState.java
index e7fb7f72..475d71d0 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceState.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceState.java
@@ -16,44 +16,40 @@
 // TODO: rework timeout handling, perhaps use existing values as defaults
 public enum SliceState {
     LOAD,
-    LOADING(timeSpan(2).minutes()),
+    LOADING(timeSpan(2)
+            .minutes()),
     LOADED,
     ACTIVATE,
-    ACTIVATING(timeSpan(1).minutes()),
+    ACTIVATING(timeSpan(1)
+               .minutes()),
     ACTIVE,
     DEACTIVATE,
     DEACTIVATING(
-            timeSpan(30).seconds()),
+    timeSpan(30)
+    .seconds()),
     FAILED,
     UNLOAD,
-    UNLOADING(timeSpan(2).minutes());
-
+    UNLOADING(timeSpan(2)
+              .minutes());
     private final Option<TimeSpan> timeout;
-
     SliceState() {
         this(Option.none());
     }
-
     SliceState(TimeSpan timeout) {
         this(Option.some(timeout));
     }
-
     SliceState(Option<TimeSpan> timeout) {
         this.timeout = timeout;
     }
-
     public Option<TimeSpan> timeout() {
         return timeout;
     }
-
     public boolean hasTimeout() {
         return timeout.isPresent();
     }
-
     public boolean isTransitional() {
         return hasTimeout();
     }
-
     public Set<SliceState> validTransitions() {
         return switch (this) {
             case LOAD -> Set.of(LOADING);
@@ -68,11 +64,10 @@ public Set<SliceState> validTransitions() {
             case UNLOADING -> Set.of();
         };
     }
-
     public boolean canTransitionTo(SliceState target) {
-        return validTransitions().contains(target);
+        return validTransitions()
+               .contains(target);
     }
-
     public Result<SliceState> nextState() {
         return switch (this) {
             case LOAD -> Result.success(LOADING);
@@ -87,9 +82,7 @@ public Result<SliceState> nextState() {
             case UNLOADING -> TERMINAL_STATE_ERROR.result();
         };
     }
-
-    private static final Map<String, SliceState> STRING_TO_STATE;
-
+    private static final Map<String, SliceState>STRING_TO_STATE;
     static {
         var map = new HashMap<String, SliceState>();
         map.put("LOAD", LOAD);
@@ -105,12 +98,10 @@ public Result<SliceState> nextState() {
         map.put("UNLOADING", UNLOADING);
         STRING_TO_STATE = Map.copyOf(map);
     }
-
     public static Result<SliceState> sliceState(String stateString) {
         return Option.option(STRING_TO_STATE.get(stateString.toUpperCase()))
                      .toResult(UNKNOWN_STATE.apply(stateString));
     }
-
-    private static final Fn1<Cause, String> UNKNOWN_STATE = Causes.forOneValue("Unknown slice state [{}]");
+    private static final Fn1<Cause, String>UNKNOWN_STATE = Causes.forOneValue("Unknown slice state [{}]");
     private static final Cause TERMINAL_STATE_ERROR = Causes.cause("Cannot transition from UNLOADING terminal state");
-}
\ No newline at end of file
+}
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceStore.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceStore.java
index 9861fa74..cbfeb3c8 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceStore.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceStore.java
@@ -9,7 +9,6 @@
 import java.util.List;
 
 public interface SliceStore {
-
     /**
      * Create a new SliceStore instance with shared library classloader.
      *
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceStoreImpl.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceStoreImpl.java
index d55aa482..0df5eef4 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceStoreImpl.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceStoreImpl.java
@@ -10,8 +10,6 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 import java.net.URL;
@@ -19,6 +17,9 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Production implementation of SliceStore that manages slice lifecycle.
  * <p>
@@ -34,14 +35,15 @@
  * Thread-safe: Uses ConcurrentHashMap for entry tracking.
  */
 public interface SliceStoreImpl {
-
     enum EntryState {
-        LOADED, ACTIVE
+        LOADED,
+        ACTIVE
     }
 
-    record LoadedSliceEntry(Artifact artifact, Slice sliceInstance, SliceClassLoader classLoader,
+    record LoadedSliceEntry(Artifact artifact,
+                            Slice sliceInstance,
+                            SliceClassLoader classLoader,
                             EntryState state) implements SliceStore.LoadedSlice {
-
         @Override
         public Slice slice() {
             return sliceInstance;
@@ -58,10 +60,10 @@ static SliceStore sliceStore(SliceRegistry registry,
         return new SliceStoreRecord(registry, repositories, sharedLibraryLoader, new ConcurrentHashMap<>());
     }
 
-    record SliceStoreRecord(SliceRegistry registry, List<Repository> repositories,
+    record SliceStoreRecord(SliceRegistry registry,
+                            List<Repository> repositories,
                             SharedLibraryClassLoader sharedLibraryLoader,
                             Map<Artifact, LoadedSliceEntry> entries) implements SliceStore {
-
         private static final Logger log = LoggerFactory.getLogger(SliceStoreRecord.class);
 
         @Override
@@ -71,25 +73,35 @@ public Promise<LoadedSlice> loadSlice(Artifact artifact) {
                 log.debug("Slice {} already loaded", artifact);
                 return Promise.success(existing);
             }
-
             log.info("Loading slice {}", artifact);
-            return locateInRepositories(artifact).flatMap(location -> loadFromLocation(artifact));
+            return locateInRepositories(artifact)
+                   .flatMap(location -> loadFromLocation(artifact));
         }
 
         private Promise<LoadedSlice> loadFromLocation(Artifact artifact) {
-            return DependencyResolver.resolve(artifact, compositeRepository(), registry, sharedLibraryLoader)
-                    .map(slice -> {
-                        // Extract the classloader from the slice's class
-                        var sliceClassLoader = slice.getClass().getClassLoader();
-                        if (sliceClassLoader instanceof SliceClassLoader scl) {
-                            return createEntry(artifact, slice, scl);
-                        }
-                        // Fallback - create a minimal classloader entry
-                        log.warn("Slice {} loaded with unexpected classloader type: {}. Resource access may be limited.",
-                                 artifact, sliceClassLoader.getClass().getName());
-                        return createEntry(artifact, slice, new SliceClassLoader(new URL[0], sharedLibraryLoader));
-                    })
-                    .onFailure(cause -> log.error("Failed to load slice {}: {}", artifact, cause.message()));
+            return DependencyResolver.resolve(artifact,
+                                              compositeRepository(),
+                                              registry,
+                                              sharedLibraryLoader)
+                                     .map(slice -> {
+                                              // Extract the classloader from the slice's class
+            var sliceClassLoader = slice.getClass()
+                                        .getClassLoader();
+                                              if (sliceClassLoader instanceof SliceClassLoader scl) {
+                                              return createEntry(artifact, slice, scl);
+                                          }
+                                              // Fallback - create a minimal classloader entry
+            log.warn("Slice {} loaded with unexpected classloader type: {}. Resource access may be limited.",
+                     artifact,
+                     sliceClassLoader.getClass()
+                                     .getName());
+                                              return createEntry(artifact,
+                                                                 slice,
+                                                                 new SliceClassLoader(new URL[0], sharedLibraryLoader));
+                                          })
+                                     .onFailure(cause -> log.error("Failed to load slice {}: {}",
+                                                                   artifact,
+                                                                   cause.message()));
         }
 
         private LoadedSlice createEntry(Artifact artifact, Slice slice, SliceClassLoader classLoader) {
@@ -103,23 +115,24 @@ private LoadedSlice createEntry(Artifact artifact, Slice slice, SliceClassLoader
         public Promise<LoadedSlice> activateSlice(Artifact artifact) {
             var entry = entries.get(artifact);
             if (entry == null) {
-                return SLICE_NOT_LOADED.apply(artifact.asString()).promise();
+                return SLICE_NOT_LOADED.apply(artifact.asString())
+                                       .promise();
             }
-
             if (entry.state() == EntryState.ACTIVE) {
                 log.debug("Slice {} already active", artifact);
                 return Promise.success(entry);
             }
-
             if (entry.state() != EntryState.LOADED) {
-                return INVALID_STATE_TRANSITION.apply(entry.state() + " → ACTIVE").promise();
+                return INVALID_STATE_TRANSITION.apply(entry.state() + " → ACTIVE")
+                                               .promise();
             }
-
             log.info("Activating slice {}", artifact);
             return entry.sliceInstance()
                         .start()
                         .map(_ -> transitionToActive(artifact, entry))
-                        .onFailure(cause -> log.error("Failed to activate slice {}: {}", artifact, cause.message()));
+                        .onFailure(cause -> log.error("Failed to activate slice {}: {}",
+                                                      artifact,
+                                                      cause.message()));
         }
 
         private LoadedSlice transitionToActive(Artifact artifact, LoadedSliceEntry entry) {
@@ -133,23 +146,24 @@ private LoadedSlice transitionToActive(Artifact artifact, LoadedSliceEntry entry
         public Promise<LoadedSlice> deactivateSlice(Artifact artifact) {
             var entry = entries.get(artifact);
             if (entry == null) {
-                return SLICE_NOT_LOADED.apply(artifact.asString()).promise();
+                return SLICE_NOT_LOADED.apply(artifact.asString())
+                                       .promise();
             }
-
             if (entry.state() == EntryState.LOADED) {
                 log.debug("Slice {} already deactivated", artifact);
                 return Promise.success(entry);
             }
-
             if (entry.state() != EntryState.ACTIVE) {
-                return INVALID_STATE_TRANSITION.apply(entry.state() + " → LOADED").promise();
+                return INVALID_STATE_TRANSITION.apply(entry.state() + " → LOADED")
+                                               .promise();
             }
-
             log.info("Deactivating slice {}", artifact);
             return entry.sliceInstance()
                         .stop()
                         .map(_ -> transitionToLoaded(artifact, entry))
-                        .onFailure(cause -> log.error("Failed to deactivate slice {}: {}", artifact, cause.message()));
+                        .onFailure(cause -> log.error("Failed to deactivate slice {}: {}",
+                                                      artifact,
+                                                      cause.message()));
         }
 
         private LoadedSlice transitionToLoaded(Artifact artifact, LoadedSliceEntry entry) {
@@ -166,18 +180,16 @@ public Promise<Unit> unloadSlice(Artifact artifact) {
                 log.debug("Slice {} not loaded, nothing to unload", artifact);
                 return Promise.success(Unit.unit());
             }
-
             log.info("Unloading slice {}", artifact);
-
             Promise<Unit> deactivatePromise = entry.state() == EntryState.ACTIVE
                                               ? entry.sliceInstance()
                                                      .stop()
                                               : Promise.success(Unit.unit());
-
-            return deactivatePromise.map(_ -> cleanup(artifact, entry)).onFailure(cause -> log.error(
-                    "Failed to unload slice {}: {}",
-                    artifact,
-                    cause.message()));
+            return deactivatePromise.map(_ -> cleanup(artifact, entry))
+                                    .onFailure(cause -> log.error(
+            "Failed to unload slice {}: {}",
+            artifact,
+            cause.message()));
         }
 
         private Unit cleanup(Artifact artifact, LoadedSliceEntry entry) {
@@ -195,7 +207,10 @@ public Promise<Unit> unload(Artifact artifact) {
 
         @Override
         public List<LoadedSlice> loaded() {
-            return entries.values().stream().map(entry -> (LoadedSlice) entry).toList();
+            return entries.values()
+                          .stream()
+                          .map(entry -> (LoadedSlice) entry)
+                          .toList();
         }
 
         private Promise<Location> locateInRepositories(Artifact artifact) {
@@ -204,15 +219,15 @@ private Promise<Location> locateInRepositories(Artifact artifact) {
 
         private Promise<Location> locateInRepositories(Artifact artifact, List<Repository> remainingRepos) {
             if (remainingRepos.isEmpty()) {
-                return ARTIFACT_NOT_FOUND.apply(artifact.asString()).promise();
+                return ARTIFACT_NOT_FOUND.apply(artifact.asString())
+                                         .promise();
             }
-
             var repo = remainingRepos.getFirst();
             var rest = remainingRepos.subList(1, remainingRepos.size());
-
             return repo.locate(artifact)
                        .await()
-                       .fold(_ -> locateInRepositories(artifact, rest), location -> Promise.success(location));
+                       .fold(_ -> locateInRepositories(artifact, rest),
+                             location -> Promise.success(location));
         }
 
         private Repository compositeRepository() {
@@ -220,19 +235,19 @@ private Repository compositeRepository() {
         }
 
         private void closeClassLoader(SliceClassLoader classLoader) {
-            try {
+            try{
                 classLoader.close();
             } catch (IOException e) {
                 log.warn("Failed to close ClassLoader: {}", e.getMessage());
             }
         }
 
-        private static final Fn1<Cause, String> SLICE_NOT_LOADED = Causes.forOneValue("Slice not loaded: %s");
+        private static final Fn1<Cause, String>SLICE_NOT_LOADED = Causes.forOneValue("Slice not loaded: %s");
 
-        private static final Fn1<Cause, String> INVALID_STATE_TRANSITION = Causes.forOneValue(
-                "Invalid state transition: %s");
+        private static final Fn1<Cause, String>INVALID_STATE_TRANSITION = Causes.forOneValue(
+        "Invalid state transition: %s");
 
-        private static final Fn1<Cause, String> ARTIFACT_NOT_FOUND = Causes.forOneValue(
-                "Artifact not found in any repository: %s");
+        private static final Fn1<Cause, String>ARTIFACT_NOT_FOUND = Causes.forOneValue(
+        "Artifact not found in any repository: %s");
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintExpander.java b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintExpander.java
index 356d7af8..4a1d2d9d 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintExpander.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintExpander.java
@@ -26,7 +26,6 @@
  * Transitive dependencies get instances=1, isDependency=true.
  */
 public interface BlueprintExpander {
-
     /**
      * Expand a Blueprint using Repository to load dependencies.
      *
@@ -51,26 +50,28 @@ static Promise<ExpandedBlueprint> expand(Blueprint blueprint, Repository reposit
      */
     static Promise<ExpandedBlueprint> expand(Blueprint blueprint, DependencyLoader loader) {
         var explicitSlices = collectExplicitSlices(blueprint);
-
-        return resolveDependencies(explicitSlices, loader).flatMap(allDeps -> buildExpandedBlueprint(blueprint,
-                                                                                                     explicitSlices,
-                                                                                                     allDeps));
+        return resolveDependencies(explicitSlices, loader)
+               .flatMap(allDeps -> buildExpandedBlueprint(blueprint, explicitSlices, allDeps));
     }
 
     private static Promise<ExpandedBlueprint> buildExpandedBlueprint(Blueprint blueprint,
                                                                      Map<Artifact, SliceSpec> explicitSlices,
                                                                      Map<Artifact, Set<Artifact>> allDeps) {
         var graph = buildDependencyGraph(allDeps);
-        return checkCycles(graph).map(_ -> buildLoadOrder(explicitSlices, allDeps, graph))
-                                 .map(loadOrder -> ExpandedBlueprint.expandedBlueprint(blueprint.id(), loadOrder))
-                                 .async();
+        return checkCycles(graph)
+               .map(_ -> buildLoadOrder(explicitSlices, allDeps, graph))
+               .map(loadOrder -> ExpandedBlueprint.expandedBlueprint(blueprint.id(),
+                                                                     loadOrder))
+               .async();
     }
 
     /**
      * Collect explicit slices from Blueprint into a map.
      */
     private static Map<Artifact, SliceSpec> collectExplicitSlices(Blueprint blueprint) {
-        return blueprint.slices().stream().collect(Collectors.toUnmodifiableMap(SliceSpec::artifact, spec -> spec));
+        return blueprint.slices()
+                        .stream()
+                        .collect(Collectors.toUnmodifiableMap(SliceSpec::artifact, spec -> spec));
     }
 
     /**
@@ -81,11 +82,11 @@ private static Promise<Map<Artifact, Set<Artifact>>> resolveDependencies(Map<Art
                                                                              DependencyLoader loader) {
         var processed = new HashSet<Artifact>();
         var dependencies = new HashMap<Artifact, Set<Artifact>>();
-
         return resolveDependenciesRecursive(explicitSlices.keySet(),
                                             loader,
                                             processed,
-                                            dependencies).map(_ -> Collections.unmodifiableMap(dependencies));
+                                            dependencies)
+               .map(_ -> Collections.unmodifiableMap(dependencies));
     }
 
     /**
@@ -99,11 +100,9 @@ private static Promise<Unit> resolveDependenciesRecursive(Set<Artifact> artifact
                                  .filter(artifact -> !processed.contains(artifact))
                                  .peek(processed::add)
                                  .toList();
-
         if (toProcess.isEmpty()) {
             return Promise.success(Unit.unit());
         }
-
         return processArtifactsSequentially(toProcess, loader, processed, dependencies, 0);
     }
 
@@ -118,14 +117,9 @@ private static Promise<Unit> processArtifactsSequentially(List<Artifact> artifac
         if (index >= artifacts.size()) {
             return Promise.success(Unit.unit());
         }
-
         var artifact = artifacts.get(index);
         return loader.loadDependencies(artifact)
-                     .flatMap(deps -> storeDepsAndRecurse(artifact,
-                                                          deps,
-                                                          loader,
-                                                          processed,
-                                                          dependencies))
+                     .flatMap(deps -> storeDepsAndRecurse(artifact, deps, loader, processed, dependencies))
                      .flatMap(_ -> processArtifactsSequentially(artifacts, loader, processed, dependencies, index + 1));
     }
 
@@ -166,8 +160,9 @@ private static List<ResolvedSlice> buildLoadOrder(Map<Artifact, SliceSpec> expli
                                                       Map<String, List<String>> graph) {
         var allArtifacts = collectAllArtifacts(explicitSlices.keySet(), allDependencies);
         var sorted = topologicalSort(allArtifacts, allDependencies);
-
-        return sorted.stream().map(artifact -> createResolvedSlice(artifact, explicitSlices)).toList();
+        return sorted.stream()
+                     .map(artifact -> createResolvedSlice(artifact, explicitSlices))
+                     .toList();
     }
 
     /**
@@ -176,7 +171,8 @@ private static List<ResolvedSlice> buildLoadOrder(Map<Artifact, SliceSpec> expli
     private static Set<Artifact> collectAllArtifacts(Set<Artifact> explicit,
                                                      Map<Artifact, Set<Artifact>> dependencies) {
         var all = new HashSet<>(explicit);
-        dependencies.values().forEach(all::addAll);
+        dependencies.values()
+                    .forEach(all::addAll);
         return all;
     }
 
@@ -186,13 +182,10 @@ private static Set<Artifact> collectAllArtifacts(Set<Artifact> explicit,
     private static List<Artifact> topologicalSort(Set<Artifact> artifacts, Map<Artifact, Set<Artifact>> dependencies) {
         var visited = new HashSet<Artifact>();
         var result = new ArrayList<Artifact>();
-
-        artifacts.stream().filter(artifact -> !visited.contains(artifact)).forEach(artifact -> topologicalSortDfs(
-                artifact,
-                dependencies,
-                visited,
-                result));
-
+        artifacts.stream()
+                 .filter(artifact -> !visited.contains(artifact))
+                 .forEach(artifact -> topologicalSortDfs(
+        artifact, dependencies, visited, result));
         return result;
     }
 
@@ -204,12 +197,11 @@ private static void topologicalSortDfs(Artifact artifact,
                                            Set<Artifact> visited,
                                            List<Artifact> result) {
         visited.add(artifact);
-
-        dependencies.getOrDefault(artifact, Set.of())
+        dependencies.getOrDefault(artifact,
+                                  Set.of())
                     .stream()
                     .filter(dep -> !visited.contains(dep))
                     .forEach(dep -> topologicalSortDfs(dep, dependencies, visited, result));
-
         result.add(artifact);
     }
 
@@ -220,7 +212,7 @@ private static ResolvedSlice createResolvedSlice(Artifact artifact, Map<Artifact
         var spec = explicitSlices.get(artifact);
         if (spec != null) {
             return ResolvedSlice.resolvedSlice(artifact, spec.instances(), false);
-        } else {
+        }else {
             return ResolvedSlice.resolvedSlice(artifact, 1, true);
         }
     }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintId.java b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintId.java
index 4e236cd9..5d3b0f87 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintId.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintId.java
@@ -13,16 +13,16 @@
 
 public record BlueprintId(String name, Version version) {
     private static final Pattern NAME_PATTERN = Pattern.compile("^[a-z][a-z0-9-]*$");
-    private static final Fn1<Cause, String> INVALID_FORMAT = Causes.forOneValue("Invalid blueprint ID format: %s");
+    private static final Fn1<Cause, String>INVALID_FORMAT = Causes.forOneValue("Invalid blueprint ID format: %s");
 
     public static Result<BlueprintId> blueprintId(String input) {
         var parts = input.split(":", 2);
-
         if (parts.length != 2) {
-            return INVALID_FORMAT.apply(input).result();
+            return INVALID_FORMAT.apply(input)
+                                 .result();
         }
-
-        return Result.all(ensure(parts[0], Is::matches, NAME_PATTERN), Version.version(parts[1]))
+        return Result.all(ensure(parts[0], Is::matches, NAME_PATTERN),
+                          Version.version(parts[1]))
                      .map(BlueprintId::blueprintId);
     }
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintParser.java b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintParser.java
index d6dff0b9..0efedcf3 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintParser.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/BlueprintParser.java
@@ -35,28 +35,28 @@
  * </pre>
  */
 public interface BlueprintParser {
-    Fn1<Cause, String> FILE_ERROR = Causes.forOneValue("Failed to read file: %s");
+    Fn1<Cause, String>FILE_ERROR = Causes.forOneValue("Failed to read file: %s");
     Cause MISSING_ID = Causes.cause("Missing blueprint id");
-    Fn1<Cause, String> INVALID_SLICE = Causes.forOneValue("Invalid slice definition: %s");
-    Fn1<Cause, String> MISSING_ARTIFACT = Causes.forOneValue("Missing artifact for slice: %s");
-    Fn1<Cause, String> INVALID_ARTIFACT = Causes.forOneValue("Invalid artifact format: %s");
+    Fn1<Cause, String>INVALID_SLICE = Causes.forOneValue("Invalid slice definition: %s");
+    Fn1<Cause, String>MISSING_ARTIFACT = Causes.forOneValue("Missing artifact for slice: %s");
+    Fn1<Cause, String>INVALID_ARTIFACT = Causes.forOneValue("Invalid artifact format: %s");
 
     static Result<Blueprint> parse(String dsl) {
         if (dsl == null || dsl.isBlank()) {
             return MISSING_ID.result();
         }
-
         return TomlParser.parse(dsl)
-            .mapError(cause -> Causes.cause("TOML parse error: " + cause.message()))
-            .flatMap(BlueprintParser::parseDocument);
+                         .mapError(cause -> Causes.cause("TOML parse error: " + cause.message()))
+                         .flatMap(BlueprintParser::parseDocument);
     }
 
     static Result<Blueprint> parseFile(Path path) {
-        try {
+        try{
             var content = Files.readString(path);
             return parse(content);
         } catch (IOException e) {
-            return FILE_ERROR.apply(e.getMessage()).result();
+            return FILE_ERROR.apply(e.getMessage())
+                             .result();
         }
     }
 
@@ -66,14 +66,13 @@ private static Result<Blueprint> parseDocument(TomlDocument doc) {
         if (idOpt.isEmpty()) {
             return MISSING_ID.result();
         }
-
         return BlueprintId.blueprintId(idOpt.unwrap())
-            .flatMap(id -> parseSlices(doc).map(slices -> Blueprint.blueprint(id, slices)));
+                          .flatMap(id -> parseSlices(doc)
+                                         .map(slices -> Blueprint.blueprint(id, slices)));
     }
 
     private static Result<List<SliceSpec>> parseSlices(TomlDocument doc) {
         var slices = new ArrayList<SliceSpec>();
-
         // Find all sections starting with "slices."
         for (var sectionName : doc.sectionNames()) {
             if (sectionName.startsWith("slices.")) {
@@ -85,20 +84,19 @@ private static Result<List<SliceSpec>> parseSlices(TomlDocument doc) {
                 slices.add(result.unwrap());
             }
         }
-
         return Result.success(slices);
     }
 
     private static Result<SliceSpec> parseSliceSection(TomlDocument doc, String section, String sliceName) {
         var artifactOpt = doc.getString(section, "artifact");
         if (artifactOpt.isEmpty()) {
-            return MISSING_ARTIFACT.apply(sliceName).result();
+            return MISSING_ARTIFACT.apply(sliceName)
+                                   .result();
         }
-
-        var instanceCount = doc.getInt(section, "instances").or(1);
-
+        var instanceCount = doc.getInt(section, "instances")
+                               .or(1);
         return Artifact.artifact(artifactOpt.unwrap())
-            .mapError(_ -> INVALID_ARTIFACT.apply(artifactOpt.unwrap()))
-            .flatMap(artifact -> SliceSpec.sliceSpec(artifact, instanceCount));
+                       .mapError(_ -> INVALID_ARTIFACT.apply(artifactOpt.unwrap()))
+                       .flatMap(artifact -> SliceSpec.sliceSpec(artifact, instanceCount));
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/ExpanderError.java b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/ExpanderError.java
index 7526d5f4..67c851d2 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/ExpanderError.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/ExpanderError.java
@@ -7,7 +7,6 @@
  * Errors that can occur during blueprint expansion.
  */
 public sealed interface ExpanderError extends Cause {
-
     /**
      * Artifact mismatch between requested and manifest-declared artifact.
      */
@@ -18,10 +17,7 @@ public static ArtifactMismatch cause(Artifact requested, Artifact declared) {
 
         @Override
         public String message() {
-            return "Artifact mismatch: requested "
-                   + requested.asString()
-                   + " but JAR manifest declares "
-                   + declared.asString();
+            return "Artifact mismatch: requested " + requested.asString() + " but JAR manifest declares " + declared.asString();
         }
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/RepositoryDependencyLoader.java b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/RepositoryDependencyLoader.java
index 3cf81c54..c1656bd1 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/blueprint/RepositoryDependencyLoader.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/blueprint/RepositoryDependencyLoader.java
@@ -20,35 +20,40 @@
  * Default DependencyLoader implementation using Repository.
  */
 public interface RepositoryDependencyLoader {
-
     static DependencyLoader repositoryDependencyLoader(Repository repository) {
-        return artifact -> repository.locate(artifact).flatMap(location -> loadDependenciesFromJar(artifact, location));
+        return artifact -> repository.locate(artifact)
+                                     .flatMap(location -> loadDependenciesFromJar(artifact, location));
     }
 
     private static Promise<Set<Artifact>> loadDependenciesFromJar(Artifact artifact, Location location) {
-        return SliceManifest.read(location.url()).flatMap(manifest -> validateManifest(artifact, manifest)).flatMap(
-                manifest -> loadDependencies(manifest, location.url())).async();
+        return SliceManifest.read(location.url())
+                            .flatMap(manifest -> validateManifest(artifact, manifest))
+                            .flatMap(manifest -> loadDependencies(manifest,
+                                                                  location.url()))
+                            .async();
     }
 
     private static Result<SliceManifest.SliceManifestInfo> validateManifest(Artifact expected,
                                                                             SliceManifest.SliceManifestInfo manifest) {
-        if (!manifest.artifact().equals(expected)) {
-            return ExpanderError.ArtifactMismatch.cause(expected, manifest.artifact()).result();
+        if (!manifest.artifact()
+                     .equals(expected)) {
+            return ExpanderError.ArtifactMismatch.cause(expected,
+                                                        manifest.artifact())
+                                .result();
         }
         return Result.success(manifest);
     }
 
     private static Result<Set<Artifact>> loadDependencies(SliceManifest.SliceManifestInfo manifest, URL jarUrl) {
         var classLoader = new SliceClassLoader(new URL[]{jarUrl}, RepositoryDependencyLoader.class.getClassLoader());
-
-        return SliceDependencies.load(manifest.sliceClassName(), classLoader)
+        return SliceDependencies.load(manifest.sliceClassName(),
+                                      classLoader)
                                 .flatMap(RepositoryDependencyLoader::convertToArtifacts);
     }
 
     private static Result<Set<Artifact>> convertToArtifacts(List<DependencyDescriptor> descriptors) {
         return Result.allOf(toArtifacts(descriptors))
                      .map(Set::copyOf);
-
     }
 
     private static Stream<Result<Artifact>> toArtifacts(List<DependencyDescriptor> descriptors) {
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactDependency.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactDependency.java
index b5da12b3..bad62b2d 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactDependency.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactDependency.java
@@ -20,11 +20,9 @@
  * @param versionPattern Version pattern for compatibility checking
  */
 public record ArtifactDependency(
-        String groupId,
-        String artifactId,
-        VersionPattern versionPattern
-) {
-
+ String groupId,
+ String artifactId,
+ VersionPattern versionPattern) {
     /**
      * Parse artifact dependency from string.
      * <p>
@@ -35,50 +33,47 @@ public record ArtifactDependency(
      */
     public static Result<ArtifactDependency> parse(String line) {
         var trimmed = line.trim();
-
         if (trimmed.isEmpty()) {
             return EMPTY_LINE.result();
         }
-
         if (trimmed.startsWith("#")) {
             return COMMENT_LINE.result();
         }
-
         if (trimmed.startsWith("[")) {
             return SECTION_HEADER.result();
         }
-
         // Find the last colon - version pattern comes after it
         // This handles cases where version pattern itself may contain special chars
         var lastColon = trimmed.lastIndexOf(':');
         if (lastColon <= 0) {
-            return INVALID_FORMAT.apply(line).result();
+            return INVALID_FORMAT.apply(line)
+                                 .result();
         }
-
-        var versionStr = trimmed.substring(lastColon + 1).trim();
+        var versionStr = trimmed.substring(lastColon + 1)
+                                .trim();
         var groupArtifact = trimmed.substring(0, lastColon);
-
         // Find the colon separating groupId from artifactId
         var colonPos = groupArtifact.lastIndexOf(':');
         if (colonPos <= 0) {
-            return INVALID_FORMAT.apply(line).result();
+            return INVALID_FORMAT.apply(line)
+                                 .result();
         }
-
-        var groupId = groupArtifact.substring(0, colonPos).trim();
-        var artifactId = groupArtifact.substring(colonPos + 1).trim();
-
+        var groupId = groupArtifact.substring(0, colonPos)
+                                   .trim();
+        var artifactId = groupArtifact.substring(colonPos + 1)
+                                      .trim();
         if (groupId.isEmpty()) {
-            return EMPTY_GROUP_ID.apply(line).result();
+            return EMPTY_GROUP_ID.apply(line)
+                                 .result();
         }
-
         if (artifactId.isEmpty()) {
-            return EMPTY_ARTIFACT_ID.apply(line).result();
+            return EMPTY_ARTIFACT_ID.apply(line)
+                                    .result();
         }
-
         if (versionStr.isEmpty()) {
-            return EMPTY_VERSION.apply(line).result();
+            return EMPTY_VERSION.apply(line)
+                                .result();
         }
-
         return VersionPattern.parse(versionStr)
                              .map(pattern -> new ArtifactDependency(groupId, artifactId, pattern));
     }
@@ -101,12 +96,8 @@ public String artifactKey() {
     static final Cause EMPTY_LINE = Causes.cause("Dependency line is empty");
     static final Cause COMMENT_LINE = Causes.cause("Dependency line is a comment");
     static final Cause SECTION_HEADER = Causes.cause("Line is a section header");
-    private static final Fn1<Cause, String> INVALID_FORMAT =
-            Causes.forOneValue("Invalid artifact dependency format: %s. Expected groupId:artifactId:versionPattern");
-    private static final Fn1<Cause, String> EMPTY_GROUP_ID =
-            Causes.forOneValue("Empty group ID in dependency: %s");
-    private static final Fn1<Cause, String> EMPTY_ARTIFACT_ID =
-            Causes.forOneValue("Empty artifact ID in dependency: %s");
-    private static final Fn1<Cause, String> EMPTY_VERSION =
-            Causes.forOneValue("Empty version pattern in dependency: %s");
+    private static final Fn1<Cause, String>INVALID_FORMAT = Causes.forOneValue("Invalid artifact dependency format: %s. Expected groupId:artifactId:versionPattern");
+    private static final Fn1<Cause, String>EMPTY_GROUP_ID = Causes.forOneValue("Empty group ID in dependency: %s");
+    private static final Fn1<Cause, String>EMPTY_ARTIFACT_ID = Causes.forOneValue("Empty artifact ID in dependency: %s");
+    private static final Fn1<Cause, String>EMPTY_VERSION = Causes.forOneValue("Empty version pattern in dependency: %s");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactMapper.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactMapper.java
index ecce4195..52c6ead0 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactMapper.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/ArtifactMapper.java
@@ -25,7 +25,6 @@
  * </ul>
  */
 public interface ArtifactMapper {
-
     /**
      * Convert a fully qualified class name and version to artifact coordinates.
      *
@@ -37,18 +36,16 @@ public interface ArtifactMapper {
     static Result<Artifact> toArtifact(String className, String version) {
         var lastDot = className.lastIndexOf('.');
         if (lastDot <= 0) {
-            return INVALID_CLASS_NAME.apply(className).result();
+            return INVALID_CLASS_NAME.apply(className)
+                                     .result();
         }
-
         var groupId = className.substring(0, lastDot);
         var simpleName = className.substring(lastDot + 1);
-
         if (simpleName.isEmpty() || !Character.isUpperCase(simpleName.charAt(0))) {
-            return INVALID_CLASS_NAME.apply(className).result();
+            return INVALID_CLASS_NAME.apply(className)
+                                     .result();
         }
-
         var artifactId = toKebabCase(simpleName);
-
         return Artifact.artifact(groupId + ":" + artifactId + ":" + version);
     }
 
@@ -76,8 +73,10 @@ static Result<Artifact> toArtifact(DependencyDescriptor descriptor) {
      * @return class name (e.g., "org.example.UserService")
      */
     static String toClassName(Artifact artifact) {
-        var groupId = artifact.groupId().id();
-        var artifactId = artifact.artifactId().id();
+        var groupId = artifact.groupId()
+                              .id();
+        var artifactId = artifact.artifactId()
+                                 .id();
         var simpleName = toPascalCase(artifactId);
         return groupId + "." + simpleName;
     }
@@ -109,13 +108,10 @@ private static String toKebabCase(String pascalCase) {
         if (pascalCase == null || pascalCase.isEmpty()) {
             return pascalCase;
         }
-
         var result = new StringBuilder();
         var chars = pascalCase.toCharArray();
-
-        for (int i = 0; i < chars.length; i++) {
+        for (int i = 0; i < chars.length; i++ ) {
             var c = chars[i];
-
             if (Character.isUpperCase(c)) {
                 // Add hyphen before uppercase (except at start)
                 if (i > 0) {
@@ -123,17 +119,15 @@ private static String toKebabCase(String pascalCase) {
                     // (handles cases like "XMLParser" → "xml-parser")
                     var prevUpper = Character.isUpperCase(chars[i - 1]);
                     var nextLower = (i + 1 < chars.length) && Character.isLowerCase(chars[i + 1]);
-
                     if (!prevUpper || nextLower) {
                         result.append('-');
                     }
                 }
                 result.append(Character.toLowerCase(c));
-            } else {
+            }else {
                 result.append(c);
             }
         }
-
         return result.toString();
     }
 
@@ -150,21 +144,18 @@ private static String toPascalCase(String kebabCase) {
         if (kebabCase == null || kebabCase.isEmpty()) {
             return kebabCase;
         }
-
         var result = new StringBuilder();
         var capitalizeNext = true;
-
         for (var c : kebabCase.toCharArray()) {
             if (c == '-') {
                 capitalizeNext = true;
-            } else if (capitalizeNext) {
+            }else if (capitalizeNext) {
                 result.append(Character.toUpperCase(c));
                 capitalizeNext = false;
-            } else {
+            }else {
                 result.append(c);
             }
         }
-
         return result.toString();
     }
 
@@ -183,6 +174,6 @@ private static String extractVersion(VersionPattern pattern) {
         };
     }
 
-    Fn1<Cause, String> INVALID_CLASS_NAME = Causes.forOneValue(
-            "Invalid class name format: %s. Expected fully qualified name like 'org.example.ClassName'");
+    Fn1<Cause, String>INVALID_CLASS_NAME = Causes.forOneValue(
+    "Invalid class name format: %s. Expected fully qualified name like 'org.example.ClassName'");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/CompatibilityResult.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/CompatibilityResult.java
index 3ffd2144..fef300c9 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/CompatibilityResult.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/CompatibilityResult.java
@@ -9,7 +9,6 @@
  * SharedLibraryClassLoader to determine if the loaded version is compatible.
  */
 public sealed interface CompatibilityResult {
-
     /**
      * The loaded version is compatible with the requested pattern.
      * The slice can use the already-loaded version.
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyCycleDetector.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyCycleDetector.java
index 35989113..8fbf704f 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyCycleDetector.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyCycleDetector.java
@@ -14,7 +14,6 @@
  * A cycle exists if we encounter a node that is currently being visited (in the current DFS path).
  */
 public interface DependencyCycleDetector {
-
     /**
      * Check for circular dependencies in the dependency graph.
      * <p>
@@ -28,7 +27,6 @@ static Result<Void> checkForCycles(Map<String, List<String>> dependencies) {
         var visited = new HashSet<String>();
         var visiting = new HashSet<String>();
         var path = new ArrayList<String>();
-
         for (var node : dependencies.keySet()) {
             if (!visited.contains(node)) {
                 var cycleResult = dfs(node, dependencies, visited, visiting, path);
@@ -37,7 +35,6 @@ static Result<Void> checkForCycles(Map<String, List<String>> dependencies) {
                 }
             }
         }
-
         return Result.success(null);
     }
 
@@ -48,16 +45,14 @@ private static Result<Void> dfs(String node,
                                     List<String> path) {
         visiting.add(node);
         path.add(node);
-
         var nodeDeps = dependencies.getOrDefault(node, List.of());
-
         for (var dep : nodeDeps) {
             if (visiting.contains(dep)) {
                 // Found a cycle
                 var cyclePath = buildCyclePath(path, dep);
-                return Causes.cause("Circular dependency detected: " + cyclePath).result();
+                return Causes.cause("Circular dependency detected: " + cyclePath)
+                             .result();
             }
-
             if (!visited.contains(dep)) {
                 var result = dfs(dep, dependencies, visited, visiting, path);
                 if (result.isFailure()) {
@@ -65,21 +60,20 @@ private static Result<Void> dfs(String node,
                 }
             }
         }
-
         visiting.remove(node);
         visited.add(node);
         path.removeLast();
-
         return Result.success(null);
     }
 
     private static String buildCyclePath(List<String> path, String cycleStart) {
         var cycleIndex = path.indexOf(cycleStart);
         var cycle = new ArrayList<>(path.subList(cycleIndex, path.size()));
-        cycle.add(cycleStart); // Close the cycle
+        cycle.add(cycleStart);
+        // Close the cycle
         return String.join(" -> ", cycle);
     }
 
     // Error constants
-    Fn1<Cause, String> CIRCULAR_DEPENDENCY = Causes.forOneValue("Circular dependency detected: %s");
+    Fn1<Cause, String>CIRCULAR_DEPENDENCY = Causes.forOneValue("Circular dependency detected: %s");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyDescriptor.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyDescriptor.java
index 5343dff9..aa1e7a35 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyDescriptor.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyDescriptor.java
@@ -32,40 +32,37 @@ public record DependencyDescriptor(String sliceClassName, VersionPattern version
      */
     public static Result<DependencyDescriptor> parse(String line) {
         var trimmed = line.trim();
-
         if (trimmed.isEmpty()) {
             return EMPTY_LINE.result();
         }
-
         if (trimmed.startsWith("#")) {
             return COMMENT_LINE.result();
         }
-
-        var parts = trimmed.split(":", -1);  // -1 to include empty strings
-
+        var parts = trimmed.split(":", - 1);
+        // -1 to include empty strings
         if (parts.length < 2) {
-            return INVALID_FORMAT.apply(line).result();
+            return INVALID_FORMAT.apply(line)
+                                 .result();
         }
-
         if (parts.length > 3) {
-            return TOO_MANY_PARTS.apply(line).result();
+            return TOO_MANY_PARTS.apply(line)
+                                 .result();
         }
-
         var className = parts[0].trim();
         var versionStr = parts[1].trim();
         var paramName = parts.length == 3
                         ? Option.option(parts[2].trim())
                         : Option.<String>none();
-
         if (className.isEmpty()) {
-            return EMPTY_CLASS_NAME.apply(line).result();
+            return EMPTY_CLASS_NAME.apply(line)
+                                   .result();
         }
-
         if (versionStr.isEmpty()) {
-            return EMPTY_VERSION_PATTERN.apply(line).result();
+            return EMPTY_VERSION_PATTERN.apply(line)
+                                        .result();
         }
-
-        return VersionPattern.parse(versionStr).map(pattern -> new DependencyDescriptor(className, pattern, paramName));
+        return VersionPattern.parse(versionStr)
+                             .map(pattern -> new DependencyDescriptor(className, pattern, paramName));
     }
 
     /**
@@ -73,18 +70,18 @@ public static Result<DependencyDescriptor> parse(String line) {
      */
     public String asString() {
         var base = sliceClassName + ":" + versionPattern.asString();
-        return parameterName.map(name -> base + ":" + name).or(base);
+        return parameterName.map(name -> base + ":" + name)
+                            .or(base);
     }
 
     // Error constants
     private static final Cause EMPTY_LINE = Causes.cause("Dependency descriptor line is empty");
     private static final Cause COMMENT_LINE = Causes.cause("Dependency descriptor line is a comment");
-    private static final Fn1<Cause, String> INVALID_FORMAT =
-            Causes.forOneValue("Invalid dependency descriptor format: %s");
-    private static final Fn1<Cause, String> TOO_MANY_PARTS = Causes.forOneValue(
-            "Too many parts in dependency descriptor: %s");
-    private static final Fn1<Cause, String> EMPTY_CLASS_NAME = Causes.forOneValue(
-            "Empty class name in dependency descriptor: %s");
-    private static final Fn1<Cause, String> EMPTY_VERSION_PATTERN = Causes.forOneValue(
-            "Empty version pattern in dependency descriptor: %s");
+    private static final Fn1<Cause, String>INVALID_FORMAT = Causes.forOneValue("Invalid dependency descriptor format: %s");
+    private static final Fn1<Cause, String>TOO_MANY_PARTS = Causes.forOneValue(
+    "Too many parts in dependency descriptor: %s");
+    private static final Fn1<Cause, String>EMPTY_CLASS_NAME = Causes.forOneValue(
+    "Empty class name in dependency descriptor: %s");
+    private static final Fn1<Cause, String>EMPTY_VERSION_PATTERN = Causes.forOneValue(
+    "Empty version pattern in dependency descriptor: %s");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyFile.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyFile.java
index 9a49a64c..677f1dd6 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyFile.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyFile.java
@@ -45,16 +45,17 @@
  * @param slices List of slice dependencies (runtime, non-typed)
  */
 public record DependencyFile(
-        List<ArtifactDependency> api,
-        List<ArtifactDependency> shared,
-        List<ArtifactDependency> slices
-) {
-
+ List<ArtifactDependency> api,
+ List<ArtifactDependency> shared,
+ List<ArtifactDependency> slices) {
     private enum Section {
-        NONE,       // No section yet (for backward compatibility)
-        API,        // [api] section
-        SHARED,     // [shared] section
-        SLICES      // [slices] section
+        NONE,
+        // No section yet (for backward compatibility)
+        API,
+        // [api] section
+        SHARED,
+        // [shared] section
+        SLICES
     }
 
     /**
@@ -68,73 +69,61 @@ public static Result<DependencyFile> parse(String content) {
         var shared = new ArrayList<ArtifactDependency>();
         var slices = new ArrayList<ArtifactDependency>();
         var currentSection = Section.NONE;
-
         var lines = content.split("\n");
         for (var line : lines) {
             var trimmed = line.trim();
-
             // Skip empty lines and comments
             if (trimmed.isEmpty() || trimmed.startsWith("#")) {
                 continue;
             }
-
             // Check for section headers
             if (trimmed.equals("[api]")) {
                 currentSection = Section.API;
                 continue;
             }
-
             if (trimmed.equals("[shared]")) {
                 currentSection = Section.SHARED;
                 continue;
             }
-
             if (trimmed.equals("[slices]")) {
                 currentSection = Section.SLICES;
                 continue;
             }
-
             // Unknown section header
             if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-                return UNKNOWN_SECTION.apply(trimmed).result();
+                return UNKNOWN_SECTION.apply(trimmed)
+                                      .result();
             }
-
             // Parse dependency line - skip empty/comment lines, fail on real errors
             var parseResult = ArtifactDependency.parse(trimmed);
-
             // Use fold to handle success and failure cases
             final var currentSectionFinal = currentSection;
             var continueFlag = new boolean[]{false};
             var errorResult = new Result[]{null};
-
-            parseResult
-                .onSuccess(dependency -> {
-                    switch (currentSectionFinal) {
-                        case API -> api.add(dependency);
-                        case SHARED -> shared.add(dependency);
-                        case SLICES, NONE -> slices.add(dependency);
-                    }
-                })
-                .onFailure(cause -> {
-                    // Skip known non-error cases
-                    if (cause == ArtifactDependency.EMPTY_LINE ||
-                        cause == ArtifactDependency.COMMENT_LINE ||
-                        cause == ArtifactDependency.SECTION_HEADER) {
-                        continueFlag[0] = true;
-                    } else {
-                        errorResult[0] = cause.result();
-                    }
-                });
-
+            parseResult.onSuccess(dependency -> {
+                                      switch (currentSectionFinal) {
+                case API -> api.add(dependency);
+                case SHARED -> shared.add(dependency);
+                case SLICES, NONE -> slices.add(dependency);
+            }
+                                  })
+                       .onFailure(cause -> {
+                                      // Skip known non-error cases
+            if (cause == ArtifactDependency.EMPTY_LINE ||
+            cause == ArtifactDependency.COMMENT_LINE ||
+            cause == ArtifactDependency.SECTION_HEADER) {
+                                      continueFlag[0] = true;
+                                  }else {
+                                      errorResult[0] = cause.result();
+                                  }
+                                  });
             if (continueFlag[0]) {
                 continue;
             }
-
             if (errorResult[0] != null) {
                 return (Result<DependencyFile>) errorResult[0];
             }
         }
-
         return Result.success(new DependencyFile(List.copyOf(api), List.copyOf(shared), List.copyOf(slices)));
     }
 
@@ -145,16 +134,19 @@ public static Result<DependencyFile> parse(String content) {
      * @return Parsed dependency file or error
      */
     public static Result<DependencyFile> parse(InputStream inputStream) {
-        return Result.lift(Causes::fromThrowable, () -> {
-            try (var reader = new BufferedReader(new InputStreamReader(inputStream))) {
-                var content = new StringBuilder();
-                String line;
-                while ((line = reader.readLine()) != null) {
-                    content.append(line).append("\n");
-                }
-                return content.toString();
-            }
-        }).flatMap(DependencyFile::parse);
+        return Result.lift(Causes::fromThrowable,
+                           () -> {
+                               try (var reader = new BufferedReader(new InputStreamReader(inputStream))) {
+                               var content = new StringBuilder();
+                               String line;
+                               while ((line = reader.readLine()) != null) {
+                               content.append(line)
+                                      .append("\n");
+                           }
+                               return content.toString();
+                           }
+                           })
+                     .flatMap(DependencyFile::parse);
     }
 
     /**
@@ -167,12 +159,10 @@ public static Result<DependencyFile> parse(InputStream inputStream) {
     public static Result<DependencyFile> load(String sliceClassName, ClassLoader classLoader) {
         var resourcePath = "META-INF/dependencies/" + sliceClassName;
         var resource = classLoader.getResourceAsStream(resourcePath);
-
         if (resource == null) {
             // No dependencies file means no dependencies - this is valid
             return Result.success(new DependencyFile(List.of(), List.of(), List.of()));
         }
-
         return parse(resource);
     }
 
@@ -205,6 +195,5 @@ public boolean isEmpty() {
     }
 
     // Error constants
-    private static final Fn1<Cause, String> UNKNOWN_SECTION =
-            Causes.forOneValue("Unknown section in dependency file: %s. Valid sections: [api], [shared], [slices]");
+    private static final Fn1<Cause, String>UNKNOWN_SECTION = Causes.forOneValue("Unknown section in dependency file: %s. Valid sections: [api], [shared], [slices]");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyResolver.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyResolver.java
index 9156c328..c0aa795a 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyResolver.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/DependencyResolver.java
@@ -18,8 +18,6 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.utils.Causes;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.net.URL;
 import java.util.ArrayList;
@@ -27,6 +25,9 @@
 import java.util.List;
 import java.util.Set;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Orchestrates dependency resolution for slices.
  * <p>
@@ -44,7 +45,6 @@
  * Thread-safe: Uses SliceRegistry for synchronization.
  */
 public interface DependencyResolver {
-
     Logger log = LoggerFactory.getLogger(DependencyResolver.class);
 
     /**
@@ -60,10 +60,13 @@ static Promise<Slice> resolve(Artifact artifact,
                                   Repository repository,
                                   SliceRegistry registry,
                                   SharedLibraryClassLoader sharedLibraryLoader) {
-        return registry.lookup(artifact).fold(
-                () -> resolveWithSharedLoader(artifact, repository, registry, sharedLibraryLoader, new HashSet<>()),
-                Promise::success
-        );
+        return registry.lookup(artifact)
+                       .fold(() -> resolveWithSharedLoader(artifact,
+                                                           repository,
+                                                           registry,
+                                                           sharedLibraryLoader,
+                                                           new HashSet<>()),
+                             Promise::success);
     }
 
     /**
@@ -80,12 +83,12 @@ static Promise<Slice> resolve(Artifact artifact,
      * @return Promise of resolved SliceBridge
      */
     static Promise<SliceBridge> resolveBridge(Artifact artifact,
-                                               Repository repository,
-                                               SliceRegistry registry,
-                                               SharedLibraryClassLoader sharedLibraryLoader,
-                                               SerializerFactory serializerFactory) {
+                                              Repository repository,
+                                              SliceRegistry registry,
+                                              SharedLibraryClassLoader sharedLibraryLoader,
+                                              SerializerFactory serializerFactory) {
         return resolve(artifact, repository, registry, sharedLibraryLoader)
-                .map(slice -> SliceBridgeImpl.sliceBridge(artifact, slice, serializerFactory));
+               .map(slice -> SliceBridgeImpl.sliceBridge(artifact, slice, serializerFactory));
     }
 
     /**
@@ -98,12 +101,11 @@ static Promise<SliceBridge> resolveBridge(Artifact artifact,
      * @return Promise of resolved SliceBridge
      */
     static Promise<SliceBridge> resolveBridge(Artifact artifact,
-                                               Repository repository,
-                                               SliceRegistry registry,
-                                               SharedLibraryClassLoader sharedLibraryLoader) {
-        var serializerFactory = FurySerializerFactoryProvider
-                .furySerializerFactoryProvider()
-                .createFactory(List.of());
+                                              Repository repository,
+                                              SliceRegistry registry,
+                                              SharedLibraryClassLoader sharedLibraryLoader) {
+        var serializerFactory = FurySerializerFactoryProvider.furySerializerFactoryProvider()
+                                                             .createFactory(List.of());
         return resolveBridge(artifact, repository, registry, sharedLibraryLoader, serializerFactory);
     }
 
@@ -113,66 +115,63 @@ private static Promise<Slice> resolveWithSharedLoader(Artifact artifact,
                                                           SharedLibraryClassLoader sharedLibraryLoader,
                                                           Set<String> resolutionPath) {
         var artifactKey = artifact.asString();
-
         if (resolutionPath.contains(artifactKey)) {
-            return circularDependencyDetected(artifactKey).promise();
+            return circularDependencyDetected(artifactKey)
+                   .promise();
         }
-
         resolutionPath.add(artifactKey);
-
         return repository.locate(artifact)
                          .flatMap(location -> loadFromLocationWithShared(artifact,
-                                                                          location,
-                                                                          repository,
-                                                                          registry,
-                                                                          sharedLibraryLoader,
-                                                                          resolutionPath))
+                                                                         location,
+                                                                         repository,
+                                                                         registry,
+                                                                         sharedLibraryLoader,
+                                                                         resolutionPath))
                          .onSuccess(_ -> resolutionPath.remove(artifactKey))
                          .onFailure(_ -> resolutionPath.remove(artifactKey));
     }
 
     private static Promise<Slice> loadFromLocationWithShared(Artifact artifact,
-                                                              Location location,
-                                                              Repository repository,
-                                                              SliceRegistry registry,
-                                                              SharedLibraryClassLoader sharedLibraryLoader,
-                                                              Set<String> resolutionPath) {
+                                                             Location location,
+                                                             Repository repository,
+                                                             SliceRegistry registry,
+                                                             SharedLibraryClassLoader sharedLibraryLoader,
+                                                             Set<String> resolutionPath) {
         return SliceManifest.read(location.url())
-                            .onFailure(cause -> log.error("Invalid slice JAR {}: {}", artifact, cause.message()))
+                            .onFailure(cause -> log.error("Invalid slice JAR {}: {}",
+                                                          artifact,
+                                                          cause.message()))
                             .async()
                             .flatMap(manifest -> validateAndLoadWithShared(artifact,
-                                                                            location,
-                                                                            manifest,
-                                                                            repository,
-                                                                            registry,
-                                                                            sharedLibraryLoader,
-                                                                            resolutionPath));
+                                                                           location,
+                                                                           manifest,
+                                                                           repository,
+                                                                           registry,
+                                                                           sharedLibraryLoader,
+                                                                           resolutionPath));
     }
 
     private static Promise<Slice> validateAndLoadWithShared(Artifact artifact,
-                                                             Location location,
-                                                             SliceManifestInfo manifest,
-                                                             Repository repository,
-                                                             SliceRegistry registry,
-                                                             SharedLibraryClassLoader sharedLibraryLoader,
-                                                             Set<String> resolutionPath) {
-        if (!manifest.artifact().equals(artifact)) {
+                                                            Location location,
+                                                            SliceManifestInfo manifest,
+                                                            Repository repository,
+                                                            SliceRegistry registry,
+                                                            SharedLibraryClassLoader sharedLibraryLoader,
+                                                            Set<String> resolutionPath) {
+        if (!manifest.artifact()
+                     .equals(artifact)) {
             log.error("Artifact mismatch: requested {} but JAR declares {}", artifact, manifest.artifact());
-            return artifactMismatch(artifact, manifest.artifact()).promise();
+            return artifactMismatch(artifact,
+                                    manifest.artifact())
+                   .promise();
         }
-
         // Load dependency file to get shared and slice dependencies
-        return DependencyFile.load(manifest.sliceClassName(), createTempLoader(location.url(), sharedLibraryLoader))
+        return DependencyFile.load(manifest.sliceClassName(),
+                                   createTempLoader(location.url(),
+                                                    sharedLibraryLoader))
                              .async()
                              .flatMap(depFile -> processSharedAndLoadSlice(
-                                     manifest,
-                                     location,
-                                     depFile,
-                                     repository,
-                                     registry,
-                                     sharedLibraryLoader,
-                                     resolutionPath
-                             ));
+        manifest, location, depFile, repository, registry, sharedLibraryLoader, resolutionPath));
     }
 
     private static SliceClassLoader createTempLoader(URL jarUrl, SharedLibraryClassLoader parent) {
@@ -180,109 +179,119 @@ private static SliceClassLoader createTempLoader(URL jarUrl, SharedLibraryClassL
     }
 
     private static Promise<Slice> processSharedAndLoadSlice(SliceManifestInfo manifest,
-                                                             Location location,
-                                                             DependencyFile depFile,
-                                                             Repository repository,
-                                                             SliceRegistry registry,
-                                                             SharedLibraryClassLoader sharedLibraryLoader,
-                                                             Set<String> resolutionPath) {
+                                                            Location location,
+                                                            DependencyFile depFile,
+                                                            Repository repository,
+                                                            SliceRegistry registry,
+                                                            SharedLibraryClassLoader sharedLibraryLoader,
+                                                            Set<String> resolutionPath) {
         // Process API dependencies first (loaded into SharedLibraryClassLoader like [shared])
         // API JARs contain typed interfaces used by generated proxies
-        return SharedDependencyLoader.processApiDependencies(
-                depFile.api(),
-                sharedLibraryLoader,
-                repository
-        ).flatMap(_ -> SharedDependencyLoader.processSharedDependencies(
-                depFile.shared(),
-                sharedLibraryLoader,
-                repository,
-                location.url()
-        )).flatMap(sharedResult -> {
-            // Now load the slice class and resolve slice dependencies
-            return loadClass(manifest.sliceClassName(), sharedResult.sliceClassLoader())
-                    .flatMap(sliceClass -> resolveSliceDependencies(
-                            manifest.artifact(),
-                            sliceClass,
-                            depFile.slices(),
-                            sharedResult.sliceClassLoader(),
-                            repository,
-                            registry,
-                            sharedLibraryLoader,
-                            resolutionPath
-                    ));
-        });
+        return SharedDependencyLoader.processApiDependencies(depFile.api(),
+                                                             sharedLibraryLoader,
+                                                             repository)
+                                     .flatMap(_ -> SharedDependencyLoader.processSharedDependencies(
+        depFile.shared(),
+        sharedLibraryLoader,
+        repository,
+        location.url()))
+                                     .flatMap(sharedResult -> {
+                                                  // Now load the slice class and resolve slice dependencies
+        return loadClass(manifest.sliceClassName(),
+                         sharedResult.sliceClassLoader())
+               .flatMap(sliceClass -> resolveSliceDependencies(
+        manifest.artifact(),
+        sliceClass,
+        depFile.slices(),
+        sharedResult.sliceClassLoader(),
+        repository,
+        registry,
+        sharedLibraryLoader,
+        resolutionPath));
+                                              });
     }
 
     private static Promise<Slice> resolveSliceDependencies(Artifact artifact,
-                                                            Class<?> sliceClass,
-                                                            List<ArtifactDependency> sliceDeps,
-                                                            ClassLoader classLoader,
-                                                            Repository repository,
-                                                            SliceRegistry registry,
-                                                            SharedLibraryClassLoader sharedLibraryLoader,
-                                                            Set<String> resolutionPath) {
+                                                           Class< ? > sliceClass,
+                                                           List<ArtifactDependency> sliceDeps,
+                                                           ClassLoader classLoader,
+                                                           Repository repository,
+                                                           SliceRegistry registry,
+                                                           SharedLibraryClassLoader sharedLibraryLoader,
+                                                           Set<String> resolutionPath) {
         if (sliceDeps.isEmpty()) {
-            return createSliceFromClass(sliceClass, List.of(), List.of())
-                    .async()
-                    .flatMap(slice -> registerSlice(artifact, slice, registry));
+            return createSliceFromClass(sliceClass,
+                                        List.of(),
+                                        List.of())
+                   .async()
+                   .flatMap(slice -> registerSlice(artifact, slice, registry));
         }
-
-        return resolveArtifactDependenciesSequentially(sliceDeps, repository, registry, sharedLibraryLoader, resolutionPath, List.of())
-                .flatMap(resolvedSlices -> createSliceFromClass(sliceClass, resolvedSlices, sliceDeps).async())
-                .flatMap(slice -> registerSlice(artifact, slice, registry));
+        return resolveArtifactDependenciesSequentially(sliceDeps,
+                                                       repository,
+                                                       registry,
+                                                       sharedLibraryLoader,
+                                                       resolutionPath,
+                                                       List.of())
+               .flatMap(resolvedSlices -> createSliceFromClass(sliceClass, resolvedSlices, sliceDeps)
+                                          .async())
+               .flatMap(slice -> registerSlice(artifact, slice, registry));
     }
 
-    private static Promise<List<Slice>> resolveArtifactDependenciesSequentially(
-            List<ArtifactDependency> dependencies,
-            Repository repository,
-            SliceRegistry registry,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Set<String> resolutionPath,
-            List<Slice> accumulated
-    ) {
+    private static Promise<List<Slice>> resolveArtifactDependenciesSequentially(List<ArtifactDependency> dependencies,
+                                                                                Repository repository,
+                                                                                SliceRegistry registry,
+                                                                                SharedLibraryClassLoader sharedLibraryLoader,
+                                                                                Set<String> resolutionPath,
+                                                                                List<Slice> accumulated) {
         if (dependencies.isEmpty()) {
             return Promise.success(accumulated);
         }
-
         var dep = dependencies.getFirst();
         var remaining = dependencies.subList(1, dependencies.size());
-
         return resolveArtifactDependency(dep, repository, registry, sharedLibraryLoader, resolutionPath)
-                .flatMap(slice -> resolveArtifactDependenciesSequentially(
-                        remaining,
-                        repository,
-                        registry,
-                        sharedLibraryLoader,
-                        resolutionPath,
-                        appendToList(accumulated, slice)
-                ));
+               .flatMap(slice -> resolveArtifactDependenciesSequentially(
+        remaining,
+        repository,
+        registry,
+        sharedLibraryLoader,
+        resolutionPath,
+        appendToList(accumulated, slice)));
     }
 
     private static Promise<Slice> resolveArtifactDependency(ArtifactDependency dependency,
-                                                             Repository repository,
-                                                             SliceRegistry registry,
-                                                             SharedLibraryClassLoader sharedLibraryLoader,
-                                                             Set<String> resolutionPath) {
+                                                            Repository repository,
+                                                            SliceRegistry registry,
+                                                            SharedLibraryClassLoader sharedLibraryLoader,
+                                                            Set<String> resolutionPath) {
         // First check registry for compatible version
-        return registry.findByArtifactKey(dependency.groupId(), dependency.artifactId(), dependency.versionPattern())
-                       .fold(
-                               () -> resolveArtifactFromRepository(dependency, repository, registry, sharedLibraryLoader, resolutionPath),
-                               Promise::success
-                       );
+        return registry.findByArtifactKey(dependency.groupId(),
+                                          dependency.artifactId(),
+                                          dependency.versionPattern())
+                       .fold(() -> resolveArtifactFromRepository(dependency,
+                                                                 repository,
+                                                                 registry,
+                                                                 sharedLibraryLoader,
+                                                                 resolutionPath),
+                             Promise::success);
     }
 
     private static Promise<Slice> resolveArtifactFromRepository(ArtifactDependency dependency,
-                                                                 Repository repository,
-                                                                 SliceRegistry registry,
-                                                                 SharedLibraryClassLoader sharedLibraryLoader,
-                                                                 Set<String> resolutionPath) {
+                                                                Repository repository,
+                                                                SliceRegistry registry,
+                                                                SharedLibraryClassLoader sharedLibraryLoader,
+                                                                Set<String> resolutionPath) {
         return toArtifact(dependency)
-                .async()
-                .flatMap(artifact -> resolveWithSharedLoader(artifact, repository, registry, sharedLibraryLoader, resolutionPath));
+               .async()
+               .flatMap(artifact -> resolveWithSharedLoader(artifact,
+                                                            repository,
+                                                            registry,
+                                                            sharedLibraryLoader,
+                                                            resolutionPath));
     }
 
     private static Result<Artifact> toArtifact(ArtifactDependency dependency) {
-        var versionStr = extractVersion(dependency.versionPattern()).withQualifier();
+        var versionStr = extractVersion(dependency.versionPattern())
+                         .withQualifier();
         return Artifact.artifact(dependency.groupId() + ":" + dependency.artifactId() + ":" + versionStr);
     }
 
@@ -296,23 +305,24 @@ private static Version extractVersion(VersionPattern pattern) {
         };
     }
 
-    private static Result<Slice> createSliceFromClass(Class<?> sliceClass,
-                                                       List<Slice> dependencies,
-                                                       List<ArtifactDependency> descriptors) {
+    private static Result<Slice> createSliceFromClass(Class< ? > sliceClass,
+                                                      List<Slice> dependencies,
+                                                      List<ArtifactDependency> descriptors) {
         // Convert ArtifactDependency to DependencyDescriptor for SliceFactory compatibility
         var legacyDescriptors = descriptors.stream()
-                .map(dep -> new DependencyDescriptor(
-                        ArtifactMapper.toClassName(dep.groupId(), dep.artifactId()),
-                        dep.versionPattern(),
-                        Option.none()
-                ))
-                .toList();
-
+                                           .map(dep -> new DependencyDescriptor(
+        ArtifactMapper.toClassName(dep.groupId(),
+                                   dep.artifactId()),
+        dep.versionPattern(),
+        Option.none()))
+                                           .toList();
         return SliceFactory.createSlice(sliceClass, dependencies, legacyDescriptors);
     }
 
     private static Promise<Slice> registerSlice(Artifact artifact, Slice slice, SliceRegistry registry) {
-        return registry.register(artifact, slice).map(_ -> slice).async();
+        return registry.register(artifact, slice)
+                       .map(_ -> slice)
+                       .async();
     }
 
     private static <T> List<T> appendToList(List<T> list, T element) {
@@ -321,7 +331,7 @@ private static <T> List<T> appendToList(List<T> list, T element) {
         return List.copyOf(newList);
     }
 
-    private static Promise<Class<?>> loadClass(String className, ClassLoader classLoader) {
+    private static Promise<Class< ? >> loadClass(String className, ClassLoader classLoader) {
         return Promise.lift(Causes::fromThrowable, () -> classLoader.loadClass(className));
     }
 
@@ -330,9 +340,6 @@ private static Cause circularDependencyDetected(String artifactKey) {
     }
 
     private static Cause artifactMismatch(Artifact requested, Artifact declared) {
-        return Causes.cause("Artifact mismatch: requested "
-                            + requested.asString()
-                            + " but JAR manifest declares "
-                            + declared.asString());
+        return Causes.cause("Artifact mismatch: requested " + requested.asString() + " but JAR manifest declares " + declared.asString());
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java
index 7b4df30d..bac085d9 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SharedDependencyLoader.java
@@ -7,19 +7,19 @@
 import org.pragmatica.aether.slice.repository.Repository;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 import java.net.URL;
 import java.util.ArrayList;
 import java.util.List;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 /**
  * Handles loading of shared dependencies into SharedLibraryClassLoader
  * and creates SliceClassLoader with appropriate parent and conflict overrides.
  */
 public interface SharedDependencyLoader {
-
     Logger log = LoggerFactory.getLogger(SharedDependencyLoader.class);
 
     /**
@@ -33,63 +33,52 @@ public interface SharedDependencyLoader {
      * @param repository          Repository to locate artifacts
      * @return Promise that completes when all API JARs are loaded
      */
-    static Promise<Void> processApiDependencies(
-            List<ArtifactDependency> dependencies,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository
-    ) {
+    static Promise<Void> processApiDependencies(List<ArtifactDependency> dependencies,
+                                                SharedLibraryClassLoader sharedLibraryLoader,
+                                                Repository repository) {
         if (dependencies.isEmpty()) {
             return Promise.success(null);
         }
-
         return processApiSequentially(dependencies, sharedLibraryLoader, repository);
     }
 
-    private static Promise<Void> processApiSequentially(
-            List<ArtifactDependency> dependencies,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository
-    ) {
+    private static Promise<Void> processApiSequentially(List<ArtifactDependency> dependencies,
+                                                        SharedLibraryClassLoader sharedLibraryLoader,
+                                                        Repository repository) {
         if (dependencies.isEmpty()) {
             return Promise.success(null);
         }
-
         var dependency = dependencies.getFirst();
         var remaining = dependencies.subList(1, dependencies.size());
-
         return loadApiIntoShared(dependency, sharedLibraryLoader, repository)
-                .flatMap(_ -> processApiSequentially(remaining, sharedLibraryLoader, repository));
+               .flatMap(_ -> processApiSequentially(remaining, sharedLibraryLoader, repository));
     }
 
-    private static Promise<Void> loadApiIntoShared(
-            ArtifactDependency dependency,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository
-    ) {
+    private static Promise<Void> loadApiIntoShared(ArtifactDependency dependency,
+                                                   SharedLibraryClassLoader sharedLibraryLoader,
+                                                   Repository repository) {
         // Check if already loaded using fold pattern
-        return sharedLibraryLoader.checkCompatibility(dependency).fold(
-                // Not loaded yet - load into shared
-                () -> toArtifact(dependency)
-                        .async()
-                        .flatMap(repository::locate)
-                        .map(location -> {
-                            var version = extractVersion(dependency.versionPattern());
-                            sharedLibraryLoader.addArtifact(
-                                    dependency.groupId(),
-                                    dependency.artifactId(),
-                                    version,
-                                    location.url()
-                            );
-                            log.debug("Loaded API dependency {} into SharedLibraryClassLoader",
-                                      dependency.asString());
-                            return null;
-                        }),
-                // Already loaded - API JARs don't have version conflicts (they're interfaces)
-                _ -> {
-                    log.debug("API dependency {} already loaded", dependency.asString());
-                    return Promise.success(null);
-                }
-        );
+        return sharedLibraryLoader.checkCompatibility(dependency)
+                                  .fold(() -> toArtifact(dependency)
+                                              .async()
+                                              .flatMap(repository::locate)
+                                              .map(location -> {
+                                                       var version = extractVersion(dependency.versionPattern());
+                                                       sharedLibraryLoader.addArtifact(
+        dependency.groupId(),
+        dependency.artifactId(),
+        version,
+        location.url());
+                                                       log.debug("Loaded API dependency {} into SharedLibraryClassLoader",
+                                                                 dependency.asString());
+                                                       return null;
+                                                   }),
+                                        // Already loaded - API JARs don't have version conflicts (they're interfaces)
+        _ -> {
+                                            log.debug("API dependency {} already loaded",
+                                                      dependency.asString());
+                                            return Promise.success(null);
+                                        });
     }
 
     /**
@@ -99,9 +88,8 @@ private static Promise<Void> loadApiIntoShared(
      * @param conflictingJarUrls URLs of JARs that conflict with shared versions (loaded into slice)
      */
     record SharedDependencyResult(
-            SliceClassLoader sliceClassLoader,
-            List<URL> conflictingJarUrls
-    ) {}
+    SliceClassLoader sliceClassLoader,
+    List<URL> conflictingJarUrls) {}
 
     /**
      * Process shared dependencies for a slice.
@@ -117,114 +105,99 @@ record SharedDependencyResult(
      * @param sliceJarUrl            URL of the slice JAR
      * @return SliceClassLoader configured with appropriate parent and conflict overrides
      */
-    static Promise<SharedDependencyResult> processSharedDependencies(
-            List<ArtifactDependency> dependencies,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository,
-            URL sliceJarUrl
-    ) {
+    static Promise<SharedDependencyResult> processSharedDependencies(List<ArtifactDependency> dependencies,
+                                                                     SharedLibraryClassLoader sharedLibraryLoader,
+                                                                     Repository repository,
+                                                                     URL sliceJarUrl) {
         var conflictUrls = new ArrayList<URL>();
-
         return processSequentially(dependencies, sharedLibraryLoader, repository, conflictUrls)
-                .map(_ -> {
-                    // Create slice classloader with slice JAR + any conflict JARs
-                    var urls = new ArrayList<URL>();
-                    urls.add(sliceJarUrl);
-                    urls.addAll(conflictUrls);
-
-                    var sliceLoader = new SliceClassLoader(
-                            urls.toArray(URL[]::new),
-                            sharedLibraryLoader
-                    );
-
-                    return new SharedDependencyResult(sliceLoader, List.copyOf(conflictUrls));
-                });
+               .map(_ -> {
+                        // Create slice classloader with slice JAR + any conflict JARs
+        var urls = new ArrayList<URL>();
+                        urls.add(sliceJarUrl);
+                        urls.addAll(conflictUrls);
+                        var sliceLoader = new SliceClassLoader(
+        urls.toArray(URL[]::new),
+        sharedLibraryLoader);
+                        return new SharedDependencyResult(sliceLoader,
+                                                          List.copyOf(conflictUrls));
+                    });
     }
 
-    private static Promise<Void> processSequentially(
-            List<ArtifactDependency> dependencies,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository,
-            List<URL> conflictUrls
-    ) {
+    private static Promise<Void> processSequentially(List<ArtifactDependency> dependencies,
+                                                     SharedLibraryClassLoader sharedLibraryLoader,
+                                                     Repository repository,
+                                                     List<URL> conflictUrls) {
         if (dependencies.isEmpty()) {
             return Promise.success(null);
         }
-
         var dependency = dependencies.getFirst();
         var remaining = dependencies.subList(1, dependencies.size());
-
         return processSingleDependency(dependency, sharedLibraryLoader, repository, conflictUrls)
-                .flatMap(_ -> processSequentially(remaining, sharedLibraryLoader, repository, conflictUrls));
+               .flatMap(_ -> processSequentially(remaining, sharedLibraryLoader, repository, conflictUrls));
     }
 
-    private static Promise<Void> processSingleDependency(
-            ArtifactDependency dependency,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository,
-            List<URL> conflictUrls
-    ) {
+    private static Promise<Void> processSingleDependency(ArtifactDependency dependency,
+                                                         SharedLibraryClassLoader sharedLibraryLoader,
+                                                         Repository repository,
+                                                         List<URL> conflictUrls) {
         var compatResult = sharedLibraryLoader.checkCompatibility(dependency);
-
         return compatResult.fold(
-                // Not loaded yet - load into shared
-                () -> loadIntoShared(dependency, sharedLibraryLoader, repository),
-                // Already loaded - check compatibility
-                result -> switch (result) {
-                    case CompatibilityResult.Compatible(var loadedVersion) -> {
-                        log.debug("Shared dependency {} compatible with loaded version {}",
-                                  dependency.asString(), loadedVersion.withQualifier());
-                        yield Promise.success(null);
-                    }
-                    case CompatibilityResult.Conflict(var loadedVersion, var required) -> {
-                        log.info("Shared dependency {} conflicts with loaded version {}, will load into slice",
-                                 dependency.asString(), loadedVersion.withQualifier());
-                        yield loadConflictIntoSlice(dependency, repository, conflictUrls);
-                    }
-                }
-        );
+        // Not loaded yet - load into shared
+        () -> loadIntoShared(dependency, sharedLibraryLoader, repository),
+        // Already loaded - check compatibility
+        result -> switch (result) {
+            case CompatibilityResult.Compatible(var loadedVersion) -> {
+            log.debug("Shared dependency {} compatible with loaded version {}",
+                      dependency.asString(),
+                      loadedVersion.withQualifier());
+            yield Promise.success(null);
+        }
+            case CompatibilityResult.Conflict(var loadedVersion, var required) -> {
+            log.info("Shared dependency {} conflicts with loaded version {}, will load into slice",
+                     dependency.asString(),
+                     loadedVersion.withQualifier());
+            yield loadConflictIntoSlice(dependency, repository, conflictUrls);
+        }
+        });
     }
 
-    private static Promise<Void> loadIntoShared(
-            ArtifactDependency dependency,
-            SharedLibraryClassLoader sharedLibraryLoader,
-            Repository repository
-    ) {
+    private static Promise<Void> loadIntoShared(ArtifactDependency dependency,
+                                                SharedLibraryClassLoader sharedLibraryLoader,
+                                                Repository repository) {
         return toArtifact(dependency)
-                .async()
-                .flatMap(repository::locate)
-                .map(location -> {
-                    var version = extractVersion(dependency.versionPattern());
-                    sharedLibraryLoader.addArtifact(
-                            dependency.groupId(),
-                            dependency.artifactId(),
-                            version,
-                            location.url()
-                    );
-                    log.debug("Loaded shared dependency {} into SharedLibraryClassLoader",
-                              dependency.asString());
-                    return null;
-                });
+               .async()
+               .flatMap(repository::locate)
+               .map(location -> {
+                        var version = extractVersion(dependency.versionPattern());
+                        sharedLibraryLoader.addArtifact(
+        dependency.groupId(),
+        dependency.artifactId(),
+        version,
+        location.url());
+                        log.debug("Loaded shared dependency {} into SharedLibraryClassLoader",
+                                  dependency.asString());
+                        return null;
+                    });
     }
 
-    private static Promise<Void> loadConflictIntoSlice(
-            ArtifactDependency dependency,
-            Repository repository,
-            List<URL> conflictUrls
-    ) {
+    private static Promise<Void> loadConflictIntoSlice(ArtifactDependency dependency,
+                                                       Repository repository,
+                                                       List<URL> conflictUrls) {
         return toArtifact(dependency)
-                .async()
-                .flatMap(repository::locate)
-                .map(location -> {
-                    conflictUrls.add(location.url());
-                    log.debug("Added conflicting dependency {} to slice classloader",
-                              dependency.asString());
-                    return null;
-                });
+               .async()
+               .flatMap(repository::locate)
+               .map(location -> {
+                        conflictUrls.add(location.url());
+                        log.debug("Added conflicting dependency {} to slice classloader",
+                                  dependency.asString());
+                        return null;
+                    });
     }
 
     private static Result<Artifact> toArtifact(ArtifactDependency dependency) {
-        var versionStr = extractVersion(dependency.versionPattern()).withQualifier();
+        var versionStr = extractVersion(dependency.versionPattern())
+                         .withQualifier();
         return Artifact.artifact(dependency.groupId() + ":" + dependency.artifactId() + ":" + versionStr);
     }
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceDependencies.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceDependencies.java
index 62c398dd..a1c5f4af 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceDependencies.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceDependencies.java
@@ -26,7 +26,6 @@
  * </pre>
  */
 public interface SliceDependencies {
-
     /**
      * Load dependencies from META-INF/dependencies/{sliceClassName} resource.
      *
@@ -38,24 +37,21 @@ public interface SliceDependencies {
     static Result<List<DependencyDescriptor>> load(String sliceClassName, ClassLoader classLoader) {
         var resourcePath = "META-INF/dependencies/" + sliceClassName;
         var resource = classLoader.getResourceAsStream(resourcePath);
-
         if (resource == null) {
             // No dependencies file means no dependencies - this is valid
             return Result.success(List.of());
         }
-
-        return Result.lift(Causes::fromThrowable, () -> {
-            try (var reader = new BufferedReader(new InputStreamReader(resource))) {
-                var dependencies = new ArrayList<DependencyDescriptor>();
-                String line;
-
-                while ((line = reader.readLine()) != null) {
-                    DependencyDescriptor.parse(line).onSuccess(dependencies::add);
-                    // Ignore empty lines and comments (they return failure)
-                }
-
-                return dependencies;
-            }
-        });
+        return Result.lift(Causes::fromThrowable,
+                           () -> {
+                               try (var reader = new BufferedReader(new InputStreamReader(resource))) {
+                               var dependencies = new ArrayList<DependencyDescriptor>();
+                               String line;
+                               while ((line = reader.readLine()) != null) {
+                               DependencyDescriptor.parse(line)
+                                                   .onSuccess(dependencies::add);
+                           }
+                               return dependencies;
+                           }
+                           });
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceFactory.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceFactory.java
index cb55de9a..87c94c3e 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceFactory.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceFactory.java
@@ -25,7 +25,6 @@
  * - Optional name verification from META-INF/dependencies descriptor
  */
 public interface SliceFactory {
-
     /**
      * Create slice instance using static factory method.
      *
@@ -35,58 +34,63 @@ public interface SliceFactory {
      *
      * @return Created slice instance
      */
-    static Result<Slice> createSlice(Class<?> sliceClass,
+    static Result<Slice> createSlice(Class< ? > sliceClass,
                                      List<Slice> dependencies,
                                      List<DependencyDescriptor> descriptors) {
-        return findFactoryMethod(sliceClass).flatMap(method -> verifyParameters(method, dependencies, descriptors))
-                                            .flatMap(method -> invokeFactory(method, dependencies));
+        return findFactoryMethod(sliceClass)
+               .flatMap(method -> verifyParameters(method, dependencies, descriptors))
+               .flatMap(method -> invokeFactory(method, dependencies));
     }
 
-    private static Result<Method> findFactoryMethod(Class<?> sliceClass) {
+    private static Result<Method> findFactoryMethod(Class< ? > sliceClass) {
         var expectedName = toLowercaseFirst(sliceClass.getSimpleName());
-
         return Arrays.stream(sliceClass.getDeclaredMethods())
                      .filter(m -> Modifier.isStatic(m.getModifiers()))
-                     .filter(m -> m.getName().equals(expectedName))
+                     .filter(m -> m.getName()
+                                   .equals(expectedName))
                      .filter(m -> sliceClass.isAssignableFrom(m.getReturnType()))
                      .findFirst()
                      .map(Result::success)
-                     .orElseGet(() -> factoryMethodNotFound(sliceClass.getName(), expectedName).result());
+                     .orElseGet(() -> factoryMethodNotFound(sliceClass.getName(),
+                                                            expectedName)
+                                      .result());
     }
 
     private static Result<Method> verifyParameters(Method method,
                                                    List<Slice> dependencies,
                                                    List<DependencyDescriptor> descriptors) {
         var parameters = method.getParameters();
-
         if (parameters.length != dependencies.size()) {
-            return parameterCountMismatch(method.getName(), parameters.length, dependencies.size()).result();
+            return parameterCountMismatch(method.getName(),
+                                          parameters.length,
+                                          dependencies.size())
+                   .result();
         }
-
-        for (int i = 0; i < parameters.length; i++) {
+        for (int i = 0; i < parameters.length; i++ ) {
             var parameter = parameters[i];
             var dependency = dependencies.get(i);
             var descriptor = descriptors.get(i);
-
             // Verify type matches
-            if (!parameter.getType().isInstance(dependency)) {
+            if (!parameter.getType()
+                          .isInstance(dependency)) {
                 return parameterTypeMismatch(i,
-                                             parameter.getType().getName(),
-                                             dependency.getClass().getName()).result();
+                                             parameter.getType()
+                                                      .getName(),
+                                             dependency.getClass()
+                                                       .getName())
+                       .result();
             }
-
-            // Note: We don't verify parameter names because they require -parameters compiler flag
         }
-
         return Result.success(method);
     }
 
     private static Result<Slice> invokeFactory(Method method, List<Slice> dependencies) {
-        return Result.lift(Causes::fromThrowable, () -> {
-            method.setAccessible(true);
-            var instance = method.invoke(null, dependencies.toArray());
-            return (Slice) instance;
-        });
+        return Result.lift(Causes::fromThrowable,
+                           () -> {
+                               method.setAccessible(true);
+                               var instance = method.invoke(null, dependencies.toArray());
+                               return (Slice) instance;
+                           });
     }
 
     private static String toLowercaseFirst(String name) {
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
index 290cb5dc..c53be9d1 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
@@ -23,7 +23,6 @@
  * - Thread-safe concurrent access
  */
 public interface SliceRegistry {
-
     /**
      * Create a new empty registry.
      */
@@ -92,12 +91,12 @@ static SliceRegistry create() {
     Option<Slice> findByArtifactKey(String groupId, String artifactId, VersionPattern versionPattern);
 
     record SliceRegistryImpl(ConcurrentMap<Artifact, Slice> registry) implements SliceRegistry {
-
         @Override
         public Result<Unit> register(Artifact artifact, Slice slice) {
             var existing = registry.putIfAbsent(artifact, slice);
             if (existing != null) {
-                return ALREADY_REGISTERED.apply(artifact.asString()).result();
+                return ALREADY_REGISTERED.apply(artifact.asString())
+                                         .result();
             }
             return Result.unitResult();
         }
@@ -106,7 +105,8 @@ public Result<Unit> register(Artifact artifact, Slice slice) {
         public Result<Unit> unregister(Artifact artifact) {
             var removed = registry.remove(artifact);
             if (removed == null) {
-                return NOT_FOUND.apply(artifact.asString()).result();
+                return NOT_FOUND.apply(artifact.asString())
+                                .result();
             }
             return Result.unitResult();
         }
@@ -120,8 +120,10 @@ public Option<Slice> lookup(Artifact artifact) {
         public Option<Slice> find(String className, VersionPattern versionPattern) {
             return registry.entrySet()
                            .stream()
-                           .filter(entry -> matchesClassName(entry.getKey(), className))
-                           .filter(entry -> versionPattern.matches(entry.getKey().version()))
+                           .filter(entry -> matchesClassName(entry.getKey(),
+                                                             className))
+                           .filter(entry -> versionPattern.matches(entry.getKey()
+                                                                        .version()))
                            .map(entry -> entry.getValue())
                            .findFirst()
                            .map(Option::option)
@@ -137,9 +139,16 @@ public List<Artifact> allArtifacts() {
         public Option<Slice> findByArtifactKey(String groupId, String artifactId, VersionPattern versionPattern) {
             return registry.entrySet()
                            .stream()
-                           .filter(entry -> entry.getKey().groupId().id().equals(groupId))
-                           .filter(entry -> entry.getKey().artifactId().id().equals(artifactId))
-                           .filter(entry -> versionPattern.matches(entry.getKey().version()))
+                           .filter(entry -> entry.getKey()
+                                                 .groupId()
+                                                 .id()
+                                                 .equals(groupId))
+                           .filter(entry -> entry.getKey()
+                                                 .artifactId()
+                                                 .id()
+                                                 .equals(artifactId))
+                           .filter(entry -> versionPattern.matches(entry.getKey()
+                                                                        .version()))
                            .map(entry -> entry.getValue())
                            .findFirst()
                            .map(Option::option)
@@ -151,7 +160,9 @@ private boolean matchesClassName(Artifact artifact, String className) {
             // Convention: artifact ID is typically the class name or last part of package
             // For exact matching, we'd need to load the class, but that's expensive
             // So we use a simple string match on the artifact ID
-            return artifact.artifactId().id().equals(extractSimpleName(className));
+            return artifact.artifactId()
+                           .id()
+                           .equals(extractSimpleName(className));
         }
 
         private String extractSimpleName(String className) {
@@ -161,8 +172,8 @@ private String extractSimpleName(String className) {
                    : className;
         }
 
-        private static final Fn1<Cause, String> ALREADY_REGISTERED = Causes.forOneValue("Artifact already registered: %s");
+        private static final Fn1<Cause, String>ALREADY_REGISTERED = Causes.forOneValue("Artifact already registered: %s");
 
-        private static final Fn1<Cause, String> NOT_FOUND = Causes.forOneValue("Artifact not found in registry: %s");
+        private static final Fn1<Cause, String>NOT_FOUND = Causes.forOneValue("Artifact not found in registry: %s");
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/VersionPattern.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/VersionPattern.java
index 107c9e1f..27b1dd8b 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/VersionPattern.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/VersionPattern.java
@@ -17,7 +17,6 @@
  * - Caret: "^1.2.3" (minor-level: >=1.2.3, <2.0.0)
  */
 public sealed interface VersionPattern {
-
     boolean matches(Version version);
 
     String asString();
@@ -37,23 +36,20 @@ public String asString() {
 
     /// Version range with inclusive/exclusive bounds
     record Range(
-            Version from,
-            boolean fromInclusive,
-            Version to,
-            boolean toInclusive
-    ) implements VersionPattern {
+    Version from,
+    boolean fromInclusive,
+    Version to,
+    boolean toInclusive) implements VersionPattern {
         @Override
         public boolean matches(Version version) {
             int fromCmp = compareVersions(version, from);
             int toCmp = compareVersions(version, to);
-
             boolean fromMatch = fromInclusive
                                 ? fromCmp >= 0
                                 : fromCmp > 0;
             boolean toMatch = toInclusive
                               ? toCmp <= 0
                               : toCmp < 0;
-
             return fromMatch && toMatch;
         }
 
@@ -88,30 +84,28 @@ public String asString() {
         }
 
         public enum Operator {
-            GT(">"), GTE(">="), LT("<"), LTE("<=");
-
+            GT(">"),
+            GTE(">="),
+            LT("<"),
+            LTE("<=");
             private final String symbol;
-
             Operator(String symbol) {
                 this.symbol = symbol;
             }
-
             public String symbol() {
                 return symbol;
             }
-
             public static Result<Operator> fromSymbol(String symbol) {
                 return switch (symbol) {
-                    case ">" -> Result.success(GT);
-                    case ">=" -> Result.success(GTE);
-                    case "<" -> Result.success(LT);
-                    case "<=" -> Result.success(LTE);
-                    default -> INVALID_OPERATOR.apply(symbol).result();
+                    case">" -> Result.success(GT);
+                    case">=" -> Result.success(GTE);
+                    case"<" -> Result.success(LT);
+                    case"<=" -> Result.success(LTE);
+                    default -> INVALID_OPERATOR.apply(symbol)
+                                               .result();
                 };
             }
-
-            private static final Fn1<Cause, String> INVALID_OPERATOR =
-                    Causes.forOneValue("Invalid comparison operator: %s");
+            private static final Fn1<Cause, String>INVALID_OPERATOR = Causes.forOneValue("Invalid comparison operator: %s");
         }
     }
 
@@ -122,10 +116,9 @@ public boolean matches(Version other) {
             if (compareVersions(other, version) < 0) {
                 return false;
             }
-
             // Must have same major and minor
             return other.major() == version.major() &&
-                   other.minor() == version.minor();
+            other.minor() == version.minor();
         }
 
         @Override
@@ -141,7 +134,6 @@ public boolean matches(Version other) {
             if (compareVersions(other, version) < 0) {
                 return false;
             }
-
             // Must have same major
             return other.major() == version.major();
         }
@@ -164,75 +156,70 @@ static int compareVersions(Version v1, Version v2) {
             return Integer.compare(v1.patch(), v2.patch());
         }
         // Qualifier comparison: lexicographic
-        return v1.qualifier().compareTo(v2.qualifier());
+        return v1.qualifier()
+                 .compareTo(v2.qualifier());
     }
 
     /// Parse version pattern from string
     static Result<VersionPattern> parse(String pattern) {
         var trimmed = pattern.trim();
-
         if (trimmed.isEmpty()) {
             return EMPTY_PATTERN.result();
         }
-
         // Range pattern: [1.0.0,2.0.0)
         if (isRangePattern(trimmed)) {
             return parseRange(trimmed);
         }
-
         // Tilde pattern: ~1.2.3
         if (trimmed.startsWith("~")) {
             return parseTilde(trimmed);
         }
-
         // Caret pattern: ^1.2.3
         if (trimmed.startsWith("^")) {
             return parseCaret(trimmed);
         }
-
         // Comparison pattern: >=1.5.0, >1.0.0, <=2.0.0, <3.0.0
         if (isComparisonPattern(trimmed)) {
             return parseComparison(trimmed);
         }
-
         // Exact version: 1.2.3
         return parseExact(trimmed);
     }
 
     private static boolean isRangePattern(String pattern) {
         return (pattern.startsWith("[") || pattern.startsWith("(")) &&
-               (pattern.endsWith("]") || pattern.endsWith(")"));
+        (pattern.endsWith("]") || pattern.endsWith(")"));
     }
 
     private static boolean isComparisonPattern(String pattern) {
         return pattern.startsWith(">=") || pattern.startsWith(">") ||
-               pattern.startsWith("<=") || pattern.startsWith("<");
+        pattern.startsWith("<=") || pattern.startsWith("<");
     }
 
     private static Result<VersionPattern> parseRange(String pattern) {
         var fromInclusive = pattern.startsWith("[");
         var toInclusive = pattern.endsWith("]");
-
         var content = pattern.substring(1, pattern.length() - 1);
         var parts = content.split(",");
-
         if (parts.length != 2) {
-            return INVALID_RANGE_FORMAT.apply(pattern).result();
+            return INVALID_RANGE_FORMAT.apply(pattern)
+                                       .result();
         }
-
         return Version.version(parts[0].trim())
                       .flatMap(from -> Version.version(parts[1].trim())
                                               .map(to -> new Range(from, fromInclusive, to, toInclusive)));
     }
 
     private static Result<VersionPattern> parseTilde(String pattern) {
-        var versionStr = pattern.substring(1).trim();
+        var versionStr = pattern.substring(1)
+                                .trim();
         return Version.version(versionStr)
                       .map(Tilde::new);
     }
 
     private static Result<VersionPattern> parseCaret(String pattern) {
-        var versionStr = pattern.substring(1).trim();
+        var versionStr = pattern.substring(1)
+                                .trim();
         return Version.version(versionStr)
                       .map(Caret::new);
     }
@@ -241,26 +228,29 @@ private static Result<VersionPattern> parseComparison(String pattern) {
         // Extract operator
         String opStr;
         String versionStr;
-
         if (pattern.startsWith(">=")) {
             opStr = ">=";
-            versionStr = pattern.substring(2).trim();
-        } else if (pattern.startsWith("<=")) {
+            versionStr = pattern.substring(2)
+                                .trim();
+        }else if (pattern.startsWith("<=")) {
             opStr = "<=";
-            versionStr = pattern.substring(2).trim();
-        } else if (pattern.startsWith(">")) {
+            versionStr = pattern.substring(2)
+                                .trim();
+        }else if (pattern.startsWith(">")) {
             opStr = ">";
-            versionStr = pattern.substring(1).trim();
-        } else if (pattern.startsWith("<")) {
+            versionStr = pattern.substring(1)
+                                .trim();
+        }else if (pattern.startsWith("<")) {
             opStr = "<";
-            versionStr = pattern.substring(1).trim();
-        } else {
-            return INVALID_COMPARISON_FORMAT.apply(pattern).result();
+            versionStr = pattern.substring(1)
+                                .trim();
+        }else {
+            return INVALID_COMPARISON_FORMAT.apply(pattern)
+                                            .result();
         }
-
         return Comparison.Operator.fromSymbol(opStr)
-                                  .flatMap(operator -> Version.version(versionStr)
-                                                              .map(version -> new Comparison(operator, version)));
+                         .flatMap(operator -> Version.version(versionStr)
+                                                     .map(version -> new Comparison(operator, version)));
     }
 
     private static Result<VersionPattern> parseExact(String pattern) {
@@ -270,6 +260,6 @@ private static Result<VersionPattern> parseExact(String pattern) {
 
     // Error constants
     Cause EMPTY_PATTERN = Causes.cause("Version pattern cannot be empty");
-    Fn1<Cause, String> INVALID_RANGE_FORMAT = Causes.forOneValue("Invalid range format: %s");
-    Fn1<Cause, String> INVALID_COMPARISON_FORMAT = Causes.forOneValue("Invalid comparison format: %s");
+    Fn1<Cause, String>INVALID_RANGE_FORMAT = Causes.forOneValue("Invalid range format: %s");
+    Fn1<Cause, String>INVALID_COMPARISON_FORMAT = Causes.forOneValue("Invalid comparison format: %s");
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
index 4d658ad1..2a0be47b 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
@@ -14,7 +14,6 @@
 
 /// Aether KV-Store structured keys for cluster state management
 public sealed interface AetherKey extends StructuredKey {
-
     /// String representation of the key
     String asString();
 
@@ -44,11 +43,13 @@ public String toString() {
 
         public static Result<BlueprintKey> blueprintKey(String key) {
             if (!key.startsWith("blueprint/")) {
-                return BLUEPRINT_KEY_FORMAT_ERROR.apply(key).result();
+                return BLUEPRINT_KEY_FORMAT_ERROR.apply(key)
+                                                 .result();
             }
-
-            var artifactPart = key.substring(10); // Remove "blueprint/"
-            return Artifact.artifact(artifactPart).map(BlueprintKey::new);
+            var artifactPart = key.substring(10);
+            // Remove "blueprint/"
+            return Artifact.artifact(artifactPart)
+                           .map(BlueprintKey::new);
         }
     }
 
@@ -77,11 +78,13 @@ public String toString() {
 
         public static Result<AppBlueprintKey> appBlueprintKey(String key) {
             if (!key.startsWith("app-blueprint/")) {
-                return APP_BLUEPRINT_KEY_FORMAT_ERROR.apply(key).result();
+                return APP_BLUEPRINT_KEY_FORMAT_ERROR.apply(key)
+                                                     .result();
             }
-
-            var blueprintIdPart = key.substring(14); // Remove "app-blueprint/"
-            return BlueprintId.blueprintId(blueprintIdPart).map(AppBlueprintKey::new);
+            var blueprintIdPart = key.substring(14);
+            // Remove "app-blueprint/"
+            return BlueprintId.blueprintId(blueprintIdPart)
+                              .map(AppBlueprintKey::new);
         }
 
         public static AppBlueprintKey appBlueprintKey(BlueprintId blueprintId) {
@@ -118,20 +121,21 @@ public String toString() {
 
         public static Result<SliceNodeKey> sliceNodeKey(String key) {
             var parts = key.split("/");
-
             if (parts.length != 3) {
-                return SLICE_KEY_FORMAT_ERROR.apply(key).result();
+                return SLICE_KEY_FORMAT_ERROR.apply(key)
+                                             .result();
             }
-
             if (!"slices".equals(parts[0])) {
-                return SLICE_KEY_FORMAT_ERROR.apply(key).result();
+                return SLICE_KEY_FORMAT_ERROR.apply(key)
+                                             .result();
             }
-
             if (parts[1].isEmpty()) {
-                return SLICE_KEY_FORMAT_ERROR.apply(key).result();
+                return SLICE_KEY_FORMAT_ERROR.apply(key)
+                                             .result();
             }
-
-            return Artifact.artifact(parts[2]).map(artifact -> new SliceNodeKey(artifact, NodeId.nodeId(parts[1])));
+            return Artifact.artifact(parts[2])
+                           .map(artifact -> new SliceNodeKey(artifact,
+                                                             NodeId.nodeId(parts[1])));
         }
     }
 
@@ -160,29 +164,29 @@ public String toString() {
 
         public static Result<EndpointKey> endpointKey(String key) {
             if (!key.startsWith("endpoints/")) {
-                return ENDPOINT_KEY_FORMAT_ERROR.apply(key).result();
+                return ENDPOINT_KEY_FORMAT_ERROR.apply(key)
+                                                .result();
             }
-
-            var content = key.substring(10); // Remove "endpoints/"
+            var content = key.substring(10);
+            // Remove "endpoints/"
             var slashIndex = content.indexOf('/');
-            if (slashIndex == -1) {
-                return ENDPOINT_KEY_FORMAT_ERROR.apply(key).result();
+            if (slashIndex == - 1) {
+                return ENDPOINT_KEY_FORMAT_ERROR.apply(key)
+                                                .result();
             }
-
             var artifactPart = content.substring(0, slashIndex);
             var endpointPart = content.substring(slashIndex + 1);
-
             var colonIndex = endpointPart.lastIndexOf(':');
-            if (colonIndex == -1) {
-                return ENDPOINT_KEY_FORMAT_ERROR.apply(key).result();
+            if (colonIndex == - 1) {
+                return ENDPOINT_KEY_FORMAT_ERROR.apply(key)
+                                                .result();
             }
-
             var methodNamePart = endpointPart.substring(0, colonIndex);
             var instancePart = endpointPart.substring(colonIndex + 1);
-
             return Result.all(Artifact.artifact(artifactPart),
                               MethodName.methodName(methodNamePart),
-                              Number.parseInt(instancePart)).map(EndpointKey::new);
+                              Number.parseInt(instancePart))
+                         .map(EndpointKey::new);
         }
     }
 
@@ -216,28 +220,28 @@ public static RouteKey routeKey(String method, String pathPattern) {
 
         public static Result<RouteKey> routeKey(String key) {
             if (!key.startsWith("routes/")) {
-                return ROUTE_KEY_FORMAT_ERROR.apply(key).result();
+                return ROUTE_KEY_FORMAT_ERROR.apply(key)
+                                             .result();
             }
-
-            var content = key.substring(7); // Remove "routes/"
+            var content = key.substring(7);
+            // Remove "routes/"
             var colonIndex = content.indexOf(':');
-            if (colonIndex == -1) {
-                return ROUTE_KEY_FORMAT_ERROR.apply(key).result();
+            if (colonIndex == - 1) {
+                return ROUTE_KEY_FORMAT_ERROR.apply(key)
+                                             .result();
             }
-
             var method = content.substring(0, colonIndex);
             var hashPart = content.substring(colonIndex + 1);
-
             return Number.parseInt(hashPart)
-                .map(hash -> new RouteKey(method, hash));
+                         .map(hash -> new RouteKey(method, hash));
         }
     }
 
-    Fn1<Cause, String> BLUEPRINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid blueprint key format: %s");
-    Fn1<Cause, String> APP_BLUEPRINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid app-blueprint key format: %s");
-    Fn1<Cause, String> SLICE_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid slice key format: %s");
-    Fn1<Cause, String> ENDPOINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid endpoint key format: %s");
-    Fn1<Cause, String> ROUTE_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid route key format: %s");
+    Fn1<Cause, String>BLUEPRINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid blueprint key format: %s");
+    Fn1<Cause, String>APP_BLUEPRINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid app-blueprint key format: %s");
+    Fn1<Cause, String>SLICE_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid slice key format: %s");
+    Fn1<Cause, String>ENDPOINT_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid endpoint key format: %s");
+    Fn1<Cause, String>ROUTE_KEY_FORMAT_ERROR = Causes.forOneValue("Invalid route key format: %s");
 
     /// Aether KV-Store structured patterns for key matching
     sealed interface AetherKeyPattern extends StructuredPattern {
@@ -276,4 +280,4 @@ public boolean matches(RouteKey key) {
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
index 539f8c90..a0895bcb 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
@@ -26,21 +26,15 @@ record EndpointValue(NodeId nodeId) implements AetherValue {}
     /// Route definition for HTTP routing.
     /// Contains full route information for self-registration by slices.
     record RouteValue(
-        Artifact artifact,
-        String methodName,
-        String httpMethod,
-        String pathPattern,
-        List<Binding> bindings
-    ) implements AetherValue {
-
+    Artifact artifact,
+    String methodName,
+    String httpMethod,
+    String pathPattern,
+    List<Binding> bindings) implements AetherValue {
         /// Check if this route matches another route (same target).
         /// Used for idempotent registration validation.
         public boolean matches(RouteValue other) {
-            return artifact.equals(other.artifact)
-                && methodName.equals(other.methodName)
-                && httpMethod.equalsIgnoreCase(other.httpMethod)
-                && pathPattern.equals(other.pathPattern)
-                && bindings.equals(other.bindings);
+            return artifact.equals(other.artifact) && methodName.equals(other.methodName) && httpMethod.equalsIgnoreCase(other.httpMethod) && pathPattern.equals(other.pathPattern) && bindings.equals(other.bindings);
         }
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/repository/Location.java b/slice/src/main/java/org/pragmatica/aether/slice/repository/Location.java
index 533ab9b4..ed9fc547 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/repository/Location.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/repository/Location.java
@@ -5,7 +5,6 @@
 import java.net.URL;
 
 public record Location(Artifact artifact, URL url) {
-
     public static Location location(Artifact artifact, URL url) {
         return new Location(artifact, url);
     }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/LocalRepository.java b/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/LocalRepository.java
index 7b8b8ffe..12586376 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/LocalRepository.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/LocalRepository.java
@@ -24,7 +24,6 @@
  * </pre>
  */
 public interface LocalRepository extends Repository {
-
     /**
      * Create a LocalRepository using the detected Maven local repository location.
      * Detection order: maven.repo.local property → user settings.xml → global settings.xml → default ~/.m2/repository
@@ -38,34 +37,38 @@ static LocalRepository localRepository() {
      */
     static LocalRepository localRepository(Path localRepo) {
         record repository(Path localRepo) implements LocalRepository {
-
             @Override
             public Promise<Location> locate(Artifact artifact) {
-                return resolveLocation(artifact).async();
+                return resolveLocation(artifact)
+                       .async();
             }
 
             private Result<Location> resolveLocation(Artifact artifact) {
                 var jarPath = resolvePath(artifact, "jar");
-
                 if (!Files.exists(jarPath)) {
-                    return ARTIFACT_NOT_FOUND.apply(artifact.asString() + " at " + jarPath).result();
+                    return ARTIFACT_NOT_FOUND.apply(artifact.asString() + " at " + jarPath)
+                                             .result();
                 }
-
-                return Result.lift(Causes::fromThrowable, () -> jarPath.toUri().toURL()).map(url -> location(artifact,
-                                                                                                             url));
+                return Result.lift(Causes::fromThrowable,
+                                   () -> jarPath.toUri()
+                                                .toURL())
+                             .map(url -> location(artifact, url));
             }
 
             private Path resolvePath(Artifact artifact, String packaging) {
                 var version = artifact.version();
-                var artifactId = artifact.artifactId().id();
-                return localRepo.resolve(artifact.groupId().id().replace('.', '/'))
+                var artifactId = artifact.artifactId()
+                                         .id();
+                return localRepo.resolve(artifact.groupId()
+                                                 .id()
+                                                 .replace('.', '/'))
                                 .resolve(artifactId)
                                 .resolve(version.bareVersion())
                                 .resolve(artifactId + "-" + version.withQualifier() + "." + packaging);
             }
 
-            private static final Fn1<Cause, String> ARTIFACT_NOT_FOUND = Causes.forOneValue(
-                    "Artifact not found in local repository: %s");
+            private static final Fn1<Cause, String>ARTIFACT_NOT_FOUND = Causes.forOneValue(
+            "Artifact not found in local repository: %s");
         }
         return new repository(localRepo);
     }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/MavenLocalRepoLocator.java b/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/MavenLocalRepoLocator.java
index bd2a4f9c..4507fe45 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/MavenLocalRepoLocator.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/repository/maven/MavenLocalRepoLocator.java
@@ -9,11 +9,10 @@
 public sealed interface MavenLocalRepoLocator {
     static String findLocalRepository() {
         var userHome = System.getProperty("user.home");
-
         return checkSystemProperty()
-                .orElse(() -> checkUserLevelSettings(userHome))
-                .orElse(() -> checkGlobalSettings(userHome))
-                .or(() -> defaultRepository(userHome));
+               .orElse(() -> checkUserLevelSettings(userHome))
+               .orElse(() -> checkGlobalSettings(userHome))
+               .or(() -> defaultRepository(userHome));
     }
 
     private static String defaultRepository(String userHome) {
@@ -29,35 +28,33 @@ private static Option<String> checkGlobalSettings(String userHome) {
     }
 
     private static Option<String> checkUserLevelSettings(String userHome) {
-        return getLocalRepoFromSettings(fromM2Home(userHome, "settings.xml")).map(userRepo -> expandPath(userRepo,
-                                                                                                         userHome));
+        return getLocalRepoFromSettings(fromM2Home(userHome, "settings.xml"))
+               .map(userRepo -> expandPath(userRepo, userHome));
     }
 
     private static Option<String> checkSystemProperty() {
-        return Option.option(System.getProperty("maven.repo.local")).filter(Verify.Is::notEmpty);
+        return Option.option(System.getProperty("maven.repo.local"))
+                     .filter(Verify.Is::notEmpty);
     }
 
     private static Option<String> getLocalRepoFromSettings(String settingsPath) {
         var file = new File(settingsPath);
-
         if (!file.exists()) {
             return Option.empty();
         }
-
-        try {
+        try{
             var dbf = DocumentBuilderFactory.newInstance();
             dbf.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
-
             var db = dbf.newDocumentBuilder();
             var doc = db.parse(file);
             var nodes = doc.getElementsByTagName("localRepository");
-
             if (nodes.getLength() > 0) {
-                return Option.option(nodes.item(0).getTextContent().trim()).filter(Verify.Is::notEmpty);
+                return Option.option(nodes.item(0)
+                                          .getTextContent()
+                                          .trim())
+                             .filter(Verify.Is::notEmpty);
             }
-        } catch (Exception ignored) {
-        }
-
+        } catch (Exception ignored) {}
         return Option.empty();
     }
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/routing/Binding.java b/slice/src/main/java/org/pragmatica/aether/slice/routing/Binding.java
index 3dc3adbb..0ecada4c 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/routing/Binding.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/routing/Binding.java
@@ -9,11 +9,12 @@
 
 public record Binding(String param, BindingSource source) {
     private static final Pattern PARAM_PATTERN = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
-    private static final Fn1<Cause, String> INVALID_PARAM = Causes.forOneValue("Invalid parameter name: %s");
+    private static final Fn1<Cause, String>INVALID_PARAM = Causes.forOneValue("Invalid parameter name: %s");
 
     public static Result<Binding> binding(String param, BindingSource source) {
         if (!param.matches(PARAM_PATTERN.pattern())) {
-            return INVALID_PARAM.apply(param).result();
+            return INVALID_PARAM.apply(param)
+                                .result();
         }
         return Result.success(new Binding(param, source));
     }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/routing/BindingSource.java b/slice/src/main/java/org/pragmatica/aether/slice/routing/BindingSource.java
index 8904a858..233833c4 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/routing/BindingSource.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/routing/BindingSource.java
@@ -71,7 +71,7 @@ public String asString() {
         }
     }
 
-    Fn1<Cause, String> INVALID_BINDING_SOURCE = Causes.forOneValue("Invalid binding source format: %s");
+    Fn1<Cause, String>INVALID_BINDING_SOURCE = Causes.forOneValue("Invalid binding source format: %s");
 
     static Result<BindingSource> parse(String input) {
         if (input.equals("body")) {
@@ -83,27 +83,26 @@ static Result<BindingSource> parse(String input) {
         if (input.equals("key")) {
             return Result.success(new Key());
         }
-
         var dotIndex = input.indexOf('.');
-        if (dotIndex == -1) {
-            return INVALID_BINDING_SOURCE.apply(input).result();
+        if (dotIndex == - 1) {
+            return INVALID_BINDING_SOURCE.apply(input)
+                                         .result();
         }
-
         var prefix = input.substring(0, dotIndex);
         var suffix = input.substring(dotIndex + 1);
-
         if (suffix.isEmpty()) {
-            return INVALID_BINDING_SOURCE.apply(input).result();
+            return INVALID_BINDING_SOURCE.apply(input)
+                                         .result();
         }
-
         return switch (prefix) {
-            case "path" -> Result.success(new PathVar(suffix));
-            case "query" -> Result.success(new QueryVar(suffix));
-            case "header" -> Result.success(new Header(suffix));
-            case "cookie" -> Result.success(new Cookie(suffix));
-            case "request" -> Result.success(new RequestField(suffix));
-            case "metadata" -> Result.success(new Metadata(suffix));
-            default -> INVALID_BINDING_SOURCE.apply(input).result();
+            case"path" -> Result.success(new PathVar(suffix));
+            case"query" -> Result.success(new QueryVar(suffix));
+            case"header" -> Result.success(new Header(suffix));
+            case"cookie" -> Result.success(new Cookie(suffix));
+            case"request" -> Result.success(new RequestField(suffix));
+            case"metadata" -> Result.success(new Metadata(suffix));
+            default -> INVALID_BINDING_SOURCE.apply(input)
+                                             .result();
         };
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/routing/RouteTarget.java b/slice/src/main/java/org/pragmatica/aether/slice/routing/RouteTarget.java
index 711c1e3f..51a367dd 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/routing/RouteTarget.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/routing/RouteTarget.java
@@ -13,49 +13,50 @@ public record RouteTarget(String sliceId, String methodName, List<String> params
     private static final Pattern SLICE_ID_PATTERN = Pattern.compile("^[a-z][a-z0-9-]*$");
     private static final Pattern METHOD_NAME_PATTERN = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
     private static final Pattern PARAM_PATTERN = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_.]*$");
-    private static final Fn1<Cause, String> INVALID_FORMAT = Causes.forOneValue("Invalid route target format: %s");
-    private static final Fn1<Cause, String> INVALID_SLICE_ID = Causes.forOneValue("Invalid slice ID: %s");
-    private static final Fn1<Cause, String> INVALID_METHOD_NAME = Causes.forOneValue("Invalid method name: %s");
-    private static final Fn1<Cause, String> INVALID_PARAM = Causes.forOneValue("Invalid parameter name: %s");
+    private static final Fn1<Cause, String>INVALID_FORMAT = Causes.forOneValue("Invalid route target format: %s");
+    private static final Fn1<Cause, String>INVALID_SLICE_ID = Causes.forOneValue("Invalid slice ID: %s");
+    private static final Fn1<Cause, String>INVALID_METHOD_NAME = Causes.forOneValue("Invalid method name: %s");
+    private static final Fn1<Cause, String>INVALID_PARAM = Causes.forOneValue("Invalid parameter name: %s");
 
     public static Result<RouteTarget> routeTarget(String input) {
         var colonIndex = input.indexOf(':');
-        if (colonIndex == -1) {
-            return INVALID_FORMAT.apply(input).result();
+        if (colonIndex == - 1) {
+            return INVALID_FORMAT.apply(input)
+                                 .result();
         }
-
         var sliceId = input.substring(0, colonIndex);
         var methodPart = input.substring(colonIndex + 1);
-
         var parenIndex = methodPart.indexOf('(');
-        if (parenIndex == -1 || !methodPart.endsWith(")")) {
-            return INVALID_FORMAT.apply(input).result();
+        if (parenIndex == - 1 || !methodPart.endsWith(")")) {
+            return INVALID_FORMAT.apply(input)
+                                 .result();
         }
-
         var methodName = methodPart.substring(0, parenIndex);
         var paramsStr = methodPart.substring(parenIndex + 1, methodPart.length() - 1);
-
         List<String> params = paramsStr.isEmpty()
                               ? List.of()
                               : Arrays.stream(paramsStr.split(","))
                                       .map(String::trim)
                                       .toList();
-
         if (!sliceId.matches(SLICE_ID_PATTERN.pattern())) {
-            return INVALID_SLICE_ID.apply(sliceId).result();
+            return INVALID_SLICE_ID.apply(sliceId)
+                                   .result();
         }
         if (!methodName.matches(METHOD_NAME_PATTERN.pattern())) {
-            return INVALID_METHOD_NAME.apply(methodName).result();
+            return INVALID_METHOD_NAME.apply(methodName)
+                                      .result();
         }
-
-        return validateParams(params).map(__ -> new RouteTarget(sliceId, methodName, params));
+        return validateParams(params)
+               .map(__ -> new RouteTarget(sliceId, methodName, params));
     }
 
     private static Result<List<String>> validateParams(List<String> params) {
         return params.stream()
-                     .filter(param -> !PARAM_PATTERN.matcher(param).matches())
+                     .filter(param -> !PARAM_PATTERN.matcher(param)
+                                                    .matches())
                      .findFirst()
-                     .map(invalid -> INVALID_PARAM.apply(invalid).<List<String>>result())
+                     .map(invalid -> INVALID_PARAM.apply(invalid)
+                                                  .<List<String>> result())
                      .orElse(Result.success(params));
     }
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/routing/SliceSpec.java b/slice/src/main/java/org/pragmatica/aether/slice/routing/SliceSpec.java
index 966b163d..11244aaf 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/routing/SliceSpec.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/routing/SliceSpec.java
@@ -7,11 +7,12 @@
 import org.pragmatica.lang.utils.Causes;
 
 public record SliceSpec(Artifact artifact, int instances) {
-    private static final Fn1<Cause, Integer> INVALID_INSTANCES = Causes.forOneValue("Instance count must be positive: %s");
+    private static final Fn1<Cause, Integer>INVALID_INSTANCES = Causes.forOneValue("Instance count must be positive: %s");
 
     public static Result<SliceSpec> sliceSpec(Artifact artifact, int instances) {
         if (instances <= 0) {
-            return INVALID_INSTANCES.apply(instances).result();
+            return INVALID_INSTANCES.apply(instances)
+                                    .result();
         }
         return Result.success(new SliceSpec(artifact, instances));
     }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
index 54935d1b..7aa6bb18 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
@@ -1,6 +1,5 @@
 package org.pragmatica.aether.slice.serialization;
 
-import org.apache.fury.ThreadSafeFury;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.type.TypeToken;
 import org.pragmatica.net.serialization.Deserializer;
@@ -12,6 +11,8 @@
 
 import java.util.List;
 
+import org.apache.fury.ThreadSafeFury;
+
 /**
  * Fury-based serializer factory provider using singleton pattern.
  * <p>
@@ -19,23 +20,19 @@
  * shared across concurrent method invocations. No pooling required.
  */
 public interface FurySerializerFactoryProvider extends SerializerFactoryProvider {
-
     static FurySerializerFactoryProvider furySerializerFactoryProvider(ClassRegistrator... registrators) {
         record furyProvider(ClassRegistrator[] registrators) implements FurySerializerFactoryProvider {
             @Override
-            public SerializerFactory createFactory(List<TypeToken<?>> typeTokens) {
+            public SerializerFactory createFactory(List<TypeToken< ? >> typeTokens) {
                 // Create single ThreadSafeFury instance for all method invocations
                 ThreadSafeFury fury = FuryFactory.fury(registrators);
-
                 // Create singleton serializer and deserializer
                 Serializer serializer = FurySerializer.furySerializer(registrators);
                 Deserializer deserializer = FuryDeserializer.furyDeserializer(registrators);
-
                 // Return factory that provides same instances (thread-safe)
                 return singletonFactory(serializer, deserializer);
             }
         }
-
         return new furyProvider(registrators);
     }
 
@@ -51,7 +48,6 @@ public Promise<Deserializer> deserializer() {
                 return Promise.success(theDeserializer);
             }
         }
-
         return new singletonFactory(serializer, deserializer);
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
index abccf467..ec8f650a 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
@@ -1,7 +1,5 @@
 package org.pragmatica.aether.slice.serialization;
 
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.util.Pool;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.type.TypeToken;
 import org.pragmatica.lang.utils.Causes;
@@ -16,6 +14,9 @@
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.util.Pool;
+
 /**
  * Kryo-based serializer factory provider using FIFO pooling pattern.
  * <p>
@@ -25,51 +26,41 @@
  * Pool size defaults to 2 * number of processors.
  */
 public interface KryoSerializerFactoryProvider extends SerializerFactoryProvider {
-
     static KryoSerializerFactoryProvider kryoSerializerFactoryProvider(ClassRegistrator... registrators) {
         record kryoProvider(ClassRegistrator[] registrators) implements KryoSerializerFactoryProvider {
             @Override
-            public SerializerFactory createFactory(List<TypeToken<?>> typeTokens) {
+            public SerializerFactory createFactory(List<TypeToken< ? >> typeTokens) {
                 // Create Kryo pool (standard pattern from existing code)
                 Pool<Kryo> kryoPool = KryoPoolFactory.kryoPool(registrators);
-
                 // Create pooled serializers using the Kryo pool
                 Serializer serializer = KryoSerializer.kryoSerializer(registrators);
                 Deserializer deserializer = KryoDeserializer.kryoDeserializer(registrators);
-
                 // Pool size: 2 * processors (same as KryoPoolFactory default)
-                int poolSize = Runtime.getRuntime().availableProcessors() * 2;
-
+                int poolSize = Runtime.getRuntime()
+                                      .availableProcessors() * 2;
                 // Return FIFO pooled factory
                 return pooledFactory(serializer, deserializer, poolSize);
             }
         }
-
         return new kryoProvider(registrators);
     }
 
     private static SerializerFactory pooledFactory(Serializer serializer, Deserializer deserializer, int poolSize) {
         record pooledFactory(
-                BlockingQueue<Serializer> serializerPool,
-                BlockingQueue<Deserializer> deserializerPool
-        ) implements SerializerFactory {
-
+        BlockingQueue<Serializer> serializerPool,
+        BlockingQueue<Deserializer> deserializerPool) implements SerializerFactory {
             @Override
             public Promise<Serializer> serializer() {
                 // Async blocking take from pool
                 return Promise.lift(
-                        Causes::fromThrowable,
-                        serializerPool::take
-                                   );
+                Causes::fromThrowable, serializerPool::take);
             }
 
             @Override
             public Promise<Deserializer> deserializer() {
                 // Async blocking take from pool
                 return Promise.lift(
-                        Causes::fromThrowable,
-                        deserializerPool::take
-                                   );
+                Causes::fromThrowable, deserializerPool::take);
             }
 
             // Release back to pool after use
@@ -81,16 +72,13 @@ void releaseDeserializer(Deserializer d) {
                 deserializerPool.offer(d);
             }
         }
-
         // Initialize pools with instances
         BlockingQueue<Serializer> serializerQueue = new ArrayBlockingQueue<>(poolSize);
         BlockingQueue<Deserializer> deserializerQueue = new ArrayBlockingQueue<>(poolSize);
-
-        for (int i = 0; i < poolSize; i++) {
+        for (int i = 0; i < poolSize; i++ ) {
             serializerQueue.offer(serializer);
             deserializerQueue.offer(deserializer);
         }
-
         return new pooledFactory(serializerQueue, deserializerQueue);
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactoryProvider.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactoryProvider.java
index 8a698302..b7298654 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactoryProvider.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactoryProvider.java
@@ -30,5 +30,5 @@ public interface SerializerFactoryProvider {
      *
      * @return A SerializerFactory instance for this slice
      */
-    SerializerFactory createFactory(List<TypeToken<?>> typeTokens);
+    SerializerFactory createFactory(List<TypeToken< ? >> typeTokens);
 }

From 7d94146555ae6806aaf660b04c8b18a1768c4a8f Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 17:45:24 +0100
Subject: [PATCH 14/26] fix: add request IDs and fix WebSocket state handling
 in HttpServer

---
 .../http/server/NettyHttpServer.java          | 97 +++++++++++--------
 .../http/server/RequestContext.java           |  6 ++
 .../http/server/ResponseWriter.java           |  5 +
 3 files changed, 70 insertions(+), 38 deletions(-)

diff --git a/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java b/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
index e699632e..51362ace 100644
--- a/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
+++ b/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
@@ -9,17 +9,14 @@
 import org.pragmatica.http.websocket.WebSocketHandler;
 import org.pragmatica.http.websocket.WebSocketMessage;
 import org.pragmatica.http.websocket.WebSocketSession;
-import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.net.SocketOptions;
 import org.pragmatica.net.TlsContextFactory;
+import org.pragmatica.utility.IdGenerator;
 
-import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.UUID;
 import java.util.function.BiConsumer;
 
 import io.netty.bootstrap.ServerBootstrap;
@@ -32,6 +29,7 @@
 import io.netty.handler.codec.http.websocketx.*;
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.stream.ChunkedWriteHandler;
+import io.netty.util.AttributeKey;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -138,6 +136,7 @@ private static class HttpServerInitializer extends ChannelInitializer<SocketChan
         private final HttpServerConfig config;
         private final BiConsumer<RequestContext, ResponseWriter> handler;
         private final SslContext sslContext;
+        private final Map<String, WebSocketEndpoint> wsEndpoints;
 
         HttpServerInitializer(HttpServerConfig config,
                               BiConsumer<RequestContext, ResponseWriter> handler,
@@ -145,6 +144,10 @@ private static class HttpServerInitializer extends ChannelInitializer<SocketChan
             this.config = config;
             this.handler = handler;
             this.sslContext = sslContext;
+            this.wsEndpoints = new HashMap<>();
+            for (var endpoint : config.webSocketEndpoints()) {
+                wsEndpoints.put(endpoint.path(), endpoint);
+            }
         }
 
         @Override
@@ -162,25 +165,26 @@ protected void initChannel(SocketChannel ch) {
             for (var endpoint : config.webSocketEndpoints()) {
                 pipeline.addLast(new WebSocketServerProtocolHandler(endpoint.path(), null, true));
             }
-            pipeline.addLast(new HttpRequestHandler(handler, config.webSocketEndpoints()));
+            // Create new handler instance per channel (not @Sharable)
+            pipeline.addLast(new HttpRequestHandler(handler, wsEndpoints));
         }
     }
 
-    @ChannelHandler.Sharable
+    /**
+     * Per-channel HTTP request handler.
+     * NOT @Sharable - each channel gets its own instance to maintain WebSocket state safely.
+     */
     private static class HttpRequestHandler extends SimpleChannelInboundHandler<Object> {
         private static final Logger LOG = LoggerFactory.getLogger(HttpRequestHandler.class);
+        private static final AttributeKey<WebSocketState>WS_STATE = AttributeKey.valueOf("wsState");
 
         private final BiConsumer<RequestContext, ResponseWriter> handler;
         private final Map<String, WebSocketEndpoint> wsEndpoints;
-        private WebSocketHandler currentWsHandler;
-        private NettyWebSocketSession currentWsSession;
 
-        HttpRequestHandler(BiConsumer<RequestContext, ResponseWriter> handler, List<WebSocketEndpoint> endpoints) {
+        HttpRequestHandler(BiConsumer<RequestContext, ResponseWriter> handler,
+                           Map<String, WebSocketEndpoint> wsEndpoints) {
             this.handler = handler;
-            this.wsEndpoints = new HashMap<>();
-            for (var endpoint : endpoints) {
-                wsEndpoints.put(endpoint.path(), endpoint);
-            }
+            this.wsEndpoints = wsEndpoints;
         }
 
         @Override
@@ -198,20 +202,24 @@ private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest reques
             var wsEndpoint = wsEndpoints.get(path);
             if (wsEndpoint != null && isWebSocketUpgrade(request)) {
                 // WebSocket upgrade will be handled by WebSocketServerProtocolHandler
-                // Just set up the handler for later
-                currentWsHandler = wsEndpoint.handler()
-                                             .get();
-                currentWsSession = new NettyWebSocketSession(ctx.channel());
+                // Store handler and session in channel attribute for later use
+                var wsHandler = wsEndpoint.handler()
+                                          .get();
+                var wsSession = new NettyWebSocketSession(ctx.channel());
+                ctx.channel()
+                   .attr(WS_STATE)
+                   .set(new WebSocketState(wsHandler, wsSession));
                 ctx.fireChannelRead(request.retain());
                 return;
             }
-            // Regular HTTP request
-            var requestContext = createRequestContext(request);
-            var responseWriter = new NettyResponseWriter(ctx);
+            // Regular HTTP request - generate request ID
+            var requestId = IdGenerator.generate("req");
+            var requestContext = createRequestContext(requestId, request);
+            var responseWriter = new NettyResponseWriter(ctx, requestId);
             try{
                 handler.accept(requestContext, responseWriter);
             } catch (Exception e) {
-                LOG.error("Error handling request", e);
+                LOG.error("Error handling request {}", requestId, e);
                 responseWriter.error(HttpStatus.INTERNAL_SERVER_ERROR, "Internal Server Error");
             }
         }
@@ -222,33 +230,37 @@ private boolean isWebSocketUpgrade(FullHttpRequest request) {
         }
 
         private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
-            if (currentWsHandler == null) {
+            var state = ctx.channel()
+                           .attr(WS_STATE)
+                           .get();
+            if (state == null) {
                 return;
             }
-            if (currentWsSession == null) {
-                currentWsSession = new NettyWebSocketSession(ctx.channel());
-            }
             if (frame instanceof TextWebSocketFrame textFrame) {
-                currentWsHandler.handle(currentWsSession,
-                                        new WebSocketMessage.Text(textFrame.text()));
+                state.handler.handle(state.session,
+                                     new WebSocketMessage.Text(textFrame.text()));
             }else if (frame instanceof BinaryWebSocketFrame binaryFrame) {
                 var bytes = new byte[binaryFrame.content()
                                                 .readableBytes()];
                 binaryFrame.content()
                            .readBytes(bytes);
-                currentWsHandler.handle(currentWsSession, new WebSocketMessage.Binary(bytes));
+                state.handler.handle(state.session, new WebSocketMessage.Binary(bytes));
             }else if (frame instanceof CloseWebSocketFrame) {
-                currentWsHandler.handle(currentWsSession, new WebSocketMessage.Close());
-                currentWsHandler = null;
-                currentWsSession = null;
+                state.handler.handle(state.session, new WebSocketMessage.Close());
+                ctx.channel()
+                   .attr(WS_STATE)
+                   .set(null);
             }
         }
 
         @Override
         public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
             if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
-                if (currentWsHandler != null && currentWsSession != null) {
-                    currentWsHandler.handle(currentWsSession, new WebSocketMessage.Open());
+                var state = ctx.channel()
+                               .attr(WS_STATE)
+                               .get();
+                if (state != null) {
+                    state.handler.handle(state.session, new WebSocketMessage.Open());
                 }
             }
             super.userEventTriggered(ctx, evt);
@@ -260,7 +272,7 @@ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
             ctx.close();
         }
 
-        private RequestContext createRequestContext(FullHttpRequest request) {
+        private RequestContext createRequestContext(String requestId, FullHttpRequest request) {
             var decoder = new QueryStringDecoder(request.uri());
             var path = decoder.path();
             var method = HttpMethod.from(request.method()
@@ -280,11 +292,17 @@ private RequestContext createRequestContext(FullHttpRequest request) {
             var content = request.content();
             var body = new byte[content.readableBytes()];
             content.readBytes(body);
-            return new NettyRequestContext(method, path, headers, queryParams, body);
+            return new NettyRequestContext(requestId, method, path, headers, queryParams, body);
         }
     }
 
+    /**
+     * WebSocket state stored per channel.
+     */
+    private record WebSocketState(WebSocketHandler handler, NettyWebSocketSession session) {}
+
     private record NettyRequestContext(
+    String requestId,
     HttpMethod method,
     String path,
     Headers headers,
@@ -293,11 +311,13 @@ private record NettyRequestContext(
 
     private static class NettyResponseWriter implements ResponseWriter {
         private final ChannelHandlerContext ctx;
+        private final String requestId;
         private final io.netty.handler.codec.http.HttpHeaders responseHeaders;
         private boolean written = false;
 
-        NettyResponseWriter(ChannelHandlerContext ctx) {
+        NettyResponseWriter(ChannelHandlerContext ctx, String requestId) {
             this.ctx = ctx;
+            this.requestId = requestId;
             this.responseHeaders = new DefaultHttpHeaders();
         }
 
@@ -321,6 +341,8 @@ public void write(HttpStatus status, byte[] body, ContentType contentType) {
                          contentType.headerText());
             response.headers()
                     .set(HttpHeaderNames.CONTENT_LENGTH, body.length);
+            response.headers()
+                    .set(X_REQUEST_ID, requestId);
             response.headers()
                     .add(responseHeaders);
             ctx.writeAndFlush(response)
@@ -334,8 +356,7 @@ private static class NettyWebSocketSession implements WebSocketSession {
 
         NettyWebSocketSession(Channel channel) {
             this.channel = channel;
-            this.id = UUID.randomUUID()
-                          .toString();
+            this.id = IdGenerator.generate("ws");
         }
 
         @Override
diff --git a/common/src/main/java/org/pragmatica/http/server/RequestContext.java b/common/src/main/java/org/pragmatica/http/server/RequestContext.java
index 5080e566..1da00187 100644
--- a/common/src/main/java/org/pragmatica/http/server/RequestContext.java
+++ b/common/src/main/java/org/pragmatica/http/server/RequestContext.java
@@ -8,6 +8,12 @@
  * HTTP request context providing access to request data.
  */
 public interface RequestContext {
+    /**
+     * Unique request ID for tracing and logging.
+     * Format: req_[ulid] (e.g., req_01hq4x2abc...)
+     */
+    String requestId();
+
     /**
      * HTTP method.
      */
diff --git a/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java b/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
index 07ac8c08..c0c7034d 100644
--- a/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
+++ b/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
@@ -13,6 +13,11 @@
  * Each response method can only be called once per request.
  */
 public interface ResponseWriter {
+    /**
+     * Standard header name for request ID tracing.
+     */
+    String X_REQUEST_ID = "X-Request-Id";
+
     /**
      * Write response with status, body, and content type.
      */

From 7ccdf9ba3db4495210e382eddba47f5d8dc07a9c Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 18:37:28 +0100
Subject: [PATCH 15/26] docs: add Aspect Provider slice to infrastructure
 services plan

---
 docs/infrastructure-services.md | 66 +++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/docs/infrastructure-services.md b/docs/infrastructure-services.md
index 119f6d10..6d75deea 100644
--- a/docs/infrastructure-services.md
+++ b/docs/infrastructure-services.md
@@ -137,6 +137,72 @@ public record CacheConfig(
 ) {}
 ```
 
+### Aspect Provider Slice (Future)
+
+Infrastructure slice exposing factories for cross-cutting concerns. Provides runtime-injectable aspects following JBCT patterns.
+
+**Aspects:**
+
+| Aspect | Purpose |
+|--------|---------|
+| Logging | Structured logging with correlation IDs, entry/exit tracing |
+| Retry | Configurable retry policies with backoff strategies |
+| Circuit Breaker | Fail-fast with configurable thresholds and recovery |
+
+**API Design:**
+
+```java
+public interface AspectProvider {
+    // Logging aspect factory
+    <I, O> Fn1<Promise<O>, I> withLogging(Fn1<Promise<O>, I> fn, LogConfig config);
+
+    // Retry aspect factory
+    <I, O> Fn1<Promise<O>, I> withRetry(Fn1<Promise<O>, I> fn, RetryConfig config);
+
+    // Circuit breaker aspect factory
+    <I, O> Fn1<Promise<O>, I> withCircuitBreaker(Fn1<Promise<O>, I> fn, CircuitBreakerConfig config);
+}
+
+public record RetryConfig(
+    int maxAttempts,
+    Duration initialDelay,
+    double backoffMultiplier,
+    Set<Class<? extends Cause>> retryableErrors
+) {}
+
+public record CircuitBreakerConfig(
+    int failureThreshold,      // Failures before opening
+    Duration openDuration,      // Time to stay open
+    int halfOpenPermits,        // Requests allowed in half-open
+    double successThreshold     // Success rate to close
+) {}
+```
+
+**Usage in Slice:**
+
+```java
+// Inject via SliceBridge
+var aspectProvider = bridge.resolve(AspectProvider.class);
+
+// Wrap adapter leaf with retry
+var saveUser = aspectProvider.withRetry(
+    userRepository::save,
+    new RetryConfig(3, Duration.ofMillis(100), 2.0, Set.of(TransientError.class))
+);
+
+// Wrap external call with circuit breaker
+var callPayment = aspectProvider.withCircuitBreaker(
+    paymentGateway::charge,
+    new CircuitBreakerConfig(5, Duration.ofSeconds(30), 3, 0.5)
+);
+```
+
+**Benefits:**
+- Consistent cross-cutting behavior across slices
+- Runtime-configurable without slice redeployment
+- Cluster-wide circuit breaker state (via DHT)
+- Metrics integration for observability
+
 ## Foundation: Distributed Hash Table
 
 All infrastructure services share a common DHT foundation with consistent hashing.

From 0d1761df0efb44cd8ba7c5515cd3a326efd267b6 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Tue, 30 Dec 2025 20:29:01 +0100
Subject: [PATCH 16/26] feat: production hardening with TLS, health endpoint,
 JBCT fixes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Add TLS support via AetherNodeConfig.withTls()
- Propagate TLS to ManagementServer, HttpRouter, NettyClusterNetwork
- Enhance /health endpoint with status, quorum, nodeCount, sliceCount
- Add RingBuffer utility for O(1) metrics storage
- Replace CopyOnWriteArrayList with RingBuffer in MetricsCollector
- Fix JBCT violations: HttpMethod, PathPattern, SliceManifest, Main
- Rename create() to typeName() in DHTNode, SliceRegistry
- Add operational runbooks for incidents, scaling, troubleshooting

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  11 +
 .../net/netty/NettyClusterNetwork.java        |  13 +-
 .../cluster/topology/TopologyManager.java     |   6 +
 .../topology/ip/TcpTopologyManager.java       |   7 +
 .../cluster/topology/ip/TopologyConfig.java   |  24 +-
 .../main/java/org/pragmatica/dht/DHTNode.java |   8 +-
 .../org/pragmatica/utility/RingBuffer.java    | 154 +++++++++++
 docs/runbooks/README.md                       |  61 +++++
 docs/runbooks/deployment.md                   | 227 +++++++++++++++++
 docs/runbooks/incident-response.md            | 148 +++++++++++
 docs/runbooks/scaling.md                      | 138 ++++++++++
 docs/runbooks/troubleshooting.md              | 240 ++++++++++++++++++
 .../main/java/org/pragmatica/aether/Main.java |  13 +-
 .../aether/api/ManagementServer.java          |  58 ++++-
 .../pragmatica/aether/http/HttpMethod.java    |  20 +-
 .../pragmatica/aether/http/HttpRouter.java    |  49 ++--
 .../pragmatica/aether/http/PathPattern.java   |  20 +-
 .../pragmatica/aether/http/RouteRegistry.java |  30 ++-
 .../pragmatica/aether/http/RouterConfig.java  |  24 +-
 .../aether/metrics/MetricsCollector.java      |  28 +-
 .../pragmatica/aether/node/AetherNode.java    |  24 +-
 .../aether/node/AetherNodeConfig.java         |  28 +-
 .../aether/http/PathPatternTest.java          | 146 ++++++-----
 .../aether/slice/SliceManifest.java           |  29 ++-
 .../slice/dependency/SliceRegistry.java       |   2 +-
 .../aether/slice/SliceStoreImplTest.java      |   2 +-
 .../slice/dependency/SliceRegistryTest.java   |  22 +-
 27 files changed, 1358 insertions(+), 174 deletions(-)
 create mode 100644 common/src/main/java/org/pragmatica/utility/RingBuffer.java
 create mode 100644 docs/runbooks/README.md
 create mode 100644 docs/runbooks/deployment.md
 create mode 100644 docs/runbooks/incident-response.md
 create mode 100644 docs/runbooks/scaling.md
 create mode 100644 docs/runbooks/troubleshooting.md

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8fc9339f..3141a681 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,8 +13,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Alert management** - Configurable thresholds with in-memory alert tracking
 - **Dashboard tabs** - Metrics, Slices, History, and Alerts views
 - **New API endpoints** - `/slices/status`, `/invocation-metrics`, `/thresholds`, `/alerts`
+- **TLS support** - Added `withTls()` to AetherNodeConfig, propagated to ManagementServer, HttpRouter, and cluster network
+- **Enhanced /health endpoint** - Returns status (healthy/degraded/unhealthy), quorum, nodeCount, sliceCount
+- **RingBuffer utility** - Thread-safe ring buffer with O(1) add and fixed memory footprint
+- **Operational runbooks** - Added docs/runbooks/ with incident-response, scaling, troubleshooting, deployment guides
 
 ### Changed
+- **MetricsCollector** - Use RingBuffer instead of CopyOnWriteArrayList for historical metrics (7200 capacity)
+- **HttpMethod.fromString()** - Returns `Option<HttpMethod>` instead of throwing
+- **PathPattern.compile()** - Returns `Result<PathPattern>` instead of throwing
+- **SliceManifest.readManifest()** - Returns `Result<Manifest>` instead of throwing
+- **Main.parsePeerAddress()** - Returns `Optional<NodeInfo>` instead of throwing
+- **DHTNode.create()** - Renamed to `DHTNode.dhtNode()` (JBCT naming convention)
+- **SliceRegistry.create()** - Renamed to `SliceRegistry.sliceRegistry()` (JBCT naming convention)
 
 ### Fixed
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 380f442c..6f22728e 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -19,6 +19,7 @@
 import org.pragmatica.message.Message;
 import org.pragmatica.message.MessageRouter;
 import org.pragmatica.net.Server;
+import org.pragmatica.net.ServerConfig;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
@@ -163,10 +164,14 @@ private void peerDisconnected(Channel channel) {
     @Override
     public Promise<Unit> start() {
         if (isRunning.compareAndSet(false, true)) {
-            return Server.server("NettyClusterNetwork",
-                                 self.address()
-                                     .port(),
-                                 handlers)
+            var serverConfig = ServerConfig.serverConfig("NettyClusterNetwork",
+                                                         self.address()
+                                                             .port());
+            // Apply TLS if configured
+            var effectiveConfig = topologyManager.tls()
+                                                 .map(serverConfig::withTls)
+                                                 .or(serverConfig);
+            return Server.server(effectiveConfig, handlers)
                          .onSuccess(NettyClusterNetwork.this.server::set)
                          .onFailure(_ -> isRunning.set(false))
                          .mapToUnit();
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
index 28d9abea..1f6d25d1 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
@@ -4,6 +4,7 @@
 import org.pragmatica.cluster.net.NodeInfo;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
+import org.pragmatica.net.TlsConfig;
 
 import java.net.SocketAddress;
 
@@ -37,4 +38,9 @@ default int fPlusOne() {
     void stop();
 
     TimeSpan pingInterval();
+
+    /// TLS configuration for cluster communication (empty for plain TCP).
+    default Option<TlsConfig> tls() {
+        return Option.empty();
+    }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
index cef905d1..736ca529 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
@@ -11,6 +11,7 @@
 import org.pragmatica.message.MessageReceiver;
 import org.pragmatica.message.MessageRouter;
 import org.pragmatica.net.NodeAddress;
+import org.pragmatica.net.TlsConfig;
 
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
@@ -185,6 +186,12 @@ public TimeSpan pingInterval() {
                 return config()
                        .pingInterval();
             }
+
+            @Override
+            public Option<TlsConfig> tls() {
+                return config()
+                       .tls();
+            }
         }
         return new Manager(new ConcurrentHashMap<>(),
                            new ConcurrentHashMap<>(),
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
index e26157d2..a85b0fcb 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
@@ -2,11 +2,33 @@
 
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
+import org.pragmatica.net.TlsConfig;
 
 import java.util.List;
 
+/**
+ * Configuration for cluster topology management.
+ *
+ * @param self                   This node's ID
+ * @param reconciliationInterval How often to reconcile cluster state
+ * @param pingInterval           How often to ping other nodes
+ * @param coreNodes              Initial cluster members
+ * @param tls                    TLS configuration for cluster communication (empty for plain TCP)
+ */
 public record TopologyConfig(NodeId self,
                              TimeSpan reconciliationInterval,
                              TimeSpan pingInterval,
-                             List<NodeInfo> coreNodes) {}
+                             List<NodeInfo> coreNodes,
+                             Option<TlsConfig> tls) {
+    /**
+     * Create TopologyConfig without TLS (backward compatible).
+     */
+    public TopologyConfig(NodeId self,
+                          TimeSpan reconciliationInterval,
+                          TimeSpan pingInterval,
+                          List<NodeInfo> coreNodes) {
+        this(self, reconciliationInterval, pingInterval, coreNodes, Option.empty());
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/dht/DHTNode.java b/common/src/main/java/org/pragmatica/dht/DHTNode.java
index ad04d832..d882d5e2 100644
--- a/common/src/main/java/org/pragmatica/dht/DHTNode.java
+++ b/common/src/main/java/org/pragmatica/dht/DHTNode.java
@@ -33,10 +33,10 @@ private DHTNode(N nodeId, StorageEngine storage, ConsistentHashRing<N> ring, DHT
      * @param ring    consistent hash ring for routing
      * @param config  DHT configuration
      */
-    public static <N extends Comparable<N>> DHTNode<N> create(N nodeId,
-                                                              StorageEngine storage,
-                                                              ConsistentHashRing<N> ring,
-                                                              DHTConfig config) {
+    public static <N extends Comparable<N>> DHTNode<N> dhtNode(N nodeId,
+                                                               StorageEngine storage,
+                                                               ConsistentHashRing<N> ring,
+                                                               DHTConfig config) {
         return new DHTNode<>(nodeId, storage, ring, config);
     }
 
diff --git a/common/src/main/java/org/pragmatica/utility/RingBuffer.java b/common/src/main/java/org/pragmatica/utility/RingBuffer.java
new file mode 100644
index 00000000..4defefdb
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/utility/RingBuffer.java
@@ -0,0 +1,154 @@
+package org.pragmatica.utility;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Predicate;
+
+/**
+ * Thread-safe ring buffer with fixed capacity.
+ *
+ * <p>Provides O(1) add operations and fixed memory footprint.
+ * When the buffer is full, oldest elements are overwritten.
+ *
+ * @param <T> element type
+ */
+public final class RingBuffer<T> {
+    private final Object[] buffer;
+    private final int capacity;
+    private final ReentrantLock lock = new ReentrantLock();
+    private int head;
+
+    // Next write position
+    private int size;
+
+    // Current number of elements
+    private RingBuffer(int capacity) {
+        if (capacity <= 0) {
+            throw new IllegalArgumentException("Capacity must be positive");
+        }
+        this.capacity = capacity;
+        this.buffer = new Object[capacity];
+        this.head = 0;
+        this.size = 0;
+    }
+
+    /**
+     * Create a new ring buffer with the specified capacity.
+     */
+    public static <T> RingBuffer<T> ringBuffer(int capacity) {
+        return new RingBuffer<>(capacity);
+    }
+
+    /**
+     * Add an element to the buffer. If full, overwrites the oldest element.
+     */
+    public void add(T element) {
+        lock.lock();
+        try{
+            buffer[head] = element;
+            head = (head + 1) % capacity;
+            if (size < capacity) {
+                size++ ;
+            }
+        } finally{
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Get all elements in order from oldest to newest.
+     */
+    public List<T> toList() {
+        lock.lock();
+        try{
+            var result = new ArrayList<T>(size);
+            if (size == 0) {
+                return result;
+            }
+            // Start from the oldest element
+            int start = (size < capacity)
+                        ? 0
+                        : head;
+            for (int i = 0; i < size; i++ ) {
+                int idx = (start + i) % capacity;
+                @SuppressWarnings("unchecked")
+                T element = (T) buffer[idx];
+                result.add(element);
+            }
+            return result;
+        } finally{
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Get all elements that match the predicate, in order from oldest to newest.
+     */
+    public List<T> filter(Predicate<T> predicate) {
+        lock.lock();
+        try{
+            var result = new ArrayList<T>();
+            if (size == 0) {
+                return result;
+            }
+            // Start from the oldest element
+            int start = (size < capacity)
+                        ? 0
+                        : head;
+            for (int i = 0; i < size; i++ ) {
+                int idx = (start + i) % capacity;
+                @SuppressWarnings("unchecked")
+                T element = (T) buffer[idx];
+                if (predicate.test(element)) {
+                    result.add(element);
+                }
+            }
+            return result;
+        } finally{
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Get the current number of elements.
+     */
+    public int size() {
+        lock.lock();
+        try{
+            return size;
+        } finally{
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Check if the buffer is empty.
+     */
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    /**
+     * Get the maximum capacity.
+     */
+    public int capacity() {
+        return capacity;
+    }
+
+    /**
+     * Clear all elements.
+     */
+    public void clear() {
+        lock.lock();
+        try{
+            for (int i = 0; i < capacity; i++ ) {
+                buffer[i] = null;
+            }
+            head = 0;
+            size = 0;
+        } finally{
+            lock.unlock();
+        }
+    }
+}
diff --git a/docs/runbooks/README.md b/docs/runbooks/README.md
new file mode 100644
index 00000000..09465ee5
--- /dev/null
+++ b/docs/runbooks/README.md
@@ -0,0 +1,61 @@
+# Aether Operational Runbooks
+
+Operational procedures for managing Aether clusters in production.
+
+## Runbooks
+
+| Runbook | Description |
+|---------|-------------|
+| [Incident Response](incident-response.md) | Procedures for handling production incidents |
+| [Scaling](scaling.md) | Manual scaling procedures for nodes and slices |
+| [Troubleshooting](troubleshooting.md) | Common issues and diagnostic steps |
+| [Deployment](deployment.md) | Deployment and upgrade procedures |
+
+## Quick Reference
+
+### Health Check Endpoints
+
+Each node exposes a management API (default port 8080):
+
+```bash
+# Health status
+curl http://node:8080/health
+
+# Node metrics
+curl http://node:8080/metrics
+
+# Cluster status
+curl http://node:8080/cluster/status
+```
+
+### CLI Commands
+
+```bash
+# Connect to cluster
+aether-cli --host node1:8080
+
+# Check cluster health
+aether> status
+
+# List deployed slices
+aether> slices list
+
+# Deploy a slice
+aether> deploy org.example:my-slice:1.0.0
+```
+
+### Key Metrics to Monitor
+
+- `cpu.usage` - Node CPU utilization (0.0-1.0)
+- `heap.usage` - Heap memory utilization (0.0-1.0)
+- `method.*.calls` - Request count per method
+- `method.*.duration.avg` - Average response time per method
+
+### Alert Thresholds
+
+| Metric | Warning | Critical |
+|--------|---------|----------|
+| CPU usage | > 70% | > 90% |
+| Heap usage | > 75% | > 90% |
+| Response time | > 500ms | > 2000ms |
+| Quorum | degraded | lost |
diff --git a/docs/runbooks/deployment.md b/docs/runbooks/deployment.md
new file mode 100644
index 00000000..9870c4a7
--- /dev/null
+++ b/docs/runbooks/deployment.md
@@ -0,0 +1,227 @@
+# Deployment Runbook
+
+## Slice Deployment
+
+### Deploy a New Slice
+
+1. **Publish artifact to repository**
+   ```bash
+   mvn deploy -DaltDeploymentRepository=releases::http://repo.example.com/releases
+   ```
+
+2. **Create blueprint (first time only)**
+   ```bash
+   aether-cli --host node1:8080
+   aether> blueprint create org.example:my-slice:1.0.0 --instances=3
+   ```
+
+3. **Verify deployment**
+   ```bash
+   aether> slices list | grep my-slice
+   # Should show 3 ACTIVE instances
+   ```
+
+4. **Test endpoints**
+   ```bash
+   curl http://node1:8080/api/my-slice/health
+   ```
+
+### Update a Slice (Rolling Update)
+
+1. **Publish new version**
+   ```bash
+   mvn deploy
+   ```
+
+2. **Update blueprint to new version**
+   ```bash
+   aether> blueprint update org.example:my-slice:1.1.0 --instances=3
+   ```
+
+3. **Monitor rollout**
+   ```bash
+   watch -n 2 'aether-cli --host node1:8080 -c "slices list" | grep my-slice'
+   ```
+
+   The cluster will:
+   - Deploy new instances first
+   - Activate new instances
+   - Deactivate old instances
+   - Unload old instances
+
+4. **Verify new version active**
+   ```bash
+   curl http://node1:8080/api/my-slice/version
+   ```
+
+### Rollback
+
+1. **Update blueprint to previous version**
+   ```bash
+   aether> blueprint update org.example:my-slice:1.0.0 --instances=3
+   ```
+
+2. **Verify rollback complete**
+   ```bash
+   aether> slices list | grep my-slice
+   # Should show 1.0.0 version
+   ```
+
+## Node Deployment
+
+### Deploy a New Node
+
+1. **Prepare the server**
+   ```bash
+   # Install Java 21+
+   apt install openjdk-21-jre
+
+   # Create aether user
+   useradd -r -s /bin/false aether
+   ```
+
+2. **Install Aether**
+   ```bash
+   mkdir -p /opt/aether
+   cp aether-node.jar /opt/aether/
+   chown -R aether:aether /opt/aether
+   ```
+
+3. **Configure systemd service**
+   ```bash
+   cat > /etc/systemd/system/aether.service << 'EOF'
+   [Unit]
+   Description=Aether Node
+   After=network.target
+
+   [Service]
+   Type=simple
+   User=aether
+   ExecStart=/usr/bin/java -Xmx4g -jar /opt/aether/aether-node.jar \
+     --node-id=${HOSTNAME} \
+     --port=8090 \
+     --peers=node1:8090,node2:8090,node3:8090
+   Restart=always
+   RestartSec=10
+
+   [Install]
+   WantedBy=multi-user.target
+   EOF
+   ```
+
+4. **Start service**
+   ```bash
+   systemctl daemon-reload
+   systemctl enable aether
+   systemctl start aether
+   ```
+
+5. **Verify node joined cluster**
+   ```bash
+   curl http://localhost:8080/health
+   ```
+
+### Upgrade Aether Version
+
+Rolling upgrade procedure (one node at a time):
+
+1. **Verify cluster health**
+   ```bash
+   curl http://node1:8080/health
+   # Must show quorum=true
+   ```
+
+2. **For each node (one at a time):**
+
+   a. Stop the node
+   ```bash
+   systemctl stop aether
+   ```
+
+   b. Backup current version
+   ```bash
+   cp /opt/aether/aether-node.jar /opt/aether/aether-node.jar.backup
+   ```
+
+   c. Deploy new version
+   ```bash
+   cp aether-node-new.jar /opt/aether/aether-node.jar
+   ```
+
+   d. Start node
+   ```bash
+   systemctl start aether
+   ```
+
+   e. Wait for node to rejoin cluster
+   ```bash
+   while ! curl -s http://localhost:8080/health | grep -q '"quorum":true'; do
+     sleep 5
+   done
+   ```
+
+   f. Verify cluster health before proceeding to next node
+   ```bash
+   curl http://node1:8080/health
+   ```
+
+3. **Verify all nodes on new version**
+   ```bash
+   for node in node1 node2 node3; do
+     echo -n "$node: "
+     curl -s http://$node:8080/info | jq -r '.version'
+   done
+   ```
+
+## TLS Configuration
+
+### Enable TLS for New Cluster
+
+1. **Generate certificates**
+   ```bash
+   # Using keytool for self-signed (dev/test only)
+   keytool -genkeypair -alias aether -keyalg RSA -keysize 2048 \
+     -keystore keystore.p12 -storetype PKCS12 \
+     -validity 365 -dname "CN=aether,O=Example"
+
+   # Or use your CA-signed certificates
+   ```
+
+2. **Configure node with TLS**
+   ```java
+   var tlsConfig = TlsConfig.fromFiles(
+       "/path/to/keystore.p12",
+       "keystorePassword",
+       "/path/to/truststore.p12",
+       "truststorePassword"
+   );
+
+   var config = AetherNodeConfig.aetherNodeConfig(...)
+                                .withTls(tlsConfig);
+   ```
+
+3. **Verify TLS is active**
+   ```bash
+   # Should show HTTPS
+   curl -k https://node1:8080/health
+   ```
+
+## Deployment Checklist
+
+### Pre-Deployment
+- [ ] Artifact published to repository
+- [ ] New version tested in staging
+- [ ] Rollback plan documented
+- [ ] Monitoring alerts configured
+
+### During Deployment
+- [ ] Cluster health verified
+- [ ] Deployment initiated
+- [ ] Rollout monitored
+- [ ] Functional tests passed
+
+### Post-Deployment
+- [ ] All instances active
+- [ ] Endpoints responding
+- [ ] No errors in logs
+- [ ] Metrics within normal range
diff --git a/docs/runbooks/incident-response.md b/docs/runbooks/incident-response.md
new file mode 100644
index 00000000..4946e12a
--- /dev/null
+++ b/docs/runbooks/incident-response.md
@@ -0,0 +1,148 @@
+# Incident Response Runbook
+
+## Severity Levels
+
+| Level | Description | Response Time | Example |
+|-------|-------------|---------------|---------|
+| SEV1 | Complete outage | Immediate | Cluster unreachable, quorum lost |
+| SEV2 | Partial outage | 15 min | Single node down, slice unavailable |
+| SEV3 | Degraded | 1 hour | High latency, resource pressure |
+| SEV4 | Minor | Next business day | Non-critical errors in logs |
+
+## Initial Assessment
+
+### 1. Check Cluster Health
+
+```bash
+# Quick health check from any node
+curl http://node1:8080/health
+
+# Expected healthy response:
+# {"status":"healthy","quorum":true,"nodeCount":3,"sliceCount":5}
+
+# Degraded response (no slices):
+# {"status":"degraded","quorum":true,"nodeCount":3,"sliceCount":0}
+
+# Unhealthy response (no quorum):
+# {"status":"unhealthy","quorum":false,"nodeCount":1,"sliceCount":2}
+```
+
+### 2. Check Individual Nodes
+
+```bash
+# Check each node
+for node in node1 node2 node3; do
+  echo "=== $node ==="
+  curl -s http://$node:8080/health || echo "UNREACHABLE"
+done
+```
+
+### 3. Check Logs
+
+```bash
+# Recent errors
+grep -i error /var/log/aether/aether.log | tail -50
+
+# Consensus issues
+grep -i "quorum\|leader\|rabia" /var/log/aether/aether.log | tail -50
+```
+
+## Common Incidents
+
+### Quorum Lost
+
+**Symptoms:** Health check returns `quorum: false`, consensus operations fail
+
+**Diagnosis:**
+```bash
+# Count reachable nodes
+for node in node1 node2 node3; do
+  curl -s http://$node:8080/health && echo " - $node OK"
+done | grep OK | wc -l
+```
+
+**Resolution:**
+1. Identify unreachable nodes
+2. Check network connectivity between nodes
+3. Restart unresponsive nodes
+4. Verify cluster port (default: 8090) is accessible
+
+### Node Unresponsive
+
+**Symptoms:** Node doesn't respond to health checks, other nodes report it as disconnected
+
+**Diagnosis:**
+```bash
+# Check process
+ssh node1 "ps aux | grep aether"
+
+# Check port binding
+ssh node1 "netstat -tlnp | grep 8080"
+
+# Check disk space
+ssh node1 "df -h"
+
+# Check memory
+ssh node1 "free -m"
+```
+
+**Resolution:**
+1. If process is running but unresponsive, collect thread dump then restart
+2. If process crashed, check logs and restart
+3. If resource exhaustion, free resources then restart
+
+### Slice Deployment Stuck
+
+**Symptoms:** Slice stays in LOADING or ACTIVATING state
+
+**Diagnosis:**
+```bash
+# Check slice state
+curl http://node1:8080/slices | jq '.[] | select(.state != "ACTIVE")'
+
+# Check deployment logs
+grep -i "slice\|artifact" /var/log/aether/aether.log | tail -100
+```
+
+**Resolution:**
+1. Check artifact is available in repository
+2. Verify slice dependencies are satisfied
+3. Force undeploy and redeploy if stuck:
+   ```bash
+   aether> undeploy org.example:stuck-slice:1.0.0 --force
+   aether> deploy org.example:stuck-slice:1.0.0
+   ```
+
+### High Latency
+
+**Symptoms:** Slow response times, `method.*.duration.avg` metrics elevated
+
+**Diagnosis:**
+```bash
+# Check CPU and memory
+curl http://node1:8080/metrics | jq '.["cpu.usage"], .["heap.usage"]'
+
+# Check method-level latency
+curl http://node1:8080/metrics | jq 'to_entries | .[] | select(.key | contains("duration.avg"))'
+```
+
+**Resolution:**
+1. If CPU high: scale out (add nodes) or reduce load
+2. If heap high: increase heap or restart nodes
+3. If specific method slow: investigate slice implementation
+
+## Escalation
+
+| Severity | First Responder | Escalate To |
+|----------|-----------------|-------------|
+| SEV1 | On-call engineer | Engineering lead + management |
+| SEV2 | On-call engineer | Team lead |
+| SEV3 | On-call engineer | - |
+| SEV4 | Any team member | - |
+
+## Post-Incident
+
+1. Document timeline and actions taken
+2. Identify root cause
+3. Create follow-up tickets for improvements
+4. Update runbooks if needed
diff --git a/docs/runbooks/scaling.md b/docs/runbooks/scaling.md
new file mode 100644
index 00000000..4e0fdbce
--- /dev/null
+++ b/docs/runbooks/scaling.md
@@ -0,0 +1,138 @@
+# Scaling Runbook
+
+## Scaling Principles
+
+1. **Odd node counts** - Use 3, 5, or 7 nodes for quorum-based consensus
+2. **Horizontal first** - Scale nodes before scaling up individual nodes
+3. **Gradual changes** - Add/remove one node at a time
+4. **Verify quorum** - Always verify quorum health after changes
+
+## Adding a Node
+
+### Prerequisites
+- New node has Aether installed
+- Network connectivity to existing nodes
+- TLS certificates (if cluster uses TLS)
+
+### Procedure
+
+1. **Start new node with cluster configuration**
+   ```bash
+   java -jar aether-node.jar \
+     --node-id=node4 \
+     --port=8090 \
+     --peers=node1:8090,node2:8090,node3:8090
+   ```
+
+2. **Verify node joined cluster**
+   ```bash
+   # On existing node
+   curl http://node1:8080/cluster/status
+   # Should show node4 in the node list
+   ```
+
+3. **Verify quorum maintained**
+   ```bash
+   curl http://node1:8080/health
+   # quorum should be true
+   ```
+
+4. **Monitor for slice rebalancing**
+   ```bash
+   # Watch slice distribution
+   watch -n 5 'curl -s http://node1:8080/slices | jq "group_by(.nodeId) | map({node: .[0].nodeId, count: length})"'
+   ```
+
+## Removing a Node
+
+### Prerequisites
+- Cluster has enough nodes to maintain quorum after removal
+- No unique slice instances on the node being removed
+
+### Procedure
+
+1. **Verify quorum will be maintained**
+   ```bash
+   # Current node count
+   curl http://node1:8080/health | jq '.nodeCount'
+   # Must be > 2 after removal for 3-node quorum
+   ```
+
+2. **Drain slices from node (if possible)**
+   ```bash
+   # Graceful shutdown will attempt to migrate slices
+   curl -X POST http://node4:8080/admin/drain
+   ```
+
+3. **Stop the node**
+   ```bash
+   # On node4
+   kill -TERM $(pgrep -f aether-node)
+   ```
+
+4. **Verify remaining cluster health**
+   ```bash
+   curl http://node1:8080/health
+   # quorum should still be true
+   ```
+
+## Scaling Slices
+
+### Increase Slice Instances
+
+1. **Update blueprint**
+   ```bash
+   aether> blueprint update org.example:my-slice:1.0.0 --instances=5
+   ```
+
+2. **Verify deployment**
+   ```bash
+   aether> slices list | grep my-slice
+   # Should show 5 instances
+   ```
+
+### Decrease Slice Instances
+
+1. **Update blueprint**
+   ```bash
+   aether> blueprint update org.example:my-slice:1.0.0 --instances=2
+   ```
+
+2. **Verify deactivation**
+   ```bash
+   # Watch instances decrease
+   watch -n 2 'aether-cli --host node1:8080 -c "slices list" | grep my-slice'
+   ```
+
+## Capacity Planning
+
+### Node Sizing Guidelines
+
+| Workload | CPU | Memory | Nodes |
+|----------|-----|--------|-------|
+| Development | 2 cores | 4 GB | 1-3 |
+| Small production | 4 cores | 8 GB | 3 |
+| Medium production | 8 cores | 16 GB | 5 |
+| Large production | 16 cores | 32 GB | 7+ |
+
+### When to Scale
+
+**Scale out (add nodes) when:**
+- CPU usage consistently > 70% across nodes
+- Response latency increasing
+- Need to increase slice capacity
+
+**Scale in (remove nodes) when:**
+- CPU usage consistently < 30% across nodes
+- Cost optimization needed
+- Minimum 3 nodes for production
+
+### Monitoring Thresholds
+
+```bash
+# Set up alerts for these conditions
+cpu.usage > 0.7        # Warning: consider scaling
+cpu.usage > 0.9        # Critical: scale immediately
+heap.usage > 0.8       # Warning: memory pressure
+quorum = false         # Critical: cluster degraded
+```
diff --git a/docs/runbooks/troubleshooting.md b/docs/runbooks/troubleshooting.md
new file mode 100644
index 00000000..ef134ef6
--- /dev/null
+++ b/docs/runbooks/troubleshooting.md
@@ -0,0 +1,240 @@
+# Troubleshooting Runbook
+
+## Diagnostic Commands
+
+### Cluster Health
+
+```bash
+# Overall health
+curl http://node:8080/health
+
+# Detailed cluster status
+curl http://node:8080/cluster/status
+
+# Node-specific metrics
+curl http://node:8080/metrics
+```
+
+### Slice Status
+
+```bash
+# List all slices
+curl http://node:8080/slices
+
+# Slice details
+curl http://node:8080/slices/org.example:my-slice:1.0.0
+
+# Active routes
+curl http://node:8080/routes
+```
+
+### Log Analysis
+
+```bash
+# Recent errors
+grep -i "error\|exception\|fail" /var/log/aether/aether.log | tail -100
+
+# Consensus activity
+grep -i "rabia\|propose\|commit" /var/log/aether/aether.log | tail -50
+
+# Slice lifecycle
+grep -i "load\|activate\|deactivate" /var/log/aether/aether.log | tail -50
+```
+
+## Common Issues
+
+### Issue: Node Won't Start
+
+**Symptoms:** Process exits immediately or fails to bind ports
+
+**Checklist:**
+1. Check port availability
+   ```bash
+   netstat -tlnp | grep -E "8080|8090"
+   ```
+
+2. Check Java version (requires Java 21+)
+   ```bash
+   java -version
+   ```
+
+3. Check file permissions
+   ```bash
+   ls -la /var/lib/aether/
+   ```
+
+4. Check logs for startup errors
+   ```bash
+   tail -100 /var/log/aether/aether.log
+   ```
+
+### Issue: Nodes Can't Connect to Each Other
+
+**Symptoms:** Quorum not established, nodes report each other as disconnected
+
+**Checklist:**
+1. Verify network connectivity
+   ```bash
+   # From node1 to node2
+   nc -zv node2 8090
+   ```
+
+2. Check firewall rules
+   ```bash
+   iptables -L -n | grep 8090
+   ```
+
+3. Verify TLS configuration (if using TLS)
+   ```bash
+   openssl s_client -connect node2:8090
+   ```
+
+4. Check peer configuration
+   ```bash
+   # Verify --peers argument matches actual node addresses
+   ps aux | grep aether | grep peers
+   ```
+
+### Issue: Slice Won't Deploy
+
+**Symptoms:** Slice stays in LOADING state, deployment errors in logs
+
+**Checklist:**
+1. Verify artifact exists in repository
+   ```bash
+   curl http://repository/org/example/my-slice/1.0.0/my-slice-1.0.0.jar -I
+   ```
+
+2. Check artifact format
+   ```bash
+   # JAR must have Slice-Class manifest attribute
+   unzip -p my-slice-1.0.0.jar META-INF/MANIFEST.MF | grep Slice
+   ```
+
+3. Check for class loading errors
+   ```bash
+   grep -i "classnotfound\|linkage\|nosuchmethod" /var/log/aether/aether.log
+   ```
+
+4. Verify dependencies
+   ```bash
+   # List dependencies in slice JAR
+   jar tf my-slice-1.0.0.jar | grep -v "^META"
+   ```
+
+### Issue: Slice Activation Fails
+
+**Symptoms:** Slice moves from LOADED to FAILED during activation
+
+**Checklist:**
+1. Check activation logs
+   ```bash
+   grep -i "activat\|FAILED" /var/log/aether/aether.log | tail -50
+   ```
+
+2. Verify slice's start() method doesn't throw
+   ```bash
+   # Look for exception during start
+   grep -A 10 "Error in slice start" /var/log/aether/aether.log
+   ```
+
+3. Check resource availability (ports, files, connections)
+
+### Issue: High Memory Usage
+
+**Symptoms:** Heap usage > 80%, OutOfMemoryError in logs
+
+**Checklist:**
+1. Check current heap usage
+   ```bash
+   curl http://node:8080/metrics | jq '.["heap.used"], .["heap.max"]'
+   ```
+
+2. Generate heap dump
+   ```bash
+   jmap -dump:format=b,file=heap.hprof $(pgrep -f aether)
+   ```
+
+3. Analyze with MAT or VisualVM
+
+4. Temporary fix: restart node
+   ```bash
+   systemctl restart aether
+   ```
+
+### Issue: Slow Response Times
+
+**Symptoms:** High `method.*.duration.avg` metrics
+
+**Checklist:**
+1. Identify slow methods
+   ```bash
+   curl http://node:8080/metrics | jq 'to_entries | .[] | select(.key | contains("duration.avg")) | select(.value > 100)'
+   ```
+
+2. Check CPU usage
+   ```bash
+   curl http://node:8080/metrics | jq '.["cpu.usage"]'
+   ```
+
+3. Check for GC pressure
+   ```bash
+   grep -i "gc\|pause" /var/log/aether/aether.log | tail -20
+   ```
+
+4. Check network latency between nodes
+   ```bash
+   ping -c 10 node2
+   ```
+
+### Issue: Split Brain
+
+**Symptoms:** Different nodes report different cluster states
+
+**Checklist:**
+1. Check each node's view
+   ```bash
+   for node in node1 node2 node3; do
+     echo "=== $node ==="
+     curl -s http://$node:8080/cluster/status | jq '.nodes'
+   done
+   ```
+
+2. Verify network connectivity between all nodes
+   ```bash
+   # Test all pairs
+   for src in node1 node2 node3; do
+     for dst in node1 node2 node3; do
+       ssh $src "nc -zv $dst 8090 2>&1"
+     done
+   done
+   ```
+
+3. Resolution: Restart minority partition nodes
+
+## Log Levels
+
+To increase logging temporarily:
+
+```bash
+# Via management API
+curl -X POST http://node:8080/admin/logging -d 'level=DEBUG&logger=org.pragmatica.aether'
+
+# Reset to normal
+curl -X POST http://node:8080/admin/logging -d 'level=INFO&logger=org.pragmatica.aether'
+```
+
+## Getting Help
+
+1. Collect diagnostic information:
+   ```bash
+   tar czf diagnostics.tar.gz \
+     /var/log/aether/*.log \
+     /etc/aether/*.yaml
+   ```
+
+2. Include:
+   - Node configuration
+   - Recent logs
+   - Steps to reproduce
+   - Expected vs actual behavior
diff --git a/node/src/main/java/org/pragmatica/aether/Main.java b/node/src/main/java/org/pragmatica/aether/Main.java
index 09da99ac..3c0c822d 100644
--- a/node/src/main/java/org/pragmatica/aether/Main.java
+++ b/node/src/main/java/org/pragmatica/aether/Main.java
@@ -86,7 +86,8 @@ private List<NodeInfo> parsePeers(NodeId self, int selfPort) {
                .map(peersStr -> Arrays.stream(peersStr.split(","))
                                       .map(String::trim)
                                       .filter(s -> !s.isEmpty())
-                                      .map(this::parsePeerAddress)
+                                      .flatMap(peerStr -> parsePeerAddress(peerStr)
+                                                          .stream())
                                       .toList())
                .map(peers -> {
                         // Include self in the peer list if not already there
@@ -102,23 +103,23 @@ private List<NodeInfo> parsePeers(NodeId self, int selfPort) {
                .orElse(List.of(selfInfo));
     }
 
-    private NodeInfo parsePeerAddress(String peerStr) {
+    private java.util.Optional<NodeInfo> parsePeerAddress(String peerStr) {
         var parts = peerStr.split(":");
         if (parts.length == 2) {
             var host = parts[0];
             var port = Integer.parseInt(parts[1]);
             // Generate node ID from address for discovery
             var nodeId = NodeId.nodeId("node-" + host + "-" + port);
-            return nodeInfo(nodeId, nodeAddress(host, port));
+            return java.util.Optional.of(nodeInfo(nodeId, nodeAddress(host, port)));
         }else if (parts.length == 3) {
             // Format: nodeId:host:port
             var nodeId = NodeId.nodeId(parts[0]);
             var host = parts[1];
             var port = Integer.parseInt(parts[2]);
-            return nodeInfo(nodeId, nodeAddress(host, port));
+            return java.util.Optional.of(nodeInfo(nodeId, nodeAddress(host, port)));
         }
-        throw new IllegalArgumentException("Invalid peer format: " + peerStr
-                                           + ". Expected host:port or nodeId:host:port");
+        log.warn("Invalid peer format: {}. Expected host:port or nodeId:host:port", peerStr);
+        return java.util.Optional.empty();
     }
 
     private java.util.Optional<String> findArg(String prefix) {
diff --git a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
index d690ed0d..bed4981e 100644
--- a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
+++ b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
@@ -7,9 +7,12 @@
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
+import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
+import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.TlsContextFactory;
 
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
@@ -39,6 +42,7 @@
 import io.netty.handler.codec.http.HttpServerCodec;
 import io.netty.handler.codec.http.HttpVersion;
 import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
+import io.netty.handler.ssl.SslContext;
 import io.netty.util.CharsetUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -62,7 +66,11 @@ public interface ManagementServer {
     Promise<Unit> stop();
 
     static ManagementServer managementServer(int port, Supplier<AetherNode> nodeSupplier) {
-        return new ManagementServerImpl(port, nodeSupplier);
+        return managementServer(port, nodeSupplier, Option.empty());
+    }
+
+    static ManagementServer managementServer(int port, Supplier<AetherNode> nodeSupplier, Option<TlsConfig> tls) {
+        return new ManagementServerImpl(port, nodeSupplier, tls);
     }
 }
 
@@ -77,15 +85,19 @@ class ManagementServerImpl implements ManagementServer {
     private final MultiThreadIoEventLoopGroup workerGroup;
     private final AlertManager alertManager;
     private final DashboardMetricsPublisher metricsPublisher;
+    private final Option<SslContext> sslContext;
     private Channel serverChannel;
 
-    ManagementServerImpl(int port, Supplier<AetherNode> nodeSupplier) {
+    ManagementServerImpl(int port, Supplier<AetherNode> nodeSupplier, Option<TlsConfig> tls) {
         this.port = port;
         this.nodeSupplier = nodeSupplier;
         this.bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
         this.workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
         this.alertManager = new AlertManager();
         this.metricsPublisher = new DashboardMetricsPublisher(nodeSupplier, alertManager);
+        this.sslContext = tls.map(TlsContextFactory::create)
+                             .flatMap(result -> result.fold(_ -> Option.empty(),
+                                                            Option::some));
     }
 
     @Override
@@ -97,6 +109,7 @@ public Promise<Unit> start() {
             @Override
             protected void initChannel(SocketChannel ch) {
                                                                      ChannelPipeline p = ch.pipeline();
+                                                                     sslContext.onPresent(ctx -> p.addLast(ctx.newHandler(ch.alloc())));
                                                                      p.addLast(new HttpServerCodec());
                                                                      p.addLast(new HttpObjectAggregator(MAX_CONTENT_LENGTH));
                                                                      p.addLast(new WebSocketServerProtocolHandler("/ws/dashboard",
@@ -112,7 +125,11 @@ protected void initChannel(SocketChannel ch) {
                                                              if (future.isSuccess()) {
                                                              serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
                                                              metricsPublisher.start();
-                                                             log.info("Management server started on port {} (dashboard at /dashboard)",
+                                                             var protocol = sslContext.isPresent()
+                                                                            ? "HTTPS"
+                                                                            : "HTTP";
+                                                             log.info("{} management server started on port {} (dashboard at /dashboard)",
+                                                                      protocol,
                                                                       port);
                                                              promise.succeed(unit());
                                                          }else {
@@ -206,7 +223,7 @@ private void handleGet(ChannelHandlerContext ctx, String uri) {
             case"/invocation-metrics" -> buildInvocationMetricsResponse(node);
             case"/thresholds" -> alertManager.thresholdsAsJson();
             case"/alerts" -> buildAlertsResponse();
-            case"/health" -> "{\"status\":\"ok\"}";
+            case"/health" -> buildHealthResponse(node);
             default -> null;
         };
         if (response != null) {
@@ -432,6 +449,39 @@ private void handleBlueprint(ChannelHandlerContext ctx, AetherNode node, String
                                                          cause.message()));
     }
 
+    private String buildHealthResponse(AetherNode node) {
+        var metrics = node.metricsCollector()
+                          .allMetrics();
+        var nodeCount = metrics.size();
+        var sliceCount = node.sliceStore()
+                             .loaded()
+                             .size();
+        // Quorum: we have metrics from at least half the expected nodes
+        // Use nodeCount > 1 as a simple proxy for "cluster is functioning"
+        var hasQuorum = nodeCount >= 1;
+        // Determine status: healthy if quorum, degraded if no slices but quorum, unhealthy if no quorum
+        var status = !hasQuorum
+                     ? "unhealthy"
+                     : sliceCount == 0
+                       ? "degraded"
+                       : "healthy";
+        var sb = new StringBuilder();
+        sb.append("{");
+        sb.append("\"status\":\"")
+          .append(status)
+          .append("\",");
+        sb.append("\"quorum\":")
+          .append(hasQuorum)
+          .append(",");
+        sb.append("\"nodeCount\":")
+          .append(nodeCount)
+          .append(",");
+        sb.append("\"sliceCount\":")
+          .append(sliceCount);
+        sb.append("}");
+        return sb.toString();
+    }
+
     private String buildStatusResponse(AetherNode node) {
         var sb = new StringBuilder();
         sb.append("{");
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java b/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
index 28c737c4..b06d5048 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpMethod.java
@@ -1,5 +1,7 @@
 package org.pragmatica.aether.http;
 
+import org.pragmatica.lang.Option;
+
 import java.util.Locale;
 
 /**
@@ -13,16 +15,16 @@ public enum HttpMethod {
     PATCH,
     HEAD,
     OPTIONS;
-    public static HttpMethod fromString(String method) {
+    public static Option<HttpMethod> fromString(String method) {
         return switch (method.toUpperCase(Locale.ROOT)) {
-            case"GET" -> GET;
-            case"POST" -> POST;
-            case"PUT" -> PUT;
-            case"DELETE" -> DELETE;
-            case"PATCH" -> PATCH;
-            case"HEAD" -> HEAD;
-            case"OPTIONS" -> OPTIONS;
-            default -> throw new IllegalArgumentException("Unknown HTTP method: " + method);
+            case"GET" -> Option.some(GET);
+            case"POST" -> Option.some(POST);
+            case"PUT" -> Option.some(PUT);
+            case"DELETE" -> Option.some(DELETE);
+            case"PATCH" -> Option.some(PATCH);
+            case"HEAD" -> Option.some(HEAD);
+            case"OPTIONS" -> Option.some(OPTIONS);
+            default -> Option.none();
         };
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
index 55b599b0..f0695dee 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
@@ -1,9 +1,11 @@
 package org.pragmatica.aether.http;
 
 import org.pragmatica.aether.invoke.SliceInvoker;
+import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
+import org.pragmatica.net.TlsContextFactory;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
@@ -24,6 +26,7 @@
 import io.netty.handler.codec.http.HttpResponseStatus;
 import io.netty.handler.codec.http.HttpServerCodec;
 import io.netty.handler.codec.http.QueryStringDecoder;
+import io.netty.handler.ssl.SslContext;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -67,6 +70,7 @@ class HttpRouterImpl implements HttpRouter {
     private final ResponseWriter responseWriter;
     private final MultiThreadIoEventLoopGroup bossGroup;
     private final MultiThreadIoEventLoopGroup workerGroup;
+    private final Option<SslContext> sslContext;
     private Channel serverChannel;
 
     HttpRouterImpl(RouterConfig config,
@@ -82,6 +86,10 @@ class HttpRouterImpl implements HttpRouter {
         this.responseWriter = ResponseWriter.responseWriter(serializer);
         this.bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
         this.workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+        this.sslContext = config.tls()
+                                .map(TlsContextFactory::create)
+                                .flatMap(result -> result.fold(_ -> Option.empty(),
+                                                               Option::some));
     }
 
     @Override
@@ -93,6 +101,7 @@ public Promise<Unit> start() {
             @Override
             protected void initChannel(SocketChannel ch) {
                                                                      ChannelPipeline p = ch.pipeline();
+                                                                     sslContext.onPresent(ctx -> p.addLast(ctx.newHandler(ch.alloc())));
                                                                      p.addLast(new HttpServerCodec());
                                                                      p.addLast(new HttpObjectAggregator(config.maxContentLength()));
                                                                      p.addLast(new HttpRequestHandler(
@@ -103,7 +112,11 @@ protected void initChannel(SocketChannel ch) {
                                             .addListener(future -> {
                                                              if (future.isSuccess()) {
                                                              serverChannel = ((io.netty.channel.ChannelFuture) future).channel();
-                                                             log.info("HTTP router started on port {}",
+                                                             var protocol = sslContext.isPresent()
+                                                                            ? "HTTPS"
+                                                                            : "HTTP";
+                                                             log.info("{} router started on port {}",
+                                                                      protocol,
                                                                       config.port());
                                                              promise.succeed(unit());
                                                          }else {
@@ -161,22 +174,28 @@ protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request)
             responseWriter.writeError(ctx, HttpResponseStatus.BAD_REQUEST, Causes.cause("Invalid HTTP request"));
             return;
         }
-        var method = HttpMethod.fromString(request.method()
-                                                  .name());
         var decoder = new QueryStringDecoder(request.uri());
         var path = decoder.path();
-        log.debug("Received {} {}", method, path);
-        routeRegistry.match(method, path)
-                     .fold(() -> {
-                               responseWriter.writeError(ctx,
-                                                         HttpResponseStatus.NOT_FOUND,
-                                                         new HttpRouterError.RouteNotFound(path));
-                               return null;
-                           },
-                           match -> {
-                               handleMatchedRoute(ctx, method, path, decoder, request, match);
-                               return null;
-                           });
+        HttpMethod.fromString(request.method()
+                                     .name())
+                  .onEmpty(() -> responseWriter.writeError(ctx,
+                                                           HttpResponseStatus.METHOD_NOT_ALLOWED,
+                                                           Causes.cause("Unsupported HTTP method: " + request.method()
+                                                                                                             .name())))
+                  .onPresent(method -> {
+                                 log.debug("Received {} {}", method, path);
+                                 routeRegistry.match(method, path)
+                                              .fold(() -> {
+                                                        responseWriter.writeError(ctx,
+                                                                                  HttpResponseStatus.NOT_FOUND,
+                                                                                  new HttpRouterError.RouteNotFound(path));
+                                                        return null;
+                                                    },
+                                                    match -> {
+                                                        handleMatchedRoute(ctx, method, path, decoder, request, match);
+                                                        return null;
+                                                    });
+                             });
     }
 
     private void handleMatchedRoute(ChannelHandlerContext ctx,
diff --git a/node/src/main/java/org/pragmatica/aether/http/PathPattern.java b/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
index 2eb77597..00fbef40 100644
--- a/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
+++ b/node/src/main/java/org/pragmatica/aether/http/PathPattern.java
@@ -1,6 +1,10 @@
 package org.pragmatica.aether.http;
 
+import org.pragmatica.lang.Cause;
+import org.pragmatica.lang.Functions.Fn1;
 import org.pragmatica.lang.Option;
+import org.pragmatica.lang.Result;
+import org.pragmatica.lang.utils.Causes;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -20,15 +24,25 @@ public record PathPattern(
  List<String> variableNames) {
     private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\{([^}]+)}");
 
-    public static PathPattern compile(String routePattern) {
+    private static final Fn1<Cause, String>MISSING_METHOD = Causes.forOneValue("Route pattern must include method: {}");
+
+    private static final Fn1<Cause, String>UNKNOWN_METHOD = Causes.forOneValue("Unknown HTTP method: {}");
+
+    public static Result<PathPattern> compile(String routePattern) {
         // Parse "GET:/api/users/{userId}" format
         var colonIndex = routePattern.indexOf(':');
         if (colonIndex == - 1) {
-            throw new IllegalArgumentException("Route pattern must include method: " + routePattern);
+            return MISSING_METHOD.apply(routePattern)
+                                 .result();
         }
         var methodStr = routePattern.substring(0, colonIndex);
         var pathPattern = routePattern.substring(colonIndex + 1);
-        var method = HttpMethod.fromString(methodStr);
+        return HttpMethod.fromString(methodStr)
+                         .toResult(UNKNOWN_METHOD.apply(methodStr))
+                         .map(method -> buildPattern(method, routePattern, pathPattern));
+    }
+
+    private static PathPattern buildPattern(HttpMethod method, String routePattern, String pathPattern) {
         var variableNames = new ArrayList<String>();
         // Convert path pattern to regex
         var regexBuilder = new StringBuilder("^");
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
index 7a7bb9a4..3f89323e 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
@@ -225,20 +225,22 @@ public Promise<Unit> unregister(Artifact artifact) {
     }
 
     private void addRoute(RouteKey key, RouteValue value) {
-        try{
-            // Create the pattern from "METHOD:path"
-            var pattern = PathPattern.compile(value.httpMethod() + ":" + value.pathPattern());
-            var registered = new RegisteredRoute(key, value, pattern);
-            routes.put(key, registered);
-            log.debug("Added route: {} {} -> {}:{}",
-                      value.httpMethod(),
-                      value.pathPattern(),
-                      value.artifact()
-                           .asString(),
-                      value.methodName());
-        } catch (Exception e) {
-            log.error("Failed to compile route pattern: {} {}", value.httpMethod(), value.pathPattern(), e);
-        }
+        // Create the pattern from "METHOD:path"
+        PathPattern.compile(value.httpMethod() + ":" + value.pathPattern())
+                   .onSuccess(pattern -> {
+                                  var registered = new RegisteredRoute(key, value, pattern);
+                                  routes.put(key, registered);
+                                  log.debug("Added route: {} {} -> {}:{}",
+                                            value.httpMethod(),
+                                            value.pathPattern(),
+                                            value.artifact()
+                                                 .asString(),
+                                            value.methodName());
+                              })
+                   .onFailure(cause -> log.error("Failed to compile route pattern: {} {} - {}",
+                                                 value.httpMethod(),
+                                                 value.pathPattern(),
+                                                 cause.message()));
     }
 
     @Override
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
index 1762ce25..d20abe30 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
@@ -1,23 +1,39 @@
 package org.pragmatica.aether.http;
+
+import org.pragmatica.lang.Option;
+import org.pragmatica.net.TlsConfig;
+
 /**
  * Configuration for the HTTP router.
+ *
+ * @param port             Port to bind to
+ * @param maxContentLength Maximum content length for requests
+ * @param tls              TLS configuration (empty for plain HTTP)
  */
 public record RouterConfig(
  int port,
- int maxContentLength) {
+ int maxContentLength,
+ Option<TlsConfig> tls) {
     public static final int DEFAULT_PORT = 8081;
     public static final int DEFAULT_MAX_CONTENT_LENGTH = 1024 * 1024;
 
     // 1MB
     public static RouterConfig defaultConfig() {
-        return new RouterConfig(DEFAULT_PORT, DEFAULT_MAX_CONTENT_LENGTH);
+        return new RouterConfig(DEFAULT_PORT, DEFAULT_MAX_CONTENT_LENGTH, Option.empty());
     }
 
     public static RouterConfig routerConfig(int port) {
-        return new RouterConfig(port, DEFAULT_MAX_CONTENT_LENGTH);
+        return new RouterConfig(port, DEFAULT_MAX_CONTENT_LENGTH, Option.empty());
     }
 
     public static RouterConfig routerConfig(int port, int maxContentLength) {
-        return new RouterConfig(port, maxContentLength);
+        return new RouterConfig(port, maxContentLength, Option.empty());
+    }
+
+    /**
+     * Create a new configuration with TLS enabled.
+     */
+    public RouterConfig withTls(TlsConfig tlsConfig) {
+        return new RouterConfig(port, maxContentLength, Option.some(tlsConfig));
     }
 }
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
index ac278c1f..c022c885 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
@@ -6,13 +6,13 @@
 import org.pragmatica.cluster.net.ClusterNetwork;
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.utility.RingBuffer;
 
 import java.lang.management.ManagementFactory;
 import java.lang.management.MemoryMXBean;
 import java.lang.management.OperatingSystemMXBean;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.DoubleAdder;
 import java.util.concurrent.atomic.LongAdder;
 
@@ -95,6 +95,9 @@ class MetricsCollectorImpl implements MetricsCollector {
     // Sliding window duration: 2 hours in milliseconds
     private static final long SLIDING_WINDOW_MS = 2 * 60 * 60 * 1000L;
 
+    // Ring buffer capacity: 2 hours at 1 sample/second = 7200 samples
+    private static final int RING_BUFFER_CAPACITY = 7200;
+
     private final NodeId self;
     private final ClusterNetwork network;
 
@@ -111,8 +114,8 @@ class MetricsCollectorImpl implements MetricsCollector {
     // Metrics received from other nodes
     private final ConcurrentHashMap<NodeId, Map<String, Double>> remoteMetrics = new ConcurrentHashMap<>();
 
-    // Sliding window for historical metrics - list of snapshots per node, oldest first
-    private final ConcurrentHashMap<NodeId, java.util.concurrent.CopyOnWriteArrayList<MetricsSnapshot>> historicalMetricsMap = new ConcurrentHashMap<>();
+    // Ring buffer for historical metrics - fixed capacity, O(1) add, oldest elements auto-evicted
+    private final ConcurrentHashMap<NodeId, RingBuffer<MetricsSnapshot>> historicalMetricsMap = new ConcurrentHashMap<>();
 
     MetricsCollectorImpl(NodeId self, ClusterNetwork network) {
         this.self = self;
@@ -184,11 +187,9 @@ public Map<String, Double> metricsFor(NodeId nodeId) {
     public Map<NodeId, java.util.List<MetricsSnapshot>> historicalMetrics() {
         var cutoff = System.currentTimeMillis() - SLIDING_WINDOW_MS;
         var result = new ConcurrentHashMap<NodeId, java.util.List<MetricsSnapshot>>();
-        historicalMetricsMap.forEach((nodeId, snapshots) -> {
+        historicalMetricsMap.forEach((nodeId, ringBuffer) -> {
                                          // Filter to only include snapshots within the window
-        var filtered = snapshots.stream()
-                                .filter(s -> s.timestamp() >= cutoff)
-                                .toList();
+        var filtered = ringBuffer.filter(s -> s.timestamp() >= cutoff);
                                          if (!filtered.isEmpty()) {
                                          result.put(nodeId, filtered);
                                      }
@@ -219,16 +220,13 @@ public void onMetricsPong(MetricsPong pong) {
     }
 
     /**
-     * Add metrics snapshot to historical window and cleanup old entries.
+     * Add metrics snapshot to historical ring buffer.
+     * Old entries are automatically evicted when buffer is full.
      */
     private void addToHistory(NodeId nodeId, Map<String, Double> metrics) {
-        var snapshots = historicalMetricsMap.computeIfAbsent(
-        nodeId, _ -> new java.util.concurrent.CopyOnWriteArrayList<>());
-        var now = System.currentTimeMillis();
-        snapshots.add(new MetricsSnapshot(now, metrics));
-        // Cleanup old entries outside the sliding window
-        var cutoff = now - SLIDING_WINDOW_MS;
-        snapshots.removeIf(s -> s.timestamp() < cutoff);
+        var ringBuffer = historicalMetricsMap.computeIfAbsent(
+        nodeId, _ -> RingBuffer.ringBuffer(RING_BUFFER_CAPACITY));
+        ringBuffer.add(new MetricsSnapshot(System.currentTimeMillis(), metrics));
     }
 
     /**
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index e609c732..4734822b 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -177,7 +177,7 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
         // Create KVStore (state machine for consensus)
         var kvStore = new KVStore<AetherKey, AetherValue>(router, serializer, deserializer);
         // Create slice management components
-        var sliceRegistry = SliceRegistry.create();
+        var sliceRegistry = SliceRegistry.sliceRegistry();
         var sharedLibraryLoader = createSharedLibraryLoader(config);
         var sliceStore = SliceStore.sliceStore(sliceRegistry,
                                                config.sliceAction()
@@ -224,11 +224,11 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
         var dhtRing = ConsistentHashRing.<String>create();
         dhtRing.addNode(config.self()
                               .id());
-        var dhtNode = DHTNode.create(config.self()
-                                           .id(),
-                                     dhtStorage,
-                                     dhtRing,
-                                     config.artifactRepo());
+        var dhtNode = DHTNode.dhtNode(config.self()
+                                            .id(),
+                                      dhtStorage,
+                                      dhtRing,
+                                      config.artifactRepo());
         var dhtClient = LocalDHTClient.create(dhtNode);
         var artifactStore = ArtifactStore.artifactStore(dhtClient);
         var mavenProtocolHandler = MavenProtocolHandler.mavenProtocolHandler(artifactStore);
@@ -249,11 +249,19 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
         // Create HTTP router if configured
         Option<HttpRouter> httpRouter = config.httpRouter()
                                               .map(routerConfig -> {
+                                                       // Apply TLS from main config if RouterConfig doesn't have its own TLS
+        var effectiveConfig = routerConfig.tls()
+                                          .isEmpty() && config.tls()
+                                                              .isPresent()
+                              ? config.tls()
+                                      .map(routerConfig::withTls)
+                                      .or(routerConfig)
+                              : routerConfig;
                                                        // Create artifact resolver that parses slice ID strings to Artifact
         SliceDispatcher.ArtifactResolver artifactResolver = sliceId -> Artifact.artifact(sliceId)
                                                                                .fold(cause -> null, artifact -> artifact);
                                                        return HttpRouter.httpRouter(
-        routerConfig, routeRegistry, sliceInvoker, artifactResolver, serializer, deserializer);
+        effectiveConfig, routeRegistry, sliceInvoker, artifactResolver, serializer, deserializer);
                                                    });
         // Create the node first (without management server reference)
         var node = new aetherNode(
@@ -279,7 +287,7 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
         httpRouter);
         // Create management server if enabled
         if (config.managementPort() > 0) {
-            var managementServer = ManagementServer.managementServer(config.managementPort(), () -> node);
+            var managementServer = ManagementServer.managementServer(config.managementPort(), () -> node, config.tls());
             return new aetherNode(
             config,
             router,
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
index 96bb9547..aa9461ca 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
@@ -9,6 +9,7 @@
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 import org.pragmatica.dht.DHTConfig;
 import org.pragmatica.lang.Option;
+import org.pragmatica.net.TlsConfig;
 
 import java.util.List;
 
@@ -24,6 +25,7 @@
  * @param managementPort  Port for HTTP management API (0 to disable)
  * @param httpRouter      HTTP router configuration (empty to disable)
  * @param artifactRepo    DHT configuration for artifact repository (replication factor, 0 = full)
+ * @param tls             TLS configuration for secure connections (empty for plain TCP/HTTP)
  */
 public record AetherNodeConfig(
  TopologyConfig topology,
@@ -31,7 +33,8 @@ public record AetherNodeConfig(
  SliceActionConfig sliceAction,
  int managementPort,
  Option<RouterConfig> httpRouter,
- DHTConfig artifactRepo) {
+ DHTConfig artifactRepo,
+ Option<TlsConfig> tls) {
     public static final int DEFAULT_MANAGEMENT_PORT = 8080;
     public static final int MANAGEMENT_DISABLED = 0;
 
@@ -103,7 +106,8 @@ self, timeSpan(5)
                                     sliceActionConfig,
                                     managementPort,
                                     httpRouter,
-                                    artifactRepoConfig);
+                                    artifactRepoConfig,
+                                    Option.empty());
     }
 
     public static AetherNodeConfig testConfig(NodeId self, int port, List<NodeInfo> coreNodes) {
@@ -117,7 +121,25 @@ self, timeSpan(500)
                                     defaultSliceConfig(),
                                     MANAGEMENT_DISABLED,
                                     Option.empty(),
-                                    DHTConfig.FULL);
+                                    DHTConfig.FULL,
+                                    Option.empty());
+    }
+
+    /**
+     * Create a new configuration with TLS enabled for all components (HTTP and cluster).
+     */
+    public AetherNodeConfig withTls(TlsConfig tlsConfig) {
+        var tlsOption = Option.some(tlsConfig);
+        // Update TopologyConfig with TLS for cluster communication
+        var newTopology = new TopologyConfig(
+        topology.self(), topology.reconciliationInterval(), topology.pingInterval(), topology.coreNodes(), tlsOption);
+        return new AetherNodeConfig(newTopology,
+                                    protocol,
+                                    sliceAction,
+                                    managementPort,
+                                    httpRouter,
+                                    artifactRepo,
+                                    tlsOption);
     }
 
     public NodeId self() {
diff --git a/node/src/test/java/org/pragmatica/aether/http/PathPatternTest.java b/node/src/test/java/org/pragmatica/aether/http/PathPatternTest.java
index 405c8773..91ed6fb6 100644
--- a/node/src/test/java/org/pragmatica/aether/http/PathPatternTest.java
+++ b/node/src/test/java/org/pragmatica/aether/http/PathPatternTest.java
@@ -1,5 +1,6 @@
 package org.pragmatica.aether.http;
 
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
@@ -8,107 +9,132 @@ class PathPatternTest {
 
     @Test
     void compile_exactPath_matchesExactly() {
-        var pattern = PathPattern.compile("GET:/api/orders");
-
-        var match = pattern.match(HttpMethod.GET, "/api/orders");
-
-        assertThat(match.isPresent()).isTrue();
-        assertThat(match.unwrap()).isEmpty();
+        PathPattern.compile("GET:/api/orders")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/orders");
+                       assertThat(match.isPresent()).isTrue();
+                       assertThat(match.unwrap()).isEmpty();
+                   });
     }
 
     @Test
     void compile_exactPath_rejectsWrongPath() {
-        var pattern = PathPattern.compile("GET:/api/orders");
-
-        var match = pattern.match(HttpMethod.GET, "/api/users");
-
-        assertThat(match.isPresent()).isFalse();
+        PathPattern.compile("GET:/api/orders")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/users");
+                       assertThat(match.isPresent()).isFalse();
+                   });
     }
 
     @Test
     void compile_exactPath_rejectsWrongMethod() {
-        var pattern = PathPattern.compile("GET:/api/orders");
-
-        var match = pattern.match(HttpMethod.POST, "/api/orders");
-
-        assertThat(match.isPresent()).isFalse();
+        PathPattern.compile("GET:/api/orders")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.POST, "/api/orders");
+                       assertThat(match.isPresent()).isFalse();
+                   });
     }
 
     @Test
     void compile_pathWithVariable_extractsVariable() {
-        var pattern = PathPattern.compile("GET:/api/orders/{orderId}");
-
-        var match = pattern.match(HttpMethod.GET, "/api/orders/ORD-12345678");
-
-        assertThat(match.isPresent()).isTrue();
-        assertThat(match.unwrap()).containsEntry("orderId", "ORD-12345678");
+        PathPattern.compile("GET:/api/orders/{orderId}")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/orders/ORD-12345678");
+                       assertThat(match.isPresent()).isTrue();
+                       assertThat(match.unwrap()).containsEntry("orderId", "ORD-12345678");
+                   });
     }
 
     @Test
     void compile_pathWithMultipleVariables_extractsAll() {
-        var pattern = PathPattern.compile("GET:/api/customers/{customerId}/orders/{orderId}");
-
-        var match = pattern.match(HttpMethod.GET, "/api/customers/CUST-001/orders/ORD-002");
-
-        assertThat(match.isPresent()).isTrue();
-        assertThat(match.unwrap())
-            .containsEntry("customerId", "CUST-001")
-            .containsEntry("orderId", "ORD-002");
+        PathPattern.compile("GET:/api/customers/{customerId}/orders/{orderId}")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/customers/CUST-001/orders/ORD-002");
+                       assertThat(match.isPresent()).isTrue();
+                       assertThat(match.unwrap())
+                           .containsEntry("customerId", "CUST-001")
+                           .containsEntry("orderId", "ORD-002");
+                   });
     }
 
     @Test
     void compile_pathWithVariableInMiddle_matchesCorrectly() {
-        var pattern = PathPattern.compile("GET:/api/users/{userId}/settings");
-
-        var match = pattern.match(HttpMethod.GET, "/api/users/123/settings");
-
-        assertThat(match.isPresent()).isTrue();
-        assertThat(match.unwrap()).containsEntry("userId", "123");
+        PathPattern.compile("GET:/api/users/{userId}/settings")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/users/123/settings");
+                       assertThat(match.isPresent()).isTrue();
+                       assertThat(match.unwrap()).containsEntry("userId", "123");
+                   });
     }
 
     @Test
     void compile_postMethod_matchesPost() {
-        var pattern = PathPattern.compile("POST:/api/orders");
-
-        var match = pattern.match(HttpMethod.POST, "/api/orders");
-
-        assertThat(match.isPresent()).isTrue();
+        PathPattern.compile("POST:/api/orders")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.POST, "/api/orders");
+                       assertThat(match.isPresent()).isTrue();
+                   });
     }
 
     @Test
     void compile_deleteMethod_matchesDelete() {
-        var pattern = PathPattern.compile("DELETE:/api/orders/{orderId}");
-
-        var match = pattern.match(HttpMethod.DELETE, "/api/orders/123");
-
-        assertThat(match.isPresent()).isTrue();
-        assertThat(match.unwrap()).containsEntry("orderId", "123");
+        PathPattern.compile("DELETE:/api/orders/{orderId}")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.DELETE, "/api/orders/123");
+                       assertThat(match.isPresent()).isTrue();
+                       assertThat(match.unwrap()).containsEntry("orderId", "123");
+                   });
     }
 
     @Test
     void compile_trailingSlashMismatch_doesNotMatch() {
-        var pattern = PathPattern.compile("GET:/api/orders");
-
-        var match = pattern.match(HttpMethod.GET, "/api/orders/");
-
-        assertThat(match.isPresent()).isFalse();
+        PathPattern.compile("GET:/api/orders")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/orders/");
+                       assertThat(match.isPresent()).isFalse();
+                   });
     }
 
     @Test
     void compile_partialPathMatch_doesNotMatch() {
-        var pattern = PathPattern.compile("GET:/api/orders/{orderId}");
-
-        var match = pattern.match(HttpMethod.GET, "/api/orders");
-
-        assertThat(match.isPresent()).isFalse();
+        PathPattern.compile("GET:/api/orders/{orderId}")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/orders");
+                       assertThat(match.isPresent()).isFalse();
+                   });
     }
 
     @Test
     void compile_longerPathThanPattern_doesNotMatch() {
-        var pattern = PathPattern.compile("GET:/api/orders/{orderId}");
+        PathPattern.compile("GET:/api/orders/{orderId}")
+                   .onFailureRun(Assertions::fail)
+                   .onSuccess(pattern -> {
+                       var match = pattern.match(HttpMethod.GET, "/api/orders/123/items");
+                       assertThat(match.isPresent()).isFalse();
+                   });
+    }
 
-        var match = pattern.match(HttpMethod.GET, "/api/orders/123/items");
+    @Test
+    void compile_missingColon_fails() {
+        PathPattern.compile("GET/api/orders")
+                   .onSuccessRun(Assertions::fail)
+                   .onFailure(cause -> assertThat(cause.message()).contains("must include method"));
+    }
 
-        assertThat(match.isPresent()).isFalse();
+    @Test
+    void compile_unknownMethod_fails() {
+        PathPattern.compile("UNKNOWN:/api/orders")
+                   .onSuccessRun(Assertions::fail)
+                   .onFailure(cause -> assertThat(cause.message()).contains("Unknown HTTP method"));
     }
 }
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
index 4b4cdf06..8b368c88 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceManifest.java
@@ -36,9 +36,8 @@ public interface SliceManifest {
      * @return SliceManifestInfo or error if manifest is missing/invalid
      */
     static Result<SliceManifestInfo> read(URL jarUrl) {
-        return Result.lift(Causes::fromThrowable,
-                           () -> readManifest(jarUrl))
-                     .flatMap(SliceManifest::parseManifest);
+        return readManifest(jarUrl)
+               .flatMap(SliceManifest::parseManifest);
     }
 
     /**
@@ -57,7 +56,7 @@ static Result<SliceManifestInfo> readFromClassLoader(ClassLoader classLoader) {
                      .flatMap(SliceManifest::parseManifest);
     }
 
-    private static Manifest readManifest(URL jarUrl) throws IOException {
+    private static Result<Manifest> readManifest(URL jarUrl) {
         var path = jarUrl.getPath();
         if (path.startsWith("file:")) {
             path = path.substring(5);
@@ -66,13 +65,21 @@ private static Manifest readManifest(URL jarUrl) throws IOException {
         if (path.contains("!")) {
             path = path.substring(0, path.indexOf("!"));
         }
-        try (var jarFile = new JarFile(path)) {
-            var manifest = jarFile.getManifest();
-            if (manifest == null) {
-                throw new IOException("JAR has no manifest: " + jarUrl);
-            }
-            return manifest;
-        }
+        var jarPath = path;
+        return Result.lift(Causes::fromThrowable,
+                           () -> new JarFile(jarPath))
+                     .flatMap(jarFile -> {
+                                  try (jarFile) {
+                                  var manifest = jarFile.getManifest();
+                                  return manifest == null
+                                         ? MANIFEST_NOT_FOUND_FN.apply(jarUrl.toString())
+                                                                .result()
+                                         : Result.success(manifest);
+                              } catch (IOException e) {
+                                  return Causes.fromThrowable(e)
+                                               .result();
+                              }
+                              });
     }
 
     private static Result<Manifest> readManifestFromUrl(URL manifestUrl) {
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
index c53be9d1..2948f933 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/dependency/SliceRegistry.java
@@ -26,7 +26,7 @@ public interface SliceRegistry {
     /**
      * Create a new empty registry.
      */
-    static SliceRegistry create() {
+    static SliceRegistry sliceRegistry() {
         return new SliceRegistryImpl(new ConcurrentHashMap<>());
     }
 
diff --git a/slice/src/test/java/org/pragmatica/aether/slice/SliceStoreImplTest.java b/slice/src/test/java/org/pragmatica/aether/slice/SliceStoreImplTest.java
index eda126c7..4d870c8e 100644
--- a/slice/src/test/java/org/pragmatica/aether/slice/SliceStoreImplTest.java
+++ b/slice/src/test/java/org/pragmatica/aether/slice/SliceStoreImplTest.java
@@ -25,7 +25,7 @@ class SliceStoreImplTest {
 
     @BeforeEach
     void setUp() {
-        registry = SliceRegistry.create();
+        registry = SliceRegistry.sliceRegistry();
         sharedLoader = new SharedLibraryClassLoader(getClass().getClassLoader());
         artifact = Artifact.artifact("org.example:test-slice:1.0.0").unwrap();
     }
diff --git a/slice/src/test/java/org/pragmatica/aether/slice/dependency/SliceRegistryTest.java b/slice/src/test/java/org/pragmatica/aether/slice/dependency/SliceRegistryTest.java
index ca030690..80a03af3 100644
--- a/slice/src/test/java/org/pragmatica/aether/slice/dependency/SliceRegistryTest.java
+++ b/slice/src/test/java/org/pragmatica/aether/slice/dependency/SliceRegistryTest.java
@@ -21,7 +21,7 @@ static class TestSlice implements Slice {
 
     @Test
     void register_and_lookup_slice() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.0.0").unwrap();
         var slice = new TestSlice();
 
@@ -35,7 +35,7 @@ void register_and_lookup_slice() {
 
     @Test
     void register_fails_for_duplicate_artifact() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.0.0").unwrap();
         var slice1 = new TestSlice();
         var slice2 = new TestSlice();
@@ -50,7 +50,7 @@ void register_fails_for_duplicate_artifact() {
 
     @Test
     void lookup_returns_none_for_missing_artifact() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:missing:1.0.0").unwrap();
 
         registry.lookup(artifact)
@@ -61,7 +61,7 @@ void lookup_returns_none_for_missing_artifact() {
 
     @Test
     void unregister_removes_slice() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.0.0").unwrap();
         var slice = new TestSlice();
 
@@ -79,7 +79,7 @@ void unregister_removes_slice() {
 
     @Test
     void unregister_fails_for_missing_artifact() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:missing:1.0.0").unwrap();
 
         registry.unregister(artifact)
@@ -89,7 +89,7 @@ void unregister_fails_for_missing_artifact() {
 
     @Test
     void find_by_class_name_and_exact_version() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.2.3").unwrap();
         var slice = new TestSlice();
 
@@ -105,7 +105,7 @@ void find_by_class_name_and_exact_version() {
 
     @Test
     void find_by_class_name_and_version_range() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.5.0").unwrap();
         var slice = new TestSlice();
 
@@ -121,7 +121,7 @@ void find_by_class_name_and_version_range() {
 
     @Test
     void find_returns_none_when_version_doesnt_match() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:2.0.0").unwrap();
         var slice = new TestSlice();
 
@@ -138,7 +138,7 @@ void find_returns_none_when_version_doesnt_match() {
 
     @Test
     void find_returns_none_when_class_name_doesnt_match() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact = Artifact.artifact("org.example:test-slice:1.0.0").unwrap();
         var slice = new TestSlice();
 
@@ -155,7 +155,7 @@ void find_returns_none_when_class_name_doesnt_match() {
 
     @Test
     void allArtifacts_returns_all_registered() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         var artifact1 = Artifact.artifact("org.example:slice1:1.0.0").unwrap();
         var artifact2 = Artifact.artifact("org.example:slice2:2.0.0").unwrap();
         var slice = new TestSlice();
@@ -170,7 +170,7 @@ void allArtifacts_returns_all_registered() {
 
     @Test
     void allArtifacts_returns_empty_for_empty_registry() {
-        var registry = SliceRegistry.create();
+        var registry = SliceRegistry.sliceRegistry();
         assertThat(registry.allArtifacts()).isEmpty();
     }
 }

From 909c8948d7bcd1abc21774dc748c332a801202f4 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Wed, 31 Dec 2025 11:25:33 +0100
Subject: [PATCH 17/26] refactor: migrate to pragmatica-lite modules
 (messaging, dht, consensus, utility)

---
 cluster/pom.xml                               |  16 +
 .../cluster/consensus/ProtocolMessage.java    |   2 +-
 .../cluster/consensus/rabia/RabiaEngine.java  |   4 +-
 .../consensus/rabia/RabiaEngineIO.java        |   2 +-
 .../cluster/leader/LeaderManager.java         |   4 +-
 .../cluster/leader/LeaderNotification.java    |   2 +-
 .../cluster/net/ClusterNetwork.java           |   4 +-
 .../net/NetworkManagementOperation.java       |   2 +-
 .../cluster/net/NetworkMessage.java           |   2 +-
 .../pragmatica/cluster/net/netty/Decoder.java |   2 +-
 .../pragmatica/cluster/net/netty/Encoder.java |   2 +-
 .../pragmatica/cluster/net/netty/Handler.java |   2 +-
 .../net/netty/NettyClusterNetwork.java        |   4 +-
 .../cluster/node/rabia/RabiaNode.java         |   2 +-
 .../cluster/state/StateMachine.java           |   2 +-
 .../state/StateMachineNotification.java       |   2 +-
 .../cluster/state/kvstore/KVStore.java        |   6 +-
 .../cluster/state/kvstore/KVStoreLocalIO.java |   2 +-
 .../topology/QuorumStateNotification.java     |   2 +-
 .../topology/TopologyChangeNotification.java  |   2 +-
 .../topology/TopologyManagementMessage.java   |   2 +-
 .../topology/ip/TcpTopologyManager.java       |   4 +-
 .../infrastructure/StateChangePrinter.java    |   2 +-
 .../rabia/infrastructure/TestCluster.java     |   2 +-
 .../cluster/leader/LeaderManagerTest.java     |   4 +-
 .../cluster/net/TcpTopologyManagerIT.java     |   2 +-
 .../cluster/net/local/LocalNetwork.java       |   2 +-
 .../org/pragmatica/node/RabiaNodeNettyIT.java |   2 +-
 common/pom.xml                                |  16 +
 .../pragmatica/dht/ConsistentHashRing.java    | 188 ------------
 .../java/org/pragmatica/dht/DHTConfig.java    |  86 ------
 .../java/org/pragmatica/dht/DHTMessage.java   |  49 ---
 .../main/java/org/pragmatica/dht/DHTNode.java | 185 -----------
 .../org/pragmatica/dht/LocalDHTClient.java    |   2 +-
 .../org/pragmatica/dht/LocalPartitionMap.java |   8 +-
 .../java/org/pragmatica/dht/Partition.java    |  56 ----
 .../dht/storage/MemoryStorageEngine.java      |  82 -----
 .../pragmatica/dht/storage/StorageEngine.java |  59 ----
 .../java/org/pragmatica/message/Message.java  |   7 -
 .../pragmatica/message/MessageReceiver.java   |  11 -
 .../org/pragmatica/message/MessageRouter.java | 176 -----------
 .../message/RouterConfigurator.java           |   4 -
 .../org/pragmatica/net/AsyncCloseable.java    |  11 +
 .../org/pragmatica/net/dns/DnsClient.java     | 199 ++++++++++++
 .../org/pragmatica/net/dns/DomainAddress.java |  24 ++
 .../org/pragmatica/net/dns/DomainName.java    |   9 +
 .../net/dns/DomainNameResolver.java           | 150 +++++++++
 .../org/pragmatica/net/dns/InetUtils.java     |  27 ++
 .../java/org/pragmatica/net/dns/README.md     | 178 +++++++++++
 .../pragmatica/net/dns/ResolverErrors.java    |  18 ++
 .../org/pragmatica/utility/IdGenerator.java   |  14 -
 .../java/org/pragmatica/utility/ULID.java     | 220 --------------
 .../dht/ConsistentHashRingTest.java           | 286 ------------------
 .../dht/storage/MemoryStorageEngineTest.java  | 163 ----------
 .../pragmatica/message/MessageRouterTest.java |  92 ------
 .../pragmatica/net/dns/DomainAddressTest.java |  70 +++++
 .../net/dns/DomainNameResolverIT.java         | 154 ++++++++++
 .../net/dns/DomainNameResolverTest.java       |  63 ++++
 .../pragmatica/net/dns/DomainNameTest.java    |  41 +++
 .../org/pragmatica/net/dns/InetUtilsTest.java |  66 ++++
 .../aether/controller/ControlLoop.java        |   2 +-
 .../cluster/ClusterDeploymentManager.java     |   4 +-
 .../node/NodeDeploymentManager.java           |   4 +-
 .../aether/endpoint/EndpointRegistry.java     |   2 +-
 .../pragmatica/aether/http/RouteRegistry.java |   2 +-
 .../aether/invoke/InvocationHandler.java      |   2 +-
 .../aether/invoke/SliceInvoker.java           |   2 +-
 .../aether/metrics/MetricsCollector.java      |   2 +-
 .../aether/metrics/MetricsScheduler.java      |   2 +-
 .../metrics/deployment/DeploymentEvent.java   |   2 +-
 .../DeploymentMetricsCollector.java           |   2 +-
 .../DeploymentMetricsScheduler.java           |   2 +-
 .../pragmatica/aether/node/AetherNode.java    |   8 +-
 .../cluster/ClusterDeploymentManagerTest.java |   2 +-
 .../node/NodeDeploymentManagerTest.java       |   2 +-
 .../DeploymentMetricsCollectorTest.java       |   2 +-
 .../DeploymentMetricsSchedulerTest.java       |   2 +-
 pom.xml                                       |  27 +-
 78 files changed, 1130 insertions(+), 1741 deletions(-)
 delete mode 100644 common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/DHTConfig.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/DHTMessage.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/DHTNode.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/Partition.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
 delete mode 100644 common/src/main/java/org/pragmatica/message/Message.java
 delete mode 100644 common/src/main/java/org/pragmatica/message/MessageReceiver.java
 delete mode 100644 common/src/main/java/org/pragmatica/message/MessageRouter.java
 delete mode 100644 common/src/main/java/org/pragmatica/message/RouterConfigurator.java
 create mode 100644 common/src/main/java/org/pragmatica/net/AsyncCloseable.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/DnsClient.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainName.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/InetUtils.java
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/README.md
 create mode 100644 common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
 delete mode 100644 common/src/main/java/org/pragmatica/utility/IdGenerator.java
 delete mode 100644 common/src/main/java/org/pragmatica/utility/ULID.java
 delete mode 100644 common/src/test/java/org/pragmatica/dht/ConsistentHashRingTest.java
 delete mode 100644 common/src/test/java/org/pragmatica/dht/storage/MemoryStorageEngineTest.java
 delete mode 100644 common/src/test/java/org/pragmatica/message/MessageRouterTest.java
 create mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
 create mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
 create mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
 create mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
 create mode 100644 common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java

diff --git a/cluster/pom.xml b/cluster/pom.xml
index d153b020..d58af777 100644
--- a/cluster/pom.xml
+++ b/cluster/pom.xml
@@ -17,6 +17,22 @@
             <groupId>org.pragmatica-lite</groupId>
             <artifactId>core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>messaging</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>utility</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>consensus</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>tcp</artifactId>
+        </dependency>
         <dependency>
             <groupId>org.pragmatica-lite.aether</groupId>
             <artifactId>common</artifactId>
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
index 804da1c4..f08bdf9f 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.consensus;
 
 import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 /// Marker interface for all protocol messages
 public interface ProtocolMessage extends Message.Wired {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
index 61248631..607c97dd 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
@@ -15,8 +15,8 @@
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.SharedScheduler;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.Comparator;
 import java.util.List;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
index bb66123a..a7aa2e1c 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.consensus.rabia;
 
 import org.pragmatica.cluster.state.Command;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
index 3ab78283..d019cae2 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
@@ -5,8 +5,8 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeDown;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
index 3fc62263..25ba819a 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.lang.Option;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 public sealed interface LeaderNotification extends Message.Local {
     record LeaderChange(Option<NodeId> leaderId, boolean localNodeIsLeader) implements LeaderNotification {}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
index 83d253ab..ee73fd3a 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
@@ -3,8 +3,8 @@
 import org.pragmatica.cluster.consensus.ProtocolMessage;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 
 /// Generalized Network API
 public interface ClusterNetwork {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
index eebe0171..4478a94e 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.net;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
index 1177b790..957a9530 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.net;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 public sealed interface NetworkMessage extends Message.Wired {
     /// Ping - test connection request
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
index 9b7eeed8..3a3738a0 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.net.netty;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 import org.pragmatica.net.serialization.Deserializer;
 
 import java.util.List;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
index 614ede33..de263c17 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.net.netty;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 import org.pragmatica.net.serialization.Serializer;
 
 import io.netty.buffer.ByteBuf;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
index fbbbd5bb..402bc769 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Handler.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.net.netty;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.function.Consumer;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 6f22728e..5e6a92f6 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -16,8 +16,8 @@
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.lang.utils.SharedScheduler;
-import org.pragmatica.message.Message;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.Message;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.Server;
 import org.pragmatica.net.ServerConfig;
 import org.pragmatica.net.serialization.Deserializer;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index 7bb545eb..cde55704 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -18,7 +18,7 @@
 import org.pragmatica.cluster.topology.ip.TcpTopologyManager;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
index 2395f671..f315ca5a 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
index 928a98a6..879f2c88 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.state;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 /// State machine notifications root.
 public interface StateMachineNotification<T> extends Message.Local {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index 1c56a094..832da716 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -13,9 +13,9 @@
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
-import org.pragmatica.message.MessageRouter.MutableRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
+import org.pragmatica.messaging.MessageRouter.MutableRouter;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
index f144bbc8..6e2d088c 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreLocalIO.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.state.kvstore;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.List;
 import java.util.Map;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java b/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
index 0a3afb01..343f1f16 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.topology;
 
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 /// Quorum state notifications
 public enum QuorumStateNotification implements Message.Local {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
index a8322f60..0938c345 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.topology;
 
 import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
index 1217388a..c255fdf9 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
index 736ca529..88fd1043 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
@@ -8,8 +8,8 @@
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
 import org.pragmatica.lang.utils.SharedScheduler;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.NodeAddress;
 import org.pragmatica.net.TlsConfig;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
index 2de4f8c3..1b10a41f 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.state.StateMachineNotification;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
index 42873067..fcfd5eb3 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
@@ -10,7 +10,7 @@
 import org.pragmatica.cluster.state.Command;
 import org.pragmatica.cluster.state.kvstore.*;
 import org.pragmatica.lang.Promise;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java b/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
index fad50722..ddbf3465 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
@@ -9,8 +9,8 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeDown;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.lang.Option;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java b/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
index b5b348c4..a5dba6be 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
@@ -7,7 +7,7 @@
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.NodeAddress;
 
 import java.net.InetSocketAddress;
diff --git a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
index 0994b732..f3cff73c 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
@@ -11,7 +11,7 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.utility.Sleep;
 
 import java.util.*;
diff --git a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
index c807e4a3..bea4cdde 100644
--- a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
+++ b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
@@ -15,7 +15,7 @@
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
diff --git a/common/pom.xml b/common/pom.xml
index 99bfb434..9b91db67 100644
--- a/common/pom.xml
+++ b/common/pom.xml
@@ -16,6 +16,22 @@
             <groupId>org.pragmatica-lite</groupId>
             <artifactId>core</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>messaging</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>utility</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>dht</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>tcp</artifactId>
+        </dependency>
 
         <!-- Networking -->
         <dependency>
diff --git a/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java b/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
deleted file mode 100644
index a0c52c07..00000000
--- a/common/src/main/java/org/pragmatica/dht/ConsistentHashRing.java
+++ /dev/null
@@ -1,188 +0,0 @@
-package org.pragmatica.dht;
-
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-
-/**
- * Consistent hash ring for distributing data across nodes.
- * Uses virtual nodes for even distribution and MurmurHash3-like hashing.
- *
- * <p>The ring maps keys to partitions (0-1023), and partitions to nodes.
- * Each physical node has multiple virtual nodes spread across the ring
- * for better load distribution.
- *
- * @param <N> Node identifier type
- */
-public final class ConsistentHashRing<N extends Comparable<N>> {
-    private static final int VIRTUAL_NODES_PER_PHYSICAL = 150;
-
-    private final NavigableMap<Integer, N> ring = new TreeMap<>();
-    private final Map<N, List<Integer>> nodeToVirtualNodes = new HashMap<>();
-    private final int virtualNodesPerPhysical;
-
-    private ConsistentHashRing(int virtualNodesPerPhysical) {
-        this.virtualNodesPerPhysical = virtualNodesPerPhysical;
-    }
-
-    /**
-     * Create a new empty consistent hash ring with default virtual node count.
-     */
-    public static <N extends Comparable<N>> ConsistentHashRing<N> create() {
-        return new ConsistentHashRing<>(VIRTUAL_NODES_PER_PHYSICAL);
-    }
-
-    /**
-     * Create a new empty consistent hash ring with specified virtual node count.
-     */
-    public static <N extends Comparable<N>> ConsistentHashRing<N> create(int virtualNodesPerPhysical) {
-        return new ConsistentHashRing<>(virtualNodesPerPhysical);
-    }
-
-    /**
-     * Add a node to the ring.
-     */
-    public synchronized void addNode(N node) {
-        if (nodeToVirtualNodes.containsKey(node)) {
-            return;
-        }
-        List<Integer> virtualNodes = new ArrayList<>(virtualNodesPerPhysical);
-        for (int i = 0; i < virtualNodesPerPhysical; i++ ) {
-            int hash = hash(node.toString() + "#" + i);
-            ring.put(hash, node);
-            virtualNodes.add(hash);
-        }
-        nodeToVirtualNodes.put(node, virtualNodes);
-    }
-
-    /**
-     * Remove a node from the ring.
-     */
-    public synchronized void removeNode(N node) {
-        List<Integer> virtualNodes = nodeToVirtualNodes.remove(node);
-        if (virtualNodes != null) {
-            virtualNodes.forEach(ring::remove);
-        }
-    }
-
-    /**
-     * Get the partition for a given key.
-     */
-    public Partition partitionFor(byte[] key) {
-        int hash = hash(key);
-        return Partition.partitionUnsafe(Math.abs(hash % Partition.MAX_PARTITIONS));
-    }
-
-    /**
-     * Get the partition for a given string key.
-     */
-    public Partition partitionFor(String key) {
-        return partitionFor(key.getBytes(StandardCharsets.UTF_8));
-    }
-
-    /**
-     * Get the primary node for a given key.
-     * Returns empty if no nodes are in the ring.
-     */
-    public Optional<N> primaryFor(byte[] key) {
-        if (ring.isEmpty()) {
-            return Optional.empty();
-        }
-        int hash = hash(key);
-        return Optional.of(getNodeForHash(hash));
-    }
-
-    /**
-     * Get the primary node for a given string key.
-     */
-    public Optional<N> primaryFor(String key) {
-        return primaryFor(key.getBytes(StandardCharsets.UTF_8));
-    }
-
-    /**
-     * Get the primary and replica nodes for a given key.
-     * Returns up to replicaCount nodes, starting with primary.
-     */
-    public List<N> nodesFor(byte[] key, int replicaCount) {
-        if (ring.isEmpty()) {
-            return List.of();
-        }
-        if (replicaCount <= 0) {
-            return List.of();
-        }
-        int hash = hash(key);
-        Set<N> seen = new LinkedHashSet<>();
-        // Start from the hash position and walk clockwise
-        Integer current = ring.ceilingKey(hash);
-        if (current == null) {
-            current = ring.firstKey();
-        }
-        while (seen.size() < replicaCount && seen.size() < nodeToVirtualNodes.size()) {
-            N node = ring.get(current);
-            seen.add(node);
-            current = ring.higherKey(current);
-            if (current == null) {
-                current = ring.firstKey();
-            }
-        }
-        return new ArrayList<>(seen);
-    }
-
-    /**
-     * Get the primary and replica nodes for a given string key.
-     */
-    public List<N> nodesFor(String key, int replicaCount) {
-        return nodesFor(key.getBytes(StandardCharsets.UTF_8), replicaCount);
-    }
-
-    /**
-     * Get all nodes currently in the ring.
-     */
-    public Set<N> nodes() {
-        return Collections.unmodifiableSet(nodeToVirtualNodes.keySet());
-    }
-
-    /**
-     * Get the number of nodes in the ring.
-     */
-    public int nodeCount() {
-        return nodeToVirtualNodes.size();
-    }
-
-    /**
-     * Check if the ring is empty.
-     */
-    public boolean isEmpty() {
-        return ring.isEmpty();
-    }
-
-    private N getNodeForHash(int hash) {
-        Integer key = ring.ceilingKey(hash);
-        if (key == null) {
-            key = ring.firstKey();
-        }
-        return ring.get(key);
-    }
-
-    /**
-     * MurmurHash3-like hash function.
-     * Provides good distribution for consistent hashing.
-     */
-    private static int hash(byte[] data) {
-        int h = 0x811c9dc5;
-        for (byte b : data) {
-            h ^= b;
-            h *= 0x01000193;
-        }
-        // Final mix
-        h ^= h>>> 16;
-        h *= 0x85ebca6b;
-        h ^= h>>> 13;
-        h *= 0xc2b2ae35;
-        h ^= h>>> 16;
-        return h;
-    }
-
-    private static int hash(String data) {
-        return hash(data.getBytes(StandardCharsets.UTF_8));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/DHTConfig.java b/common/src/main/java/org/pragmatica/dht/DHTConfig.java
deleted file mode 100644
index ad74f6a5..00000000
--- a/common/src/main/java/org/pragmatica/dht/DHTConfig.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package org.pragmatica.dht;
-/**
- * Configuration for the distributed hash table.
- *
- * @param replicationFactor number of copies of each piece of data (including primary).
- *                          Use 0 for full replication (all nodes store everything).
- * @param writeQuorum       minimum number of successful writes for operation to succeed
- * @param readQuorum        minimum number of successful reads for operation to succeed
- */
-public record DHTConfig(
- int replicationFactor,
- int writeQuorum,
- int readQuorum) {
-    /**
-     * Full replication marker - all nodes store all data.
-     */
-    public static final int FULL_REPLICATION = 0;
-
-    /**
-     * Default configuration: 3 replicas, quorum of 2 for both reads and writes.
-     */
-    public static final DHTConfig DEFAULT = new DHTConfig(3, 2, 2);
-
-    /**
-     * Single-node configuration for testing.
-     */
-    public static final DHTConfig SINGLE_NODE = new DHTConfig(1, 1, 1);
-
-    /**
-     * Full replication configuration - all nodes store all data.
-     * Read/write quorum of 1 since any node has all data.
-     */
-    public static final DHTConfig FULL = new DHTConfig(FULL_REPLICATION, 1, 1);
-
-    public DHTConfig {
-        if (replicationFactor < 0) {
-            throw new IllegalArgumentException("replicationFactor must be >= 0 (0 = full replication)");
-        }
-        if (replicationFactor > 0) {
-            if (writeQuorum < 1 || writeQuorum > replicationFactor) {
-                throw new IllegalArgumentException("writeQuorum must be between 1 and replicationFactor");
-            }
-            if (readQuorum < 1 || readQuorum > replicationFactor) {
-                throw new IllegalArgumentException("readQuorum must be between 1 and replicationFactor");
-            }
-        }
-    }
-
-    /**
-     * Create a config with the given replication factor and majority quorum.
-     * Use 0 for full replication.
-     */
-    public static DHTConfig withReplication(int replicationFactor) {
-        if (replicationFactor == FULL_REPLICATION) {
-            return FULL;
-        }
-        int quorum = (replicationFactor / 2) + 1;
-        return new DHTConfig(replicationFactor, quorum, quorum);
-    }
-
-    /**
-     * Check if this is full replication mode (all nodes store everything).
-     */
-    public boolean isFullReplication() {
-        return replicationFactor == FULL_REPLICATION;
-    }
-
-    /**
-     * Check if reads and writes overlap (strong consistency guarantee).
-     * R + W > N ensures that any read will see the most recent write.
-     * Full replication is always strongly consistent.
-     */
-    public boolean isStronglyConsistent() {
-        return isFullReplication() || readQuorum + writeQuorum > replicationFactor;
-    }
-
-    /**
-     * Get effective replication factor for a given cluster size.
-     * For full replication, returns cluster size. Otherwise returns configured value.
-     */
-    public int effectiveReplicationFactor(int clusterSize) {
-        return isFullReplication()
-               ? clusterSize
-               : Math.min(replicationFactor, clusterSize);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/DHTMessage.java b/common/src/main/java/org/pragmatica/dht/DHTMessage.java
deleted file mode 100644
index 8e97de27..00000000
--- a/common/src/main/java/org/pragmatica/dht/DHTMessage.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.message.Message;
-
-/**
- * Messages for DHT operations between nodes.
- */
-public sealed interface DHTMessage extends Message.Wired {
-    /**
-     * Request to get a value.
-     */
-    record GetRequest(String requestId, byte[] key) implements DHTMessage {}
-
-    /**
-     * Response to a get request.
-     */
-    record GetResponse(String requestId, Option<byte[] > value) implements DHTMessage {}
-
-    /**
-     * Request to put a value.
-     */
-    record PutRequest(String requestId, byte[] key, byte[] value) implements DHTMessage {}
-
-    /**
-     * Response to a put request.
-     */
-    record PutResponse(String requestId, boolean success) implements DHTMessage {}
-
-    /**
-     * Request to remove a value.
-     */
-    record RemoveRequest(String requestId, byte[] key) implements DHTMessage {}
-
-    /**
-     * Response to a remove request.
-     */
-    record RemoveResponse(String requestId, boolean found) implements DHTMessage {}
-
-    /**
-     * Request to check if key exists.
-     */
-    record ExistsRequest(String requestId, byte[] key) implements DHTMessage {}
-
-    /**
-     * Response to exists request.
-     */
-    record ExistsResponse(String requestId, boolean exists) implements DHTMessage {}
-}
diff --git a/common/src/main/java/org/pragmatica/dht/DHTNode.java b/common/src/main/java/org/pragmatica/dht/DHTNode.java
deleted file mode 100644
index d882d5e2..00000000
--- a/common/src/main/java/org/pragmatica/dht/DHTNode.java
+++ /dev/null
@@ -1,185 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.dht.storage.StorageEngine;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-/**
- * Local DHT node that handles storage operations.
- * Provides local data access and can be integrated with MessageRouter
- * for handling remote requests.
- *
- * @param <N> Node identifier type
- */
-public final class DHTNode<N extends Comparable<N>> {
-    private final N nodeId;
-    private final StorageEngine storage;
-    private final ConsistentHashRing<N> ring;
-    private final DHTConfig config;
-
-    private DHTNode(N nodeId, StorageEngine storage, ConsistentHashRing<N> ring, DHTConfig config) {
-        this.nodeId = nodeId;
-        this.storage = storage;
-        this.ring = ring;
-        this.config = config;
-    }
-
-    /**
-     * Create a new DHT node.
-     *
-     * @param nodeId  this node's identifier
-     * @param storage storage engine for local data
-     * @param ring    consistent hash ring for routing
-     * @param config  DHT configuration
-     */
-    public static <N extends Comparable<N>> DHTNode<N> dhtNode(N nodeId,
-                                                               StorageEngine storage,
-                                                               ConsistentHashRing<N> ring,
-                                                               DHTConfig config) {
-        return new DHTNode<>(nodeId, storage, ring, config);
-    }
-
-    /**
-     * Get the node's identifier.
-     */
-    public N nodeId() {
-        return nodeId;
-    }
-
-    /**
-     * Get the configuration.
-     */
-    public DHTConfig config() {
-        return config;
-    }
-
-    /**
-     * Get the consistent hash ring.
-     */
-    public ConsistentHashRing<N> ring() {
-        return ring;
-    }
-
-    /**
-     * Get a value from local storage.
-     */
-    public Promise<Option<byte[] >> getLocal(byte[] key) {
-        return storage.get(key);
-    }
-
-    /**
-     * Put a value to local storage.
-     */
-    public Promise<Unit> putLocal(byte[] key, byte[] value) {
-        return storage.put(key, value);
-    }
-
-    /**
-     * Remove a value from local storage.
-     */
-    public Promise<Boolean> removeLocal(byte[] key) {
-        return storage.remove(key);
-    }
-
-    /**
-     * Check if key exists in local storage.
-     */
-    public Promise<Boolean> existsLocal(byte[] key) {
-        return storage.exists(key);
-    }
-
-    /**
-     * Get the partition for a key.
-     */
-    public Partition partitionFor(byte[] key) {
-        return ring.partitionFor(key);
-    }
-
-    /**
-     * Check if this node is responsible for a key (as primary or replica).
-     */
-    public boolean isResponsibleFor(byte[] key) {
-        return ring.nodesFor(key,
-                             config.replicationFactor())
-                   .contains(nodeId);
-    }
-
-    /**
-     * Check if this node is the primary for a key.
-     */
-    public boolean isPrimaryFor(byte[] key) {
-        return ring.primaryFor(key)
-                   .map(nodeId::equals)
-                   .orElse(false);
-    }
-
-    /**
-     * Get the local storage size.
-     */
-    public long localSize() {
-        return storage.size();
-    }
-
-    /**
-     * Clear local storage.
-     */
-    public Promise<Unit> clearLocal() {
-        return storage.clear();
-    }
-
-    /**
-     * Shutdown the node and release resources.
-     */
-    public Promise<Unit> shutdown() {
-        return storage.shutdown();
-    }
-
-    /**
-     * Handle a get request (for message routing integration).
-     */
-    public void handleGetRequest(DHTMessage.GetRequest request,
-                                 java.util.function.Consumer<DHTMessage.GetResponse> responseHandler) {
-        storage.get(request.key())
-               .onSuccess(value -> responseHandler.accept(
-        new DHTMessage.GetResponse(request.requestId(),
-                                   value)));
-    }
-
-    /**
-     * Handle a put request (for message routing integration).
-     */
-    public void handlePutRequest(DHTMessage.PutRequest request,
-                                 java.util.function.Consumer<DHTMessage.PutResponse> responseHandler) {
-        storage.put(request.key(),
-                    request.value())
-               .onSuccess(_ -> responseHandler.accept(
-        new DHTMessage.PutResponse(request.requestId(),
-                                   true)))
-               .onFailure(_ -> responseHandler.accept(
-        new DHTMessage.PutResponse(request.requestId(),
-                                   false)));
-    }
-
-    /**
-     * Handle a remove request (for message routing integration).
-     */
-    public void handleRemoveRequest(DHTMessage.RemoveRequest request,
-                                    java.util.function.Consumer<DHTMessage.RemoveResponse> responseHandler) {
-        storage.remove(request.key())
-               .onSuccess(found -> responseHandler.accept(
-        new DHTMessage.RemoveResponse(request.requestId(),
-                                      found)));
-    }
-
-    /**
-     * Handle an exists request (for message routing integration).
-     */
-    public void handleExistsRequest(DHTMessage.ExistsRequest request,
-                                    java.util.function.Consumer<DHTMessage.ExistsResponse> responseHandler) {
-        storage.exists(request.key())
-               .onSuccess(exists -> responseHandler.accept(
-        new DHTMessage.ExistsResponse(request.requestId(),
-                                      exists)));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java b/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
index d9c866bc..80aa4f2e 100644
--- a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
+++ b/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
@@ -20,7 +20,7 @@ private LocalDHTClient(DHTNode<N> node) {
     /**
      * Create a local DHT client backed by the given node.
      */
-    public static <N extends Comparable<N>> LocalDHTClient<N> create(DHTNode<N> node) {
+    public static <N extends Comparable<N>> LocalDHTClient<N> localDHTClient(DHTNode<N> node) {
         return new LocalDHTClient<>(node);
     }
 
diff --git a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java b/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
index cd4ca72a..b439b641 100644
--- a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
+++ b/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
@@ -19,12 +19,12 @@ private LocalPartitionMap(ConsistentHashRing<N> ring) {
         this.ring = ring;
     }
 
-    public static <N extends Comparable<N>> LocalPartitionMap<N> create() {
-        return new LocalPartitionMap<>(ConsistentHashRing.<N>create());
+    public static <N extends Comparable<N>> LocalPartitionMap<N> localPartitionMap() {
+        return new LocalPartitionMap<>(ConsistentHashRing.<N>consistentHashRing());
     }
 
-    public static <N extends Comparable<N>> LocalPartitionMap<N> create(int virtualNodesPerPhysical) {
-        return new LocalPartitionMap<>(ConsistentHashRing.<N>create(virtualNodesPerPhysical));
+    public static <N extends Comparable<N>> LocalPartitionMap<N> localPartitionMap(int virtualNodesPerPhysical) {
+        return new LocalPartitionMap<>(ConsistentHashRing.<N>consistentHashRing(virtualNodesPerPhysical));
     }
 
     @Override
diff --git a/common/src/main/java/org/pragmatica/dht/Partition.java b/common/src/main/java/org/pragmatica/dht/Partition.java
deleted file mode 100644
index baefe222..00000000
--- a/common/src/main/java/org/pragmatica/dht/Partition.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Cause;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.utils.Causes;
-
-/**
- * A partition identifier in the DHT consistent hash ring.
- * Partitions are numbered 0 to MAX_PARTITIONS-1 (default 1024 partitions).
- */
-public record Partition(int value) implements Comparable<Partition> {
-    public static final int MAX_PARTITIONS = 1024;
-
-    private static final Cause INVALID_PARTITION = Causes.cause("Partition must be between 0 and " + (MAX_PARTITIONS - 1));
-
-    public Partition {
-        if (value < 0 || value >= MAX_PARTITIONS) {
-            throw new IllegalArgumentException(INVALID_PARTITION.message());
-        }
-    }
-
-    public static Result<Partition> partition(int value) {
-        if (value < 0 || value >= MAX_PARTITIONS) {
-            return INVALID_PARTITION.result();
-        }
-        return Result.success(new Partition(value));
-    }
-
-    public static Partition partitionUnsafe(int value) {
-        return new Partition(value);
-    }
-
-    /**
-     * Get the next partition in the ring (wraps around).
-     */
-    public Partition next() {
-        return new Partition((value + 1) % MAX_PARTITIONS);
-    }
-
-    /**
-     * Get the previous partition in the ring (wraps around).
-     */
-    public Partition previous() {
-        return new Partition((value - 1 + MAX_PARTITIONS) % MAX_PARTITIONS);
-    }
-
-    @Override
-    public int compareTo(Partition other) {
-        return Integer.compare(this.value, other.value);
-    }
-
-    @Override
-    public String toString() {
-        return "P" + value;
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java b/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
deleted file mode 100644
index c1978646..00000000
--- a/common/src/main/java/org/pragmatica/dht/storage/MemoryStorageEngine.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.pragmatica.dht.storage;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-import java.util.Arrays;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * In-memory storage engine backed by ConcurrentHashMap.
- * Thread-safe and suitable for development and testing.
- * Data is not persisted across restarts.
- */
-public final class MemoryStorageEngine implements StorageEngine {
-    private final ConcurrentHashMap<ByteArrayKey, byte[] > data = new ConcurrentHashMap<>();
-
-    private MemoryStorageEngine() {}
-
-    public static MemoryStorageEngine create() {
-        return new MemoryStorageEngine();
-    }
-
-    @Override
-    public Promise<Option<byte[] >> get(byte[] key) {
-        byte[] value = data.get(new ByteArrayKey(key));
-        return Promise.success(value != null
-                               ? Option.some(value.clone())
-                               : Option.none());
-    }
-
-    @Override
-    public Promise<Unit> put(byte[] key, byte[] value) {
-        data.put(new ByteArrayKey(key), value.clone());
-        return Promise.success(Unit.unit());
-    }
-
-    @Override
-    public Promise<Boolean> remove(byte[] key) {
-        byte[] removed = data.remove(new ByteArrayKey(key));
-        return Promise.success(removed != null);
-    }
-
-    @Override
-    public Promise<Boolean> exists(byte[] key) {
-        return Promise.success(data.containsKey(new ByteArrayKey(key)));
-    }
-
-    @Override
-    public long size() {
-        return data.size();
-    }
-
-    @Override
-    public Promise<Unit> clear() {
-        data.clear();
-        return Promise.success(Unit.unit());
-    }
-
-    @Override
-    public Promise<Unit> shutdown() {
-        data.clear();
-        return Promise.success(Unit.unit());
-    }
-
-    /**
-     * Wrapper for byte[] to use as HashMap key with proper equals/hashCode.
-     */
-    private record ByteArrayKey(byte[] data) {
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (! (o instanceof ByteArrayKey that)) return false;
-            return Arrays.equals(data, that.data);
-        }
-
-        @Override
-        public int hashCode() {
-            return Arrays.hashCode(data);
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java b/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
deleted file mode 100644
index ecca4b20..00000000
--- a/common/src/main/java/org/pragmatica/dht/storage/StorageEngine.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package org.pragmatica.dht.storage;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-/**
- * Storage engine interface for DHT data storage.
- * Implementations may use in-memory storage, off-heap memory, or persistent storage.
- */
-public interface StorageEngine {
-    /**
-     * Get a value by key.
-     *
-     * @param key the key to look up
-     * @return the value if present, or empty option
-     */
-    Promise<Option<byte[] >> get(byte[] key);
-
-    /**
-     * Store a value.
-     *
-     * @param key   the key
-     * @param value the value to store
-     * @return promise that completes when value is stored
-     */
-    Promise<Unit> put(byte[] key, byte[] value);
-
-    /**
-     * Remove a value.
-     *
-     * @param key the key to remove
-     * @return true if value was present and removed, false if not found
-     */
-    Promise<Boolean> remove(byte[] key);
-
-    /**
-     * Check if a key exists.
-     *
-     * @param key the key to check
-     * @return true if key exists
-     */
-    Promise<Boolean> exists(byte[] key);
-
-    /**
-     * Get approximate number of entries.
-     */
-    long size();
-
-    /**
-     * Clear all entries.
-     */
-    Promise<Unit> clear();
-
-    /**
-     * Shutdown the storage engine and release resources.
-     */
-    Promise<Unit> shutdown();
-}
diff --git a/common/src/main/java/org/pragmatica/message/Message.java b/common/src/main/java/org/pragmatica/message/Message.java
deleted file mode 100644
index 58cd987f..00000000
--- a/common/src/main/java/org/pragmatica/message/Message.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.pragmatica.message;
-/// Marker interface for all messages circulating inside the system
-public sealed interface Message {
-    non-sealed interface Local extends Message {}
-
-    non-sealed interface Wired extends Message {}
-}
diff --git a/common/src/main/java/org/pragmatica/message/MessageReceiver.java b/common/src/main/java/org/pragmatica/message/MessageReceiver.java
deleted file mode 100644
index 303ae11b..00000000
--- a/common/src/main/java/org/pragmatica/message/MessageReceiver.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.pragmatica.message;
-
-import java.lang.annotation.*;
-
-/// This annotation marks methods which handler messages from [MessageRouter].
-/// At present this annotation is used only for documentation purposes.
-@Documented
-@Retention(RetentionPolicy.SOURCE)
-@Target(ElementType.METHOD)
-@Inherited
-public @interface MessageReceiver {}
diff --git a/common/src/main/java/org/pragmatica/message/MessageRouter.java b/common/src/main/java/org/pragmatica/message/MessageRouter.java
deleted file mode 100644
index cb3de096..00000000
--- a/common/src/main/java/org/pragmatica/message/MessageRouter.java
+++ /dev/null
@@ -1,176 +0,0 @@
-package org.pragmatica.message;
-
-import org.pragmatica.lang.Cause;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Tuple.Tuple2;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.CopyOnWriteArrayList;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.lang.Tuple.tuple;
-
-/// **NOTE**: This implementation assumes that the instance is configured and then used without
-/// changes.
-public sealed interface MessageRouter {
-    <T extends Message> void route(T message);
-
-    default <T extends Message> void routeAsync(Supplier<T> messageSupplier) {
-        Promise.async(() -> route(messageSupplier.get()));
-    }
-
-    static MutableRouter mutable() {
-        return new MutableRouter.SimpleMutableRouter<>(new ConcurrentHashMap<>());
-    }
-
-    sealed interface MutableRouter extends MessageRouter {
-        <T extends Message> MessageRouter addRoute(Class< ? extends T> messageType, Consumer< ? extends T> receiver);
-
-        record SimpleMutableRouter<T extends Message>(
-        ConcurrentMap<Class<T>, List<Consumer<T>>> routingTable) implements MutableRouter {
-            private static final Logger log = LoggerFactory.getLogger(MessageRouter.class);
-
-            @Override
-            public <R extends Message> void route(R message) {
-                Option.option(routingTable.get(message.getClass()))
-                      .onPresent(list -> list.forEach(fn -> fn.accept((T) message)))
-                      .onEmpty(() -> log.warn("No route for message type: {}",
-                                              message.getClass()
-                                                     .getSimpleName()));
-            }
-
-            @SuppressWarnings("unchecked")
-            @Override
-            public <R extends Message> MessageRouter addRoute(Class< ? extends R> messageType,
-                                                              Consumer< ? extends R> receiver) {
-                routingTable.computeIfAbsent((Class<T>) messageType,
-                                             _ -> new CopyOnWriteArrayList<>())
-                            .add((Consumer<T>) receiver);
-                return this;
-            }
-        }
-    }
-
-    non-sealed interface ImmutableRouter<T extends Message> extends MessageRouter {
-        Map<Class<T>, List<Consumer<T>>> routingTable();
-
-        @SuppressWarnings("unchecked")
-        default <R extends Message> void route(R message) {
-            routingTable()
-            .get(message.getClass())
-            .forEach(fn -> fn.accept((T) message));
-        }
-    }
-
-    interface Entry<T extends Message> {
-        Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries();
-
-        Class<T> type();
-
-        Set<Class< ? >> validate();
-
-        @SuppressWarnings("unchecked")
-        default Result<MessageRouter> asRouter() {
-            var validated = validate();
-            if (!validated.isEmpty()) {
-                var missing = validated.stream()
-                                       .map(Class::getSimpleName)
-                                       .collect(Collectors.joining(", "));
-                return new InvalidMessageRouterConfiguration("Missing message types: " + missing).result();
-            }
-            record router <T extends Message>(
-            Map<Class<T>, List<Consumer<T>>> routingTable) implements ImmutableRouter<T> {}
-            var routingTable = new HashMap<Class<T>, List<Consumer<T>>>();
-            entries()
-            .forEach(tuple -> routingTable.compute((Class<T>) tuple.first(),
-                                                   (_, oldValue) -> merge(tuple, oldValue)));
-            return Result.success(new router <>(routingTable));
-        }
-
-        @SuppressWarnings("unchecked")
-        private static <T extends Message> List<Consumer<T>> merge(Tuple2<Class< ? extends T>, Consumer< ? extends T>> tuple,
-                                                                   List<Consumer<T>> oldValue) {
-            var list = oldValue == null
-                       ? new ArrayList<Consumer<T>>()
-                       : oldValue;
-            list.add((Consumer<T>) tuple.last());
-            return list;
-        }
-
-        interface SealedBuilder<T extends Message> extends Entry<T> {
-            static <T extends Message> SealedBuilder<T> from(Class<T> clazz) {
-                record sealedBuilder <T extends Message>(Class<T> type,
-                                                         List<Entry< ? extends T>> routes) implements SealedBuilder<T> {
-                    @SuppressWarnings("unchecked")
-                    @Override
-                    public Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries() {
-                        return routes.stream()
-                                     .map(entry -> (Entry<T>) entry)
-                                     .flatMap(Entry::entries);
-                    }
-
-                    @SafeVarargs
-                    @Override
-                    public final Entry<T> route(Entry<? extends T>... routes) {
-                        routes()
-                        .addAll(List.of(routes));
-                        return this;
-                    }
-
-                    @Override
-                    public Set<Class< ? >> validate() {
-                        if (!type()
-                             .isSealed()) {
-                            return mergeSubroutes(new HashSet<>());
-                        }
-                        var declared = routes()
-                                       .stream()
-                                       .map(Entry::type)
-                                       .collect(Collectors.toSet());
-                        var permitted = new HashSet<>(Set.of(type()
-                                                             .getPermittedSubclasses()));
-                        permitted.removeAll(declared);
-                        return mergeSubroutes(permitted);
-                    }
-
-                    private Set<Class< ? >> mergeSubroutes(Set<Class< ? >> local) {
-                        routes()
-                        .forEach(route -> local.addAll(route.validate()));
-                        return local;
-                    }
-                }
-                return new sealedBuilder <>(clazz, new ArrayList<>());
-            }
-
-            @SuppressWarnings("unchecked")
-            Entry<T> route(Entry<? extends T>... routes);
-        }
-
-        static <T extends Message> Entry<T> route(Class<T> type, Consumer<T> receiver) {
-            record entry <T extends Message>(Class<T> type, Consumer<T> receiver) implements Entry<T> {
-                @Override
-                public Stream<Tuple2<Class< ? extends T>, Consumer< ? extends T>>> entries() {
-                    return Stream.of(tuple(type(), receiver()));
-                }
-
-                @Override
-                public Set<Class< ? >> validate() {
-                    return Set.of();
-                }
-            }
-            return new entry <>(type, receiver);
-        }
-    }
-
-    record InvalidMessageRouterConfiguration(String message) implements Cause {}
-}
diff --git a/common/src/main/java/org/pragmatica/message/RouterConfigurator.java b/common/src/main/java/org/pragmatica/message/RouterConfigurator.java
deleted file mode 100644
index 1d3f1233..00000000
--- a/common/src/main/java/org/pragmatica/message/RouterConfigurator.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package org.pragmatica.message;
-public interface RouterConfigurator {
-    void configure(MessageRouter router);
-}
diff --git a/common/src/main/java/org/pragmatica/net/AsyncCloseable.java b/common/src/main/java/org/pragmatica/net/AsyncCloseable.java
new file mode 100644
index 00000000..916c9223
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/AsyncCloseable.java
@@ -0,0 +1,11 @@
+package org.pragmatica.net;
+
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+
+/**
+ * Interface for resources that can be closed asynchronously.
+ */
+public interface AsyncCloseable {
+    Promise<Unit> close();
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DnsClient.java b/common/src/main/java/org/pragmatica/net/dns/DnsClient.java
new file mode 100644
index 00000000..63131e43
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/DnsClient.java
@@ -0,0 +1,199 @@
+package org.pragmatica.net.dns;
+
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.lang.io.TimeSpan;
+import org.pragmatica.net.AsyncCloseable;
+import org.pragmatica.net.dns.ResolverErrors.RequestTimeout;
+import org.pragmatica.net.dns.ResolverErrors.ServerError;
+
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.netty.bootstrap.Bootstrap;
+import io.netty.buffer.ByteBufUtil;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.channel.socket.DatagramChannel;
+import io.netty.channel.socket.nio.NioDatagramChannel;
+import io.netty.handler.codec.dns.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.pragmatica.lang.Option.option;
+import static org.pragmatica.lang.Unit.unit;
+import static org.pragmatica.lang.io.TimeSpan.timeSpan;
+
+/**
+ * Asynchronous DNS client using Netty UDP.
+ */
+public interface DnsClient extends AsyncCloseable {
+    Logger log = LoggerFactory.getLogger(DnsClient.class);
+
+    Promise<DomainAddress> resolve(DomainName domainName, InetSocketAddress serverAddress);
+
+    /**
+     * Create DNS client with provided event loop group.
+     * The event loop group will NOT be shut down when the client is closed.
+     */
+    static DnsClient dnsClient(EventLoopGroup eventLoopGroup) {
+        var bootstrap = new Bootstrap().group(eventLoopGroup)
+                        .channel(NioDatagramChannel.class);
+        var client = DnsClientImpl.forBootstrap(bootstrap, false);
+        bootstrap.handler(DnsChannelInitializer.forClient(client));
+        return client;
+    }
+}
+
+class DnsChannelInitializer extends ChannelInitializer<DatagramChannel> {
+    private final DnsClientImpl client;
+
+    private DnsChannelInitializer(DnsClientImpl client) {
+        this.client = client;
+    }
+
+    static DnsChannelInitializer forClient(DnsClientImpl client) {
+        return new DnsChannelInitializer(client);
+    }
+
+    @Override
+    protected void initChannel(DatagramChannel ch) {
+        ch.pipeline()
+          .addLast(new DatagramDnsQueryEncoder())
+          .addLast(new DatagramDnsResponseDecoder())
+          .addLast(new SimpleChannelInboundHandler<DatagramDnsResponse>() {
+            @Override
+            protected void channelRead0(ChannelHandlerContext ctx, DatagramDnsResponse msg) {
+                       try{
+                       client.handleDatagram(msg);
+                   } finally{
+                       ctx.close();
+                   }
+                   }
+        });
+    }
+}
+
+record Request(DomainName domainName, Promise<DomainAddress> promise, int requestId) {}
+
+record DnsClientImpl(Bootstrap bootstrap,
+                     ConcurrentHashMap<Integer, Request> requestMap,
+                     AtomicInteger idCounter,
+                     boolean ownsEventLoop) implements DnsClient {
+    private static final TimeSpan QUERY_TIMEOUT = timeSpan(10)
+                                                 .seconds();
+
+    static DnsClientImpl forBootstrap(Bootstrap bootstrap, boolean ownsEventLoop) {
+        return new DnsClientImpl(bootstrap, new ConcurrentHashMap<>(), new AtomicInteger(1), ownsEventLoop);
+    }
+
+    @Override
+    public Promise<DomainAddress> resolve(DomainName domainName, InetSocketAddress serverAddress) {
+        return Promise.promise(promise -> fireRequest(promise, domainName, serverAddress));
+    }
+
+    @Override
+    public Promise<Unit> close() {
+        if (!ownsEventLoop) {
+            return Promise.success(unit());
+        }
+        return Promise.promise(promise -> bootstrap()
+                                          .config()
+                                          .group()
+                                          .shutdownGracefully()
+                                          .addListener(_ -> promise.succeed(unit())));
+    }
+
+    void handleDatagram(DatagramDnsResponse msg) {
+        var requestId = msg.id();
+        log.debug("Received response for request Id {}", requestId);
+        option(requestMap.get(requestId))
+        .onPresent(request -> handleResponse(request, msg));
+    }
+
+    private void handleResponse(Request request, DatagramDnsResponse msg) {
+        log.debug("Handling response {} for request {}", msg, request);
+        if (!msg.code()
+                .equals(DnsResponseCode.NOERROR)) {
+            var errorMessage = "Server responded with error code " + msg.code();
+            log.warn(errorMessage);
+            request.promise()
+                   .fail(new ServerError(errorMessage));
+            return;
+        }
+        // Take record with minimal TTL
+        // This is less efficient in regard to number of requests, but enables
+        // faster propagation of DNS changes.
+        extractAddresses(request, msg)
+        .stream()
+        .min(Comparator.comparing(DomainAddress::ttl))
+        .ifPresentOrElse(address -> request.promise()
+                                           .succeed(address),
+                         () -> request.promise()
+                                      .fail(new ServerError("No address provided by server")));
+    }
+
+    private static ArrayList<DomainAddress> extractAddresses(Request request, DatagramDnsResponse msg) {
+        var addresses = new ArrayList<DomainAddress>();
+        for (int i = 0, count = msg.count(DnsSection.ANSWER); i < count; i++ ) {
+            var record = msg.recordAt(DnsSection.ANSWER, i);
+            if (record.type() == DnsRecordType.A) {
+                var raw = (DnsRawRecord) record;
+                log.debug("record {}, ttl {}", raw, raw.timeToLive());
+                InetUtils.forBytes(ByteBufUtil.getBytes(raw.content()))
+                         .map(inetAddress -> DomainAddress.domainAddress(request.domainName(),
+                                                                         inetAddress,
+                                                                         Duration.ofSeconds(raw.timeToLive())))
+                         .onSuccess(addresses::add)
+                         .onFailureRun(() -> log.warn("Response for {} contains incorrectly formatted IP address",
+                                                      request.domainName()));
+            }
+        }
+        return addresses;
+    }
+
+    private void fireRequest(Promise<DomainAddress> promise, DomainName domainName, InetSocketAddress serverAddress) {
+        bootstrap()
+        .bind(0)
+        .syncUninterruptibly()
+        .channel()
+        .writeAndFlush(buildQuery(serverAddress, promise, domainName));
+        // Setup guard timeout
+        promise.async(QUERY_TIMEOUT,
+                      pending -> pending.fail(new RequestTimeout("No response from server in 10 seconds")));
+    }
+
+    private DatagramDnsQuery buildQuery(InetSocketAddress serverAddress,
+                                        Promise<DomainAddress> promise,
+                                        DomainName domainName) {
+        var request = computeRequest(promise, domainName);
+        log.debug("Sending request {} to {}", request, serverAddress);
+        return new DatagramDnsQuery(null, serverAddress, request.requestId()).setRecursionDesired(true)
+                                                                .setRecord(DnsSection.QUESTION,
+                                                                           new DefaultDnsQuestion(request.domainName()
+                                                                                                         .name(),
+                                                                                                  DnsRecordType.A));
+    }
+
+    private Request computeRequest(Promise<DomainAddress> promise, DomainName domainName) {
+        for (int attempt = 0; attempt < 0xFFFF; attempt++ ) {
+            var requestId = idCounter()
+                            .getAndIncrement() & 0xFFFF;
+            var request = new Request(domainName, promise, requestId);
+            if (requestMap()
+                .putIfAbsent(requestId, request) == null) {
+                // Ensure slot for this ID is freed regardless of the outcome
+                promise.onResultRun(() -> requestMap()
+                                          .remove(requestId));
+                return request;
+            }
+        }
+        throw new IllegalStateException("Unable to generate request id (too many requests in progress)");
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java b/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
new file mode 100644
index 00000000..f214e646
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
@@ -0,0 +1,24 @@
+package org.pragmatica.net.dns;
+
+import java.net.InetAddress;
+import java.time.Duration;
+
+/**
+ * Resolved domain address with TTL.
+ */
+public interface DomainAddress {
+    DomainName name();
+
+    InetAddress ip();
+
+    Duration ttl();
+
+    static DomainAddress domainAddress(DomainName name, InetAddress ip, Duration ttl) {
+        record domainAddress(DomainName name, InetAddress ip, Duration ttl) implements DomainAddress {}
+        return new domainAddress(name, ip, ttl);
+    }
+
+    default DomainAddress withDomain(DomainName domainName) {
+        return domainAddress(domainName, ip(), ttl());
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainName.java b/common/src/main/java/org/pragmatica/net/dns/DomainName.java
new file mode 100644
index 00000000..545e54a0
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/DomainName.java
@@ -0,0 +1,9 @@
+package org.pragmatica.net.dns;
+/**
+ * Domain name to resolve.
+ */
+public record DomainName(String name) {
+    public static DomainName domainName(String domainName) {
+        return new DomainName(domainName);
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java b/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
new file mode 100644
index 00000000..24b299be
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
@@ -0,0 +1,150 @@
+package org.pragmatica.net.dns;
+
+import org.pragmatica.lang.Promise;
+import org.pragmatica.lang.Result;
+import org.pragmatica.lang.Unit;
+import org.pragmatica.lang.io.TimeSpan;
+import org.pragmatica.net.AsyncCloseable;
+import org.pragmatica.net.dns.ResolverErrors.UnknownDomain;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.MultiThreadIoEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.pragmatica.lang.Option.option;
+import static org.pragmatica.lang.Promise.resolved;
+import static org.pragmatica.lang.Promise.success;
+import static org.pragmatica.lang.io.TimeSpan.timeSpan;
+import static org.pragmatica.net.dns.DomainAddress.domainAddress;
+import static org.pragmatica.net.dns.DomainName.domainName;
+
+/**
+ * Asynchronous domain name resolver with TTL-based caching.
+ * <p>
+ * The cache uses promise mechanics for automatic TTL expiry - no background threads required.
+ * Each successful resolution schedules its own eviction via {@code promise.async(ttl, ...)}.
+ */
+public interface DomainNameResolver extends AsyncCloseable {
+    int DNS_UDP_PORT = 53;
+    Result<DomainAddress>UNKNOWN_DOMAIN = new UnknownDomain("Unknown domain").result();
+
+    /**
+     * Resolve domain name, using cache if available.
+     */
+    default Promise<DomainAddress> resolve(String name) {
+        return resolve(domainName(name));
+    }
+
+    /**
+     * Resolve domain name, using cache if available.
+     */
+    Promise<DomainAddress> resolve(DomainName name);
+
+    /**
+     * Get cached resolution result without triggering new resolution.
+     */
+    default Promise<DomainAddress> resolveCached(String name) {
+        return resolveCached(domainName(name));
+    }
+
+    /**
+     * Get cached resolution result without triggering new resolution.
+     */
+    Promise<DomainAddress> resolveCached(DomainName name);
+
+    /**
+     * Create resolver with provided DNS servers, using own event loop.
+     * The event loop will be shut down when the resolver is closed.
+     *
+     * @param servers list of DNS server addresses
+     * @return new resolver instance
+     */
+    static DomainNameResolver domainNameResolver(List<InetAddress> servers) {
+        var eventLoop = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+        return new Resolver(
+        DnsClient.dnsClient(eventLoop), prepareServers(servers), buildDnsCache(), eventLoop, true);
+    }
+
+    /**
+     * Create resolver with provided DNS servers, sharing the given event loop.
+     * The event loop will NOT be shut down when the resolver is closed.
+     *
+     * @param servers    list of DNS server addresses
+     * @param eventLoop  event loop group to use for DNS queries
+     * @return new resolver instance
+     */
+    static DomainNameResolver domainNameResolver(List<InetAddress> servers, EventLoopGroup eventLoop) {
+        return new Resolver(
+        DnsClient.dnsClient(eventLoop), prepareServers(servers), buildDnsCache(), eventLoop, false);
+    }
+
+    private static List<InetSocketAddress> prepareServers(List<InetAddress> serverList) {
+        return serverList.stream()
+                         .map(ip -> new InetSocketAddress(ip, DNS_UDP_PORT))
+                         .toList();
+    }
+
+    private static ConcurrentHashMap<DomainName, Promise<DomainAddress>> buildDnsCache() {
+        var cache = new ConcurrentHashMap<DomainName, Promise<DomainAddress>>();
+        var resolvedLocalHost = domainAddress(
+        domainName("localhost"), InetAddress.getLoopbackAddress(), Duration.ofSeconds(0));
+        cache.put(resolvedLocalHost.name(), success(resolvedLocalHost));
+        return cache;
+    }
+}
+
+record Resolver(
+ DnsClient client,
+ List<InetSocketAddress> serverList,
+ ConcurrentHashMap<DomainName, Promise<DomainAddress>> cache,
+ EventLoopGroup eventLoop,
+ boolean ownsEventLoop) implements DomainNameResolver {
+    private static final Logger log = LoggerFactory.getLogger(DomainNameResolver.class);
+
+    @Override
+    public Promise<DomainAddress> resolveCached(DomainName name) {
+        return option(cache.get(name))
+               .or(() -> resolved(UNKNOWN_DOMAIN));
+    }
+
+    @Override
+    public Promise<DomainAddress> resolve(DomainName name) {
+        var promise = cache.computeIfAbsent(name, this::fireRequest);
+        // Do not cache failed requests and observe TTL for successful ones
+        return promise.onFailureRun(() -> cache.remove(name))
+                      .onSuccess(domainAddress -> {
+                                     log.debug("TTL for {} is {}",
+                                               domainAddress.name(),
+                                               domainAddress.ttl());
+                                     var ttl = TimeSpan.fromDuration(domainAddress.ttl());
+                                     promise.async(ttl,
+                                                   _ -> log.debug("TTL expired, removing {} from cache",
+                                                                  cache.remove(domainAddress.name())));
+                                 });
+    }
+
+    private Promise<DomainAddress> fireRequest(DomainName domainName) {
+        return Promise.any(UNKNOWN_DOMAIN,
+                           serverList.stream()
+                                     .map(server -> client.resolve(domainName, server))
+                                     .toList());
+    }
+
+    @Override
+    public Promise<Unit> close() {
+        if (!ownsEventLoop) {
+            return client.close();
+        }
+        return client.close()
+                     .flatMap(_ -> Promise.promise(promise -> eventLoop.shutdownGracefully()
+                                                                       .addListener(_ -> promise.succeed(Unit.unit()))));
+    }
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/InetUtils.java b/common/src/main/java/org/pragmatica/net/dns/InetUtils.java
new file mode 100644
index 00000000..82d3cba3
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/InetUtils.java
@@ -0,0 +1,27 @@
+package org.pragmatica.net.dns;
+
+import org.pragmatica.lang.Cause;
+import org.pragmatica.lang.Result;
+import org.pragmatica.net.dns.ResolverErrors.InvalidIpAddress;
+import org.pragmatica.net.dns.ResolverErrors.UnknownError;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+
+/**
+ * Utilities for working with InetAddress.
+ */
+public final class InetUtils {
+    public static Result<InetAddress> forBytes(byte[] address) {
+        return Result.lift(InetUtils::exceptionMapper, () -> InetAddress.getByAddress(address));
+    }
+
+    static Cause exceptionMapper(Throwable throwable) {
+        if (throwable instanceof UnknownHostException) {
+            return new InvalidIpAddress(throwable.getMessage());
+        }
+        return new UnknownError(throwable.getMessage());
+    }
+
+    private InetUtils() {}
+}
diff --git a/common/src/main/java/org/pragmatica/net/dns/README.md b/common/src/main/java/org/pragmatica/net/dns/README.md
new file mode 100644
index 00000000..1ec63b63
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/README.md
@@ -0,0 +1,178 @@
+# Asynchronous DNS Resolver
+
+Fully asynchronous DNS resolver with TTL-based caching using Netty UDP.
+
+## Features
+
+- **Fully async**: Returns `Promise<DomainAddress>` - no blocking
+- **TTL caching**: Automatic cache eviction based on DNS TTL
+- **Multi-server failover**: Queries multiple DNS servers, returns first success
+- **Event loop sharing**: Can use own event loop or share with existing server
+- **Zero background threads**: Cache eviction uses promise mechanics
+
+## Quick Start
+
+```java
+import org.pragmatica.net.dns.DomainNameResolver;
+import java.net.InetAddress;
+import java.util.List;
+
+// Create resolver with public DNS servers
+var resolver = DomainNameResolver.domainNameResolver(List.of(
+    InetAddress.getByName("8.8.8.8"),      // Google DNS
+    InetAddress.getByName("1.1.1.1")       // Cloudflare DNS
+));
+
+// Resolve domain
+resolver.resolve("example.com")
+        .onSuccess(address -> {
+            System.out.println("IP: " + address.ip());
+            System.out.println("TTL: " + address.ttl());
+        })
+        .onFailure(cause -> {
+            System.err.println("Resolution failed: " + cause.message());
+        });
+
+// Don't forget to close when done
+resolver.close();
+```
+
+## API
+
+### DomainNameResolver
+
+Main entry point for DNS resolution.
+
+```java
+public interface DomainNameResolver extends AsyncCloseable {
+    // Resolve domain, using cache if available
+    Promise<DomainAddress> resolve(String name);
+    Promise<DomainAddress> resolve(DomainName name);
+
+    // Get cached result without triggering resolution
+    Promise<DomainAddress> resolveCached(String name);
+    Promise<DomainAddress> resolveCached(DomainName name);
+
+    // Factory methods
+    static DomainNameResolver domainNameResolver(List<InetAddress> servers);
+    static DomainNameResolver domainNameResolver(List<InetAddress> servers, EventLoopGroup eventLoop);
+}
+```
+
+### Factory Methods
+
+**Own event loop** (auto-cleanup on close):
+```java
+var resolver = DomainNameResolver.domainNameResolver(List.of(
+    InetAddress.getByName("8.8.8.8")
+));
+// Event loop created internally, shut down when resolver.close() called
+```
+
+**Shared event loop** (no cleanup, caller manages lifecycle):
+```java
+var sharedEventLoop = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
+var resolver = DomainNameResolver.domainNameResolver(servers, sharedEventLoop);
+// Event loop NOT shut down when resolver.close() called
+// Useful when sharing with Server or other components
+```
+
+### DomainAddress
+
+Resolved address with metadata.
+
+```java
+public interface DomainAddress {
+    DomainName name();    // Original domain name
+    InetAddress ip();     // Resolved IP address
+    Duration ttl();       // Time-to-live from DNS response
+}
+```
+
+### Error Handling
+
+All errors are typed via `ResolverErrors`:
+
+```java
+public sealed interface ResolverErrors extends Cause {
+    record InvalidIpAddress(String message) implements ResolverErrors {}
+    record ServerError(String message) implements ResolverErrors {}
+    record RequestTimeout(String message) implements ResolverErrors {}
+    record UnknownError(String message) implements ResolverErrors {}
+    record UnknownDomain(String message) implements ResolverErrors {}
+}
+```
+
+## Caching Behavior
+
+The resolver implements intelligent caching:
+
+1. **Successful resolutions** are cached until TTL expires
+2. **Failed resolutions** are NOT cached (allows retry)
+3. **TTL eviction** uses `promise.async(ttl, ...)` - no background threads
+4. **localhost** is pre-cached with infinite TTL
+
+```java
+// First call: DNS query sent
+resolver.resolve("example.com").await();
+
+// Second call: returns cached result (no network)
+resolver.resolve("example.com").await();
+
+// After TTL expires: DNS query sent again
+```
+
+## Multi-Server Failover
+
+When multiple DNS servers are configured:
+
+```java
+var resolver = DomainNameResolver.domainNameResolver(List.of(
+    InetAddress.getByName("8.8.8.8"),      // Primary
+    InetAddress.getByName("8.8.4.4"),      // Secondary
+    InetAddress.getByName("1.1.1.1")       // Tertiary
+));
+```
+
+- Queries are sent to ALL servers in parallel
+- First successful response wins (`Promise.any()`)
+- Response with shortest TTL is preferred (faster DNS change propagation)
+- If all fail, returns `UnknownDomain` error
+
+## Timeout Handling
+
+Each DNS query has a 10-second timeout. If no response is received:
+
+```java
+resolver.resolve("slow-dns.example.com")
+        .onFailure(cause -> {
+            // cause instanceof ResolverErrors.RequestTimeout
+        });
+```
+
+## Thread Safety
+
+- `DomainNameResolver` is fully thread-safe
+- Cache operations use `ConcurrentHashMap`
+- Safe for concurrent resolution from multiple threads
+
+## Dependencies
+
+- Netty (`netty-codec-dns`, `netty-transport`)
+- Pragmatica Lite Core (`Promise`, `Result`, `Cause`, `TimeSpan`)
+- SLF4J for logging
+
+## Integration with Server
+
+Share event loop between DNS resolver and TCP server:
+
+```java
+// Server creates event loops
+var server = Server.server(config, channelHandlers).await().unsafe();
+
+// DNS shares the worker group (access via reflection or expose getter)
+// Or create shared event loop externally:
+var sharedLoop = new MultiThreadIoEventLoopGroup(4, NioIoHandler.newFactory());
+var server = Server.serverWithEventLoop(config, channelHandlers, sharedLoop);
+var resolver = DomainNameResolver.domainNameResolver(dnsServers, sharedLoop);
+```
diff --git a/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java b/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
new file mode 100644
index 00000000..198e2c41
--- /dev/null
+++ b/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
@@ -0,0 +1,18 @@
+package org.pragmatica.net.dns;
+
+import org.pragmatica.lang.Cause;
+
+/**
+ * DNS resolution errors.
+ */
+public sealed interface ResolverErrors extends Cause {
+    record InvalidIpAddress(String message) implements ResolverErrors {}
+
+    record ServerError(String message) implements ResolverErrors {}
+
+    record RequestTimeout(String message) implements ResolverErrors {}
+
+    record UnknownError(String message) implements ResolverErrors {}
+
+    record UnknownDomain(String message) implements ResolverErrors {}
+}
diff --git a/common/src/main/java/org/pragmatica/utility/IdGenerator.java b/common/src/main/java/org/pragmatica/utility/IdGenerator.java
deleted file mode 100644
index 45463894..00000000
--- a/common/src/main/java/org/pragmatica/utility/IdGenerator.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package org.pragmatica.utility;
-
-import java.util.Locale;
-
-public sealed interface IdGenerator {
-    static String generate(String prefix) {
-        return prefix + "_" + ULID.randomULID()
-                                 .encoded()
-                                 .toLowerCase(Locale.ROOT);
-    }
-
-    @SuppressWarnings("unused")
-    record unused() implements IdGenerator {}
-}
diff --git a/common/src/main/java/org/pragmatica/utility/ULID.java b/common/src/main/java/org/pragmatica/utility/ULID.java
deleted file mode 100644
index d9b3d2cb..00000000
--- a/common/src/main/java/org/pragmatica/utility/ULID.java
+++ /dev/null
@@ -1,220 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2016 Azamshul Azizy
- * Copyright (c) 2020 Sergiy Yevtushenko
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-package org.pragmatica.utility;
-
-import java.security.SecureRandom;
-import java.util.Arrays;
-
-/**
- * ULID string generator and parser class, using Crockford Base32 encoding. Only upper case letters are used for generation. Parsing allows upper and
- * lower case letters, and i and l will be treated as 1 and o will be treated as 0.
- * <br>
- * This version is significantly reworked implementation created by Azamshul Azizy.
- *
- * @author azam
- * @see <a href="http://www.crockford.com/wrmg/base32.html">Base32 Encoding</a>
- * @see <a href="https://github.com/alizain/ulid">ULID</a>
- * @see <a href="https://github.com/azam/ulidj">ULIDJ</a>
- * @since 0.0.1
- */
-@SuppressWarnings("unused")
-public final class ULID implements Comparable<ULID> {
-    public static final int ULID_LENGTH = 26;
-
-    private static final SecureRandom SECURE = new SecureRandom();
-    private static final long OFFSET = System.currentTimeMillis() * 1000_000;
-
-    // Base32 characters mapping
-    private static final char[] C = new char[]{0X30, 0X31, 0X32, 0X33, 0X34, 0X35, 0X36, 0X37,
-    0X38, 0X39, 0X41, 0X42, 0X43, 0X44, 0X45, 0X46,
-    0X47, 0X48, 0X4A, 0X4B, 0X4D, 0X4E, 0X50, 0X51,
-    0X52, 0X53, 0X54, 0X56, 0X57, 0X58, 0X59, 0X5A};
-
-    private static final byte[] V = new byte[]{(byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0X00, (byte) 0X01, (byte) 0X02, (byte) 0X03,
-    (byte) 0X04, (byte) 0X05, (byte) 0X06, (byte) 0X07,
-    (byte) 0X08, (byte) 0X09, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
-    (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
-    (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
-    (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
-    (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
-    (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
-    (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0X0A, (byte) 0X0B, (byte) 0X0C,
-    (byte) 0X0D, (byte) 0X0E, (byte) 0X0F, (byte) 0X10,
-    (byte) 0X11, (byte) 0XFF, (byte) 0X12, (byte) 0X13,
-    (byte) 0XFF, (byte) 0X14, (byte) 0X15, (byte) 0XFF,
-    (byte) 0X16, (byte) 0X17, (byte) 0X18, (byte) 0X19,
-    (byte) 0X1A, (byte) 0XFF, (byte) 0X1B, (byte) 0X1C,
-    (byte) 0X1D, (byte) 0X1E, (byte) 0X1F, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF,
-    (byte) 0XFF, (byte) 0XFF, (byte) 0XFF, (byte) 0XFF};
-
-    private final String representation;
-    private final long timestamp;
-    private final byte[] entropy;
-
-    private ULID(final String representation, final long timestamp, final byte[] entropy) {
-        this.representation = representation;
-        this.timestamp = timestamp;
-        this.entropy = entropy;
-    }
-
-    /**
-     * Generate random ULID string using {@link SecureRandom} instance.
-     *
-     * @return ULID string
-     */
-    public static ULID randomULID() {
-        final var entropy = new byte[10];
-        SECURE.nextBytes(entropy);
-        return generate(System.nanoTime() + OFFSET, entropy);
-    }
-
-    private static ULID generate(final long timestamp, final byte[] entropy) {
-        final var chars = new char[ULID_LENGTH];
-        // time
-        chars[0] = C[(byte)(timestamp>>> 45) & 0x1F];
-        chars[1] = C[(byte)(timestamp>>> 40) & 0x1F];
-        chars[2] = C[(byte)(timestamp>>> 35) & 0x1F];
-        chars[3] = C[(byte)(timestamp>>> 30) & 0x1F];
-        chars[4] = C[(byte)(timestamp>>> 25) & 0x1F];
-        chars[5] = C[(byte)(timestamp>>> 20) & 0x1F];
-        chars[6] = C[(byte)(timestamp>>> 15) & 0x1F];
-        chars[7] = C[(byte)(timestamp>>> 10) & 0x1F];
-        chars[8] = C[(byte)(timestamp>>> 5) & 0x1F];
-        chars[9] = C[((byte)(timestamp)) & 0x1F];
-        // entropy
-        chars[10] = C[(byte)((entropy[0] & 0xFF)>>> 3)];
-        chars[11] = C[(byte)((entropy[0]<< 2 | ((entropy[1] & 0xFF)>>> 6)) & 0x1F)];
-        chars[12] = C[(byte)((entropy[1] & 0xFF)>>> 1 & 0x1F)];
-        chars[13] = C[(byte)((entropy[1]<< 4 | ((entropy[2] & 0xFF)>>> 4)) & 0x1F)];
-        chars[14] = C[(byte)((entropy[2]<< 5 | ((entropy[3] & 0xFF)>>> 7)) & 0x1F)];
-        chars[15] = C[(byte)((entropy[3] & 0xFF)>>> 2 & 0x1F)];
-        chars[16] = C[(byte)((entropy[3]<< 3 | ((entropy[4] & 0xFF)>>> 5)) & 0x1F)];
-        chars[17] = C[(byte)(entropy[4] & 0x1F)];
-        chars[18] = C[(byte)((entropy[5] & 0xFF)>>> 3)];
-        chars[19] = C[(byte)((entropy[5]<< 2 | ((entropy[6] & 0xFF)>>> 6)) & 0x1F)];
-        chars[20] = C[(byte)((entropy[6] & 0xFF)>>> 1 & 0x1F)];
-        chars[21] = C[(byte)((entropy[6]<< 4 | ((entropy[7] & 0xFF)>>> 4)) & 0x1F)];
-        chars[22] = C[(byte)((entropy[7]<< 5 | ((entropy[8] & 0xFF)>>> 7)) & 0x1F)];
-        chars[23] = C[(byte)((entropy[8] & 0xFF)>>> 2 & 0x1F)];
-        chars[24] = C[(byte)((entropy[8]<< 3 | ((entropy[9] & 0xFF)>>> 5)) & 0x1F)];
-        chars[25] = C[(byte)(entropy[9] & 0x1F)];
-        return new ULID(new String(chars), timestamp, entropy);
-    }
-
-    /**
-     * Extract and return the timestamp part from ULID.
-     *
-     * @return timestamp value
-     */
-    public long timestamp() {
-        return timestamp;
-    }
-
-    /**
-     * Extract and return the entropy part from ULID.
-     *
-     * @return Entropy bytes
-     */
-    public byte[] entropy() {
-        return Arrays.copyOf(entropy, entropy.length);
-    }
-
-    /**
-     * Return encoded representation of ULID.
-     *
-     * @return string representation
-     */
-    public String encoded() {
-        return representation;
-    }
-
-    @Override
-    public int compareTo(final ULID o) {
-        return representation.compareTo(o.representation);
-    }
-
-    @Override
-    public boolean equals(final Object o) {
-        return o instanceof ULID other && representation.equals(other.representation);
-    }
-
-    @Override
-    public int hashCode() {
-        return representation.hashCode();
-    }
-
-    @Override
-    public String toString() {
-        return "ULID(" + representation + ")";
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/dht/ConsistentHashRingTest.java b/common/src/test/java/org/pragmatica/dht/ConsistentHashRingTest.java
deleted file mode 100644
index 8d17a5b8..00000000
--- a/common/src/test/java/org/pragmatica/dht/ConsistentHashRingTest.java
+++ /dev/null
@@ -1,286 +0,0 @@
-package org.pragmatica.dht;
-
-import org.junit.jupiter.api.Test;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class ConsistentHashRingTest {
-
-    @Test
-    void create_empty_ring() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        assertThat(ring.isEmpty()).isTrue();
-        assertThat(ring.nodeCount()).isZero();
-        assertThat(ring.nodes()).isEmpty();
-    }
-
-    @Test
-    void addNode_increases_node_count() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        ring.addNode("node-1");
-
-        assertThat(ring.isEmpty()).isFalse();
-        assertThat(ring.nodeCount()).isEqualTo(1);
-        assertThat(ring.nodes()).containsExactly("node-1");
-    }
-
-    @Test
-    void addNode_is_idempotent() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        ring.addNode("node-1");
-        ring.addNode("node-1");
-
-        assertThat(ring.nodeCount()).isEqualTo(1);
-    }
-
-    @Test
-    void removeNode_removes_from_ring() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-
-        ring.removeNode("node-1");
-
-        assertThat(ring.nodeCount()).isEqualTo(1);
-        assertThat(ring.nodes()).containsExactly("node-2");
-    }
-
-    @Test
-    void removeNode_nonexistent_is_safe() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        ring.removeNode("nonexistent");
-
-        assertThat(ring.isEmpty()).isTrue();
-    }
-
-    @Test
-    void partitionFor_returns_valid_partition() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-
-        Partition partition = ring.partitionFor("test-key");
-
-        assertThat(partition.value()).isGreaterThanOrEqualTo(0);
-        assertThat(partition.value()).isLessThan(Partition.MAX_PARTITIONS);
-    }
-
-    @Test
-    void partitionFor_is_deterministic() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-
-        Partition partition1 = ring.partitionFor("test-key");
-        Partition partition2 = ring.partitionFor("test-key");
-
-        assertThat(partition1).isEqualTo(partition2);
-    }
-
-    @Test
-    void partitionFor_works_without_nodes() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        // Should not throw even with empty ring
-        Partition partition = ring.partitionFor("test-key");
-
-        assertThat(partition).isNotNull();
-    }
-
-    @Test
-    void primaryFor_returns_node_when_ring_has_nodes() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-
-        var primary = ring.primaryFor("test-key");
-
-        assertThat(primary).isPresent();
-        assertThat(primary.get()).isEqualTo("node-1");
-    }
-
-    @Test
-    void primaryFor_returns_empty_when_ring_empty() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        var primary = ring.primaryFor("test-key");
-
-        assertThat(primary).isEmpty();
-    }
-
-    @Test
-    void primaryFor_is_deterministic() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-        ring.addNode("node-3");
-
-        var primary1 = ring.primaryFor("test-key");
-        var primary2 = ring.primaryFor("test-key");
-
-        assertThat(primary1).isEqualTo(primary2);
-    }
-
-    @Test
-    void nodesFor_returns_requested_number_of_replicas() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-        ring.addNode("node-3");
-
-        List<String> nodes = ring.nodesFor("test-key", 2);
-
-        assertThat(nodes).hasSize(2);
-    }
-
-    @Test
-    void nodesFor_returns_unique_nodes() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-        ring.addNode("node-3");
-
-        List<String> nodes = ring.nodesFor("test-key", 3);
-
-        assertThat(nodes).hasSize(3);
-        assertThat(nodes).containsExactlyInAnyOrder("node-1", "node-2", "node-3");
-    }
-
-    @Test
-    void nodesFor_respects_node_count_limit() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-
-        // Request more replicas than nodes
-        List<String> nodes = ring.nodesFor("test-key", 5);
-
-        assertThat(nodes).hasSize(2);
-    }
-
-    @Test
-    void nodesFor_returns_empty_for_empty_ring() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-
-        List<String> nodes = ring.nodesFor("test-key", 3);
-
-        assertThat(nodes).isEmpty();
-    }
-
-    @Test
-    void nodesFor_returns_empty_for_zero_replicas() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-
-        List<String> nodes = ring.nodesFor("test-key", 0);
-
-        assertThat(nodes).isEmpty();
-    }
-
-    @Test
-    void keys_are_distributed_across_nodes() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-        ring.addNode("node-3");
-
-        Map<String, Integer> distribution = new HashMap<>();
-        int keyCount = 10000;
-
-        for (int i = 0; i < keyCount; i++) {
-            String key = "key-" + i;
-            var primary = ring.primaryFor(key);
-            assertThat(primary).isPresent();
-            distribution.merge(primary.get(), 1, Integer::sum);
-        }
-
-        // All nodes should have keys
-        assertThat(distribution).containsKeys("node-1", "node-2", "node-3");
-
-        // Distribution should be roughly even (within 50% of ideal)
-        int idealCount = keyCount / 3;
-        for (int count : distribution.values()) {
-            assertThat(count).isGreaterThan(idealCount / 2);
-            assertThat(count).isLessThan(idealCount * 2);
-        }
-    }
-
-    @Test
-    void adding_node_redistributes_minimal_keys() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-
-        // Record initial assignments
-        Map<String, String> initialAssignments = new HashMap<>();
-        int keyCount = 1000;
-        for (int i = 0; i < keyCount; i++) {
-            String key = "key-" + i;
-            initialAssignments.put(key, ring.primaryFor(key).orElseThrow());
-        }
-
-        // Add a third node
-        ring.addNode("node-3");
-
-        // Count how many keys moved
-        int movedCount = 0;
-        for (int i = 0; i < keyCount; i++) {
-            String key = "key-" + i;
-            String newPrimary = ring.primaryFor(key).orElseThrow();
-            if (!newPrimary.equals(initialAssignments.get(key))) {
-                movedCount++;
-            }
-        }
-
-        // With consistent hashing, roughly 1/3 of keys should move to the new node
-        // Allow some variance due to virtual node distribution
-        assertThat(movedCount).isGreaterThan(keyCount / 6);
-        assertThat(movedCount).isLessThan(keyCount / 2);
-    }
-
-    @Test
-    void removing_node_redistributes_only_its_keys() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-        ring.addNode("node-2");
-        ring.addNode("node-3");
-
-        // Record initial assignments
-        Map<String, String> initialAssignments = new HashMap<>();
-        int keyCount = 1000;
-        for (int i = 0; i < keyCount; i++) {
-            String key = "key-" + i;
-            initialAssignments.put(key, ring.primaryFor(key).orElseThrow());
-        }
-
-        // Remove node-2
-        ring.removeNode("node-2");
-
-        // Keys that weren't on node-2 should stay with their original node
-        for (int i = 0; i < keyCount; i++) {
-            String key = "key-" + i;
-            String originalNode = initialAssignments.get(key);
-            if (!originalNode.equals("node-2")) {
-                String newPrimary = ring.primaryFor(key).orElseThrow();
-                assertThat(newPrimary).isEqualTo(originalNode);
-            }
-        }
-    }
-
-    @Test
-    void string_and_bytes_produce_same_partition() {
-        ConsistentHashRing<String> ring = ConsistentHashRing.create();
-        ring.addNode("node-1");
-
-        String key = "test-key";
-        Partition fromString = ring.partitionFor(key);
-        Partition fromBytes = ring.partitionFor(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
-
-        assertThat(fromString).isEqualTo(fromBytes);
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/dht/storage/MemoryStorageEngineTest.java b/common/src/test/java/org/pragmatica/dht/storage/MemoryStorageEngineTest.java
deleted file mode 100644
index e5acb26b..00000000
--- a/common/src/test/java/org/pragmatica/dht/storage/MemoryStorageEngineTest.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package org.pragmatica.dht.storage;
-
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class MemoryStorageEngineTest {
-
-    @Test
-    void get_returns_empty_for_missing_key() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.get("missing".getBytes())
-            .await()
-            .onSuccess(value -> value
-                .onPresent(_ -> Assertions.fail("Expected empty option"))
-                .onEmpty(() -> {})); // Success - empty as expected
-    }
-
-    @Test
-    void put_and_get_value() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value = "value".getBytes();
-
-        storage.put(key, value).await();
-
-        storage.get(key)
-            .await()
-            .onSuccess(retrieved -> retrieved
-                .onEmpty(Assertions::fail)
-                .onPresent(v -> assertThat(v).isEqualTo(value)));
-    }
-
-    @Test
-    void put_overwrites_existing_value() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value1 = "value1".getBytes();
-        byte[] value2 = "value2".getBytes();
-
-        storage.put(key, value1).await();
-        storage.put(key, value2).await();
-
-        storage.get(key)
-            .await()
-            .onSuccess(retrieved -> retrieved
-                .onEmpty(Assertions::fail)
-                .onPresent(v -> assertThat(v).isEqualTo(value2)));
-    }
-
-    @Test
-    void remove_returns_true_for_existing_key() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value = "value".getBytes();
-
-        storage.put(key, value).await();
-
-        storage.remove(key)
-            .await()
-            .onSuccess(found -> assertThat(found).isTrue());
-    }
-
-    @Test
-    void remove_returns_false_for_missing_key() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.remove("missing".getBytes())
-            .await()
-            .onSuccess(found -> assertThat(found).isFalse());
-    }
-
-    @Test
-    void remove_actually_removes_value() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value = "value".getBytes();
-
-        storage.put(key, value).await();
-        storage.remove(key).await();
-
-        storage.get(key)
-            .await()
-            .onSuccess(retrieved -> retrieved
-                .onPresent(_ -> Assertions.fail("Expected empty after remove")));
-    }
-
-    @Test
-    void exists_returns_true_for_existing_key() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value = "value".getBytes();
-
-        storage.put(key, value).await();
-
-        storage.exists(key)
-            .await()
-            .onSuccess(exists -> assertThat(exists).isTrue());
-    }
-
-    @Test
-    void exists_returns_false_for_missing_key() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.exists("missing".getBytes())
-            .await()
-            .onSuccess(exists -> assertThat(exists).isFalse());
-    }
-
-    @Test
-    void size_returns_entry_count() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.put("key1".getBytes(), "value1".getBytes()).await();
-        storage.put("key2".getBytes(), "value2".getBytes()).await();
-        storage.put("key3".getBytes(), "value3".getBytes()).await();
-
-        assertThat(storage.size()).isEqualTo(3);
-    }
-
-    @Test
-    void clear_removes_all_entries() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.put("key1".getBytes(), "value1".getBytes()).await();
-        storage.put("key2".getBytes(), "value2".getBytes()).await();
-
-        storage.clear().await();
-
-        assertThat(storage.size()).isZero();
-    }
-
-    @Test
-    void shutdown_clears_data() {
-        var storage = MemoryStorageEngine.create();
-
-        storage.put("key".getBytes(), "value".getBytes()).await();
-        storage.shutdown().await();
-
-        assertThat(storage.size()).isZero();
-    }
-
-    @Test
-    void values_are_copied_not_referenced() {
-        var storage = MemoryStorageEngine.create();
-        byte[] key = "key".getBytes();
-        byte[] value = "value".getBytes();
-
-        storage.put(key, value).await();
-
-        // Modify the original value
-        value[0] = 'X';
-
-        // Retrieved value should be unchanged
-        storage.get(key)
-            .await()
-            .onSuccess(retrieved -> retrieved
-                .onEmpty(Assertions::fail)
-                .onPresent(v -> assertThat(new String(v)).isEqualTo("value")));
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/message/MessageRouterTest.java b/common/src/test/java/org/pragmatica/message/MessageRouterTest.java
deleted file mode 100644
index 0941727c..00000000
--- a/common/src/test/java/org/pragmatica/message/MessageRouterTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-package org.pragmatica.message;
-
-import org.junit.jupiter.api.Test;
-import org.pragmatica.message.Message.Local;
-import org.pragmatica.message.MessageRouterTest.LocalMessages.LocalMessage1;
-import org.pragmatica.message.MessageRouterTest.LocalMessages.LocalMessage2;
-import org.pragmatica.message.MessageRouterTest.LocalMessages.LocalMessage3;
-import org.pragmatica.message.MessageRouterTest.WiredMessages.WiredMessage1;
-import org.pragmatica.message.MessageRouterTest.WiredMessages.WiredMessage2;
-import org.pragmatica.message.MessageRouterTest.WiredMessages.WiredMessage3;
-import org.pragmatica.message.MessageRouterTest.WiredMessages.WiredMessage4;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.pragmatica.message.MessageRouter.Entry.SealedBuilder.from;
-import static org.pragmatica.message.MessageRouter.Entry.route;
-
-class MessageRouterTest {
-
-    sealed interface LocalMessages extends Local {
-        record LocalMessage1() implements LocalMessages {}
-
-        record LocalMessage2() implements LocalMessages {}
-
-        record LocalMessage3() implements LocalMessages {}
-    }
-
-    sealed interface WiredMessages extends Message.Wired {
-        record WiredMessage1() implements WiredMessages {}
-
-        record WiredMessage2() implements WiredMessages {}
-
-        record WiredMessage3() implements WiredMessages {}
-
-        record WiredMessage4() implements WiredMessages {}
-    }
-
-    record LocalHandler() {
-        @MessageReceiver
-        public void handle1(LocalMessage1 message) {
-        }
-
-        @MessageReceiver
-        public void handle2(LocalMessage2 message) {
-        }
-
-        @MessageReceiver
-        public void handle3(LocalMessage3 message) {
-        }
-    }
-
-    record WiredHandler() {
-        @MessageReceiver
-        public void handle1(WiredMessage1 message) {
-        }
-
-        @MessageReceiver
-        public void handle2(WiredMessages.WiredMessage2 message) {
-        }
-
-        @MessageReceiver
-        public void handle3(WiredMessages.WiredMessage3 message) {
-        }
-
-        @MessageReceiver
-        public void handle4(WiredMessages.WiredMessage4 message) {
-        }
-    }
-
-
-    @SuppressWarnings("unchecked")
-    @Test
-    void assemblingExample() {
-        var localHandler = new LocalHandler();
-        var wiredHandler = new WiredHandler();
-
-        var routes = from(Message.class)
-                .route(from(Local.class)
-                               .route(from(LocalMessages.class)
-                                              .route(route(LocalMessage1.class, localHandler::handle1),
-                                                     route(LocalMessage2.class, localHandler::handle2),
-                                                     route(LocalMessage3.class, localHandler::handle3))),
-                       from(Message.Wired.class)
-                               .route(from(WiredMessages.class)
-                                              .route(route(WiredMessage1.class, wiredHandler::handle1),
-                                                     route(WiredMessage2.class, wiredHandler::handle2),
-                                                     route(WiredMessage3.class, wiredHandler::handle3),
-                                                     route(WiredMessage4.class, wiredHandler::handle4))));
-
-        assertTrue(routes.validate().isEmpty());
-        assertTrue(routes.asRouter().isSuccess());
-    }
-}
\ No newline at end of file
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
new file mode 100644
index 00000000..e6e9a183
--- /dev/null
+++ b/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
@@ -0,0 +1,70 @@
+package org.pragmatica.net.dns;
+
+import org.junit.jupiter.api.Test;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.pragmatica.net.dns.DomainAddress.domainAddress;
+import static org.pragmatica.net.dns.DomainName.domainName;
+
+class DomainAddressTest {
+
+    @Test
+    void domainAddress_creates_instance_with_all_fields() throws UnknownHostException {
+        var name = domainName("example.com");
+        var ip = InetAddress.getByName("93.184.216.34");
+        var ttl = Duration.ofSeconds(300);
+
+        var address = domainAddress(name, ip, ttl);
+
+        assertThat(address.name()).isEqualTo(name);
+        assertThat(address.ip()).isEqualTo(ip);
+        assertThat(address.ttl()).isEqualTo(ttl);
+    }
+
+    @Test
+    void domainAddress_withDomain_creates_new_instance_with_different_name() throws UnknownHostException {
+        var originalName = domainName("example.com");
+        var newName = domainName("alias.example.com");
+        var ip = InetAddress.getByName("93.184.216.34");
+        var ttl = Duration.ofSeconds(300);
+
+        var original = domainAddress(originalName, ip, ttl);
+        var withNewDomain = original.withDomain(newName);
+
+        assertThat(withNewDomain.name()).isEqualTo(newName);
+        assertThat(withNewDomain.ip()).isEqualTo(ip);
+        assertThat(withNewDomain.ttl()).isEqualTo(ttl);
+        assertThat(original.name()).isEqualTo(originalName); // original unchanged
+    }
+
+    @Test
+    void domainAddress_supports_ipv4() throws UnknownHostException {
+        var ip = InetAddress.getByName("192.168.1.1");
+        var address = domainAddress(domainName("local"), ip, Duration.ofSeconds(60));
+
+        assertThat(address.ip().getHostAddress()).isEqualTo("192.168.1.1");
+    }
+
+    @Test
+    void domainAddress_supports_ipv6() throws UnknownHostException {
+        var ip = InetAddress.getByName("::1");
+        var address = domainAddress(domainName("localhost"), ip, Duration.ofSeconds(0));
+
+        assertThat(address.ip().getHostAddress()).isEqualTo("0:0:0:0:0:0:0:1");
+    }
+
+    @Test
+    void domainAddress_supports_zero_ttl() throws UnknownHostException {
+        var address = domainAddress(
+            domainName("no-cache.example.com"),
+            InetAddress.getByName("1.2.3.4"),
+            Duration.ZERO
+        );
+
+        assertThat(address.ttl()).isEqualTo(Duration.ZERO);
+    }
+}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
new file mode 100644
index 00000000..df26c084
--- /dev/null
+++ b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
@@ -0,0 +1,154 @@
+package org.pragmatica.net.dns;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.time.Duration;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.pragmatica.net.dns.DomainNameResolver.domainNameResolver;
+
+/**
+ * Integration tests for DNS resolution using real DNS servers.
+ * <p>
+ * These tests require network access and may be flaky if DNS servers are unreachable.
+ * Enable by setting environment variable: DNS_INTEGRATION_TESTS=true
+ */
+@EnabledIfEnvironmentVariable(named = "DNS_INTEGRATION_TESTS", matches = "true")
+class DomainNameResolverIT {
+
+    private DomainNameResolver resolver;
+
+    @BeforeEach
+    void setUp() throws UnknownHostException {
+        // Use well-known public DNS servers
+        resolver = domainNameResolver(List.of(
+            InetAddress.getByName("8.8.8.8"),      // Google
+            InetAddress.getByName("1.1.1.1")       // Cloudflare
+        ));
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (resolver != null) {
+            resolver.close().await();
+        }
+    }
+
+    @Test
+    void resolves_well_known_domain() {
+        resolver.resolve("google.com")
+                .await()
+                .onFailureRun(Assertions::fail)
+                .onSuccess(address -> {
+                    assertThat(address.name().name()).isEqualTo("google.com");
+                    assertThat(address.ip()).isNotNull();
+                    assertThat(address.ttl()).isNotNull();
+                    System.out.println("Resolved google.com to " + address.ip() + " (TTL: " + address.ttl() + ")");
+                });
+    }
+
+    @Test
+    void resolves_domain_with_short_ttl() {
+        // ibm.com typically has shorter TTL for load balancing
+        resolver.resolve("ibm.com")
+                .await()
+                .onFailureRun(Assertions::fail)
+                .onSuccess(address -> {
+                    assertThat(address.name().name()).isEqualTo("ibm.com");
+                    assertThat(address.ip()).isNotNull();
+                    System.out.println("Resolved ibm.com to " + address.ip() + " (TTL: " + address.ttl() + ")");
+
+                    // IBM typically has TTL under 5 minutes
+                    assertThat(address.ttl()).isLessThan(Duration.ofMinutes(10));
+                });
+    }
+
+    @Test
+    void caches_resolution_and_respects_ttl() throws InterruptedException {
+        // First resolution
+        var firstResult = resolver.resolve("example.com").await();
+
+        firstResult.onFailureRun(Assertions::fail)
+                   .onSuccess(first -> {
+                       System.out.println("First resolution: " + first.ip() + " (TTL: " + first.ttl() + ")");
+
+                       // Cached resolution should return same result
+                       resolver.resolveCached("example.com")
+                               .await()
+                               .onFailureRun(Assertions::fail)
+                               .onSuccess(cached -> {
+                                   assertThat(cached.ip()).isEqualTo(first.ip());
+                               });
+                   });
+    }
+
+    @Test
+    void fails_for_nonexistent_domain() {
+        resolver.resolve("this-domain-definitely-does-not-exist-12345.invalid")
+                .await()
+                .onSuccessRun(() -> Assertions.fail("Should have failed for non-existent domain"))
+                .onFailure(cause -> {
+                    System.out.println("Expected failure for non-existent domain: " + cause.message());
+                    assertThat(cause).isNotNull();
+                });
+    }
+
+    @Test
+    void handles_multiple_concurrent_resolutions() {
+        var domains = List.of("google.com", "microsoft.com", "apple.com", "amazon.com");
+
+        var promises = domains.stream()
+                              .map(resolver::resolve)
+                              .toList();
+
+        for (int i = 0; i < promises.size(); i++) {
+            var domain = domains.get(i);
+            promises.get(i)
+                    .await()
+                    .onSuccess(address -> {
+                        System.out.println("Resolved " + domain + " to " + address.ip());
+                        assertThat(address.name().name()).isEqualTo(domain);
+                    })
+                    .onFailure(cause -> {
+                        System.out.println("Failed to resolve " + domain + ": " + cause.message());
+                    });
+        }
+    }
+
+    @Test
+    void ttl_cache_eviction_works() throws InterruptedException {
+        // Resolve a domain with short TTL
+        var result = resolver.resolve("ibm.com").await();
+
+        result.onSuccess(address -> {
+            var ttlSeconds = address.ttl().toSeconds();
+            System.out.println("ibm.com TTL: " + ttlSeconds + " seconds");
+
+            if (ttlSeconds > 0 && ttlSeconds < 30) {
+                // Wait for TTL to expire plus small buffer
+                try {
+                    System.out.println("Waiting " + (ttlSeconds + 2) + " seconds for TTL expiry...");
+                    Thread.sleep((ttlSeconds + 2) * 1000);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    return;
+                }
+
+                // Cache should be evicted, resolveCached should fail
+                resolver.resolveCached("ibm.com")
+                        .await()
+                        .onSuccess(cached -> System.out.println("Still cached (may have been re-resolved): " + cached.ip()))
+                        .onFailure(cause -> System.out.println("Cache evicted as expected: " + cause.message()));
+            } else {
+                System.out.println("TTL too long for practical test, skipping eviction verification");
+            }
+        });
+    }
+}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
new file mode 100644
index 00000000..43eb2b50
--- /dev/null
+++ b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
@@ -0,0 +1,63 @@
+package org.pragmatica.net.dns;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.time.Duration;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.pragmatica.net.dns.DomainAddress.domainAddress;
+import static org.pragmatica.net.dns.DomainName.domainName;
+import static org.pragmatica.net.dns.DomainNameResolver.domainNameResolver;
+
+class DomainNameResolverTest {
+
+    @Test
+    void resolver_returns_localhost_from_cache() {
+        var resolver = domainNameResolver(List.of());
+
+        resolver.resolve("localhost")
+                .await()
+                .onFailureRun(Assertions::fail)
+                .onSuccess(address -> {
+                    assertThat(address.name().name()).isEqualTo("localhost");
+                    assertThat(address.ip().isLoopbackAddress()).isTrue();
+                });
+    }
+
+    @Test
+    void resolveCached_returns_unknown_for_uncached_domain() {
+        var resolver = domainNameResolver(List.of());
+
+        resolver.resolveCached("not-in-cache.example.com")
+                .await()
+                .onSuccessRun(Assertions::fail)
+                .onFailure(cause -> {
+                    assertThat(cause).isInstanceOf(ResolverErrors.UnknownDomain.class);
+                });
+    }
+
+    @Test
+    void resolver_caches_successful_resolution() throws UnknownHostException {
+        // Use a mock-like approach: create resolver, manually populate cache via resolve
+        var googleDns = InetAddress.getByName("8.8.8.8");
+        var resolver = domainNameResolver(List.of(googleDns));
+
+        // First resolution (will go to real DNS)
+        var firstResult = resolver.resolve("example.com").await();
+
+        if (firstResult.isSuccess()) {
+            // Second call should return cached result
+            resolver.resolveCached("example.com")
+                    .await()
+                    .onFailureRun(Assertions::fail)
+                    .onSuccess(cached -> {
+                        assertThat(cached.name().name()).isEqualTo("example.com");
+                    });
+        }
+        // If first resolution failed (no network), test is inconclusive but passes
+    }
+}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
new file mode 100644
index 00000000..f00d350b
--- /dev/null
+++ b/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
@@ -0,0 +1,41 @@
+package org.pragmatica.net.dns;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.pragmatica.net.dns.DomainName.domainName;
+
+class DomainNameTest {
+
+    @Test
+    void domainName_creates_instance_with_provided_name() {
+        var domain = domainName("example.com");
+
+        assertThat(domain.name()).isEqualTo("example.com");
+    }
+
+    @Test
+    void domainName_preserves_case() {
+        var domain = domainName("Example.COM");
+
+        assertThat(domain.name()).isEqualTo("Example.COM");
+    }
+
+    @Test
+    void domainName_equality_based_on_name() {
+        var domain1 = domainName("example.com");
+        var domain2 = domainName("example.com");
+        var domain3 = domainName("other.com");
+
+        assertThat(domain1).isEqualTo(domain2);
+        assertThat(domain1).isNotEqualTo(domain3);
+    }
+
+    @Test
+    void domainName_hashCode_consistent_with_equality() {
+        var domain1 = domainName("example.com");
+        var domain2 = domainName("example.com");
+
+        assertThat(domain1.hashCode()).isEqualTo(domain2.hashCode());
+    }
+}
diff --git a/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java b/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java
new file mode 100644
index 00000000..52c3c94b
--- /dev/null
+++ b/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java
@@ -0,0 +1,66 @@
+package org.pragmatica.net.dns;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class InetUtilsTest {
+
+    @Test
+    void forBytes_parses_valid_ipv4_address() {
+        var bytes = new byte[]{(byte) 192, (byte) 168, 1, 1};
+
+        InetUtils.forBytes(bytes)
+                 .onFailureRun(Assertions::fail)
+                 .onSuccess(address -> {
+                     assertThat(address.getHostAddress()).isEqualTo("192.168.1.1");
+                 });
+    }
+
+    @Test
+    void forBytes_parses_valid_ipv6_address() {
+        // ::1 in bytes (16 bytes, all zeros except last byte)
+        var bytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
+
+        InetUtils.forBytes(bytes)
+                 .onFailureRun(Assertions::fail)
+                 .onSuccess(address -> {
+                     assertThat(address.getHostAddress()).isEqualTo("0:0:0:0:0:0:0:1");
+                 });
+    }
+
+    @Test
+    void forBytes_fails_for_invalid_length() {
+        // Neither 4 (IPv4) nor 16 (IPv6) bytes
+        var bytes = new byte[]{1, 2, 3};
+
+        InetUtils.forBytes(bytes)
+                 .onSuccessRun(Assertions::fail)
+                 .onFailure(cause -> {
+                     assertThat(cause).isInstanceOf(ResolverErrors.InvalidIpAddress.class);
+                 });
+    }
+
+    @Test
+    void forBytes_handles_all_zeros_ipv4() {
+        var bytes = new byte[]{0, 0, 0, 0};
+
+        InetUtils.forBytes(bytes)
+                 .onFailureRun(Assertions::fail)
+                 .onSuccess(address -> {
+                     assertThat(address.getHostAddress()).isEqualTo("0.0.0.0");
+                 });
+    }
+
+    @Test
+    void forBytes_handles_broadcast_address() {
+        var bytes = new byte[]{(byte) 255, (byte) 255, (byte) 255, (byte) 255};
+
+        InetUtils.forBytes(bytes)
+                 .onFailureRun(Assertions::fail)
+                 .onSuccess(address -> {
+                     assertThat(address.getHostAddress()).isEqualTo("255.255.255.255");
+                 });
+    }
+}
diff --git a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
index 9e27824d..2ccd1c7e 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
@@ -15,7 +15,7 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
 import java.util.Map;
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
index af9e14fd..42694040 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
@@ -18,8 +18,8 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.aether.metrics.deployment.DeploymentEvent.DeploymentStarted;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
index 768e23b0..bc2e77f1 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
@@ -31,8 +31,8 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.message.MessageReceiver;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageReceiver;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 import java.util.Map;
diff --git a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
index 027ae04d..87e8e713 100644
--- a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
@@ -10,7 +10,7 @@
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
 import org.pragmatica.lang.Option;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.Comparator;
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
index 3f89323e..99e9735c 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouteRegistry.java
@@ -18,7 +18,7 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
 import java.util.Map;
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
index 7117e6a1..e150f1ce 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
@@ -8,7 +8,7 @@
 import org.pragmatica.cluster.net.ClusterNetwork;
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.lang.Option;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.nio.charset.StandardCharsets;
 import java.util.Map;
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
index f143d677..a0dabd2e 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
@@ -15,7 +15,7 @@
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 import org.pragmatica.utility.ULID;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
index c022c885..162b777b 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
@@ -5,7 +5,7 @@
 import org.pragmatica.cluster.metrics.MetricsMessage.MetricsPong;
 import org.pragmatica.cluster.net.ClusterNetwork;
 import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.utility.RingBuffer;
 
 import java.lang.management.ManagementFactory;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
index 35f482e3..cc2a14f9 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
@@ -7,7 +7,7 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
 import java.util.concurrent.*;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
index 945451da..94508316 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
@@ -3,7 +3,7 @@
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.slice.SliceState;
 import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.message.Message;
+import org.pragmatica.messaging.Message;
 
 /**
  * Events emitted during slice deployment lifecycle for metrics collection.
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
index 594c122b..42c0c486 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
@@ -10,7 +10,7 @@
 import org.pragmatica.cluster.net.ClusterNetwork;
 import org.pragmatica.cluster.net.NodeId;
 import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
index 02b96065..926e66e6 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
@@ -7,7 +7,7 @@
 import org.pragmatica.cluster.topology.TopologyChangeNotification;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
 import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.message.MessageReceiver;
+import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
 import java.util.concurrent.*;
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index 4734822b..2b74a4e2 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -48,7 +48,7 @@
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
 
@@ -220,8 +220,8 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
         compositeRepository(config.sliceAction()
                                   .repositories()));
         // Create DHT and artifact repository
-        var dhtStorage = MemoryStorageEngine.create();
-        var dhtRing = ConsistentHashRing.<String>create();
+        var dhtStorage = MemoryStorageEngine.memoryStorageEngine();
+        var dhtRing = ConsistentHashRing.<String>consistentHashRing();
         dhtRing.addNode(config.self()
                               .id());
         var dhtNode = DHTNode.dhtNode(config.self()
@@ -229,7 +229,7 @@ public <R> Promise<List<R>> apply(List<KVCommand<AetherKey>> commands) {
                                       dhtStorage,
                                       dhtRing,
                                       config.artifactRepo());
-        var dhtClient = LocalDHTClient.create(dhtNode);
+        var dhtClient = LocalDHTClient.localDHTClient(dhtNode);
         var artifactStore = ArtifactStore.artifactStore(dhtClient);
         var mavenProtocolHandler = MavenProtocolHandler.mavenProtocolHandler(artifactStore);
         // Wire up message routing
diff --git a/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java b/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
index b66a41c2..d7021e3e 100644
--- a/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
@@ -21,7 +21,7 @@
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
diff --git a/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java b/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
index 7a9bd92d..810ab960 100644
--- a/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
@@ -26,7 +26,7 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
index 59aac438..202e1f6b 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
@@ -16,7 +16,7 @@
 import org.pragmatica.cluster.net.NetworkMessage;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 import java.util.Map;
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
index 938c15cc..0b875d77 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
@@ -15,7 +15,7 @@
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
-import org.pragmatica.message.MessageRouter;
+import org.pragmatica.messaging.MessageRouter;
 
 import java.util.List;
 import java.util.Map;
diff --git a/pom.xml b/pom.xml
index 746e3706..eacf72e2 100644
--- a/pom.xml
+++ b/pom.xml
@@ -41,7 +41,7 @@
         <junit.version>5.13.4</junit.version>
         <assertj-core.version>3.26.3</assertj-core.version>
         <mockito.version>5.14.2</mockito.version>
-        <pragmatica.version>0.9.0</pragmatica.version>
+        <pragmatica.version>0.9.2</pragmatica.version>
         <awaitility.version>4.2.1</awaitility.version>
         <tinylog.version>2.7.0</tinylog.version>
         <netty.version>4.2.9.Final</netty.version>
@@ -62,6 +62,31 @@
                 <artifactId>toml</artifactId>
                 <version>${pragmatica.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>messaging</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>utility</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>dht</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>consensus</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>tcp</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
 
             <!-- Internal -->
             <dependency>

From 0d9f55947dd4eda9a94fd7d0b122771d036b723c Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Wed, 31 Dec 2025 14:57:11 +0100
Subject: [PATCH 18/26] refactor: migrate to pragmatica-lite consensus module
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Remove duplicate consensus implementation (30+ files)
- Update imports from org.pragmatica.cluster.* to org.pragmatica.consensus.*
- Use pragmatica-lite TlsConfig and NodeAddress from org.pragmatica.net.tcp
- Switch from ULID to KSUID for correlation IDs
- Fix LeaderManagerTest with deterministic node IDs

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 CHANGELOG.md                                  |  15 +
 .../cluster/consensus/ConsensusErrors.java    |  18 -
 .../cluster/consensus/ProtocolMessage.java    |   9 -
 .../cluster/consensus/rabia/Batch.java        |  42 --
 .../cluster/consensus/rabia/BatchId.java      |  18 -
 .../consensus/rabia/CorrelationId.java        |  17 -
 .../cluster/consensus/rabia/Phase.java        |  17 -
 .../consensus/rabia/ProtocolConfig.java       |  27 -
 .../cluster/consensus/rabia/RabiaEngine.java  | 614 ------------------
 .../consensus/rabia/RabiaEngineIO.java        |  10 -
 .../consensus/rabia/RabiaPersistence.java     |  79 ---
 .../consensus/rabia/RabiaProtocolMessage.java |  42 --
 .../cluster/consensus/rabia/StateValue.java   |  10 -
 .../cluster/leader/LeaderManager.java         | 111 ----
 .../cluster/leader/LeaderNotification.java    |  13 -
 .../metrics/DeploymentMetricsMessage.java     |   4 +-
 .../cluster/metrics/MetricsMessage.java       |   4 +-
 .../cluster/net/ClusterNetwork.java           |  42 --
 .../net/NetworkManagementOperation.java       |  15 -
 .../cluster/net/NetworkMessage.java           |  11 -
 .../org/pragmatica/cluster/net/NodeId.java    |  22 -
 .../org/pragmatica/cluster/net/NodeInfo.java  |  16 -
 .../net/netty/NettyClusterNetwork.java        |  26 +-
 .../pragmatica/cluster/node/ClusterNode.java  |   4 +-
 .../cluster/node/rabia/CustomClasses.java     |   6 +-
 .../cluster/node/rabia/NodeConfig.java        |   2 +-
 .../cluster/node/rabia/RabiaNode.java         |  26 +-
 .../org/pragmatica/cluster/state/Command.java |   3 -
 .../cluster/state/StateMachine.java           |  41 --
 .../state/StateMachineNotification.java       |   8 -
 .../cluster/state/kvstore/KVCommand.java      |   2 +-
 .../cluster/state/kvstore/KVStore.java        |   2 +-
 .../state/kvstore/KVStoreNotification.java    |   2 +-
 .../topology/QuorumStateNotification.java     |   9 -
 .../topology/TopologyChangeNotification.java  |  37 --
 .../topology/TopologyManagementMessage.java   |  18 -
 .../cluster/topology/TopologyManager.java     |  46 --
 .../topology/ip/TcpTopologyManager.java       |  14 +-
 .../cluster/topology/ip/TopologyConfig.java   |   6 +-
 .../consensus/rabia/ByzantineBehaviorsIT.java |   6 +-
 .../consensus/rabia/CrashStopFailuresIT.java  |  12 +-
 .../consensus/rabia/MessageSemanticsIT.java   |  10 +-
 .../consensus/rabia/NominalOperationIT.java   |  10 +-
 .../consensus/rabia/RabiaIntegrationIT.java   |  10 +-
 .../consensus/rabia/ReconfigurationIT.java    |   8 +-
 .../infrastructure/StateChangePrinter.java    |   6 +-
 .../rabia/infrastructure/TestCluster.java     |  22 +-
 .../infrastructure/TestTopologyManager.java   |   8 +-
 .../cluster/leader/LeaderManagerTest.java     |  36 +-
 .../cluster/net/TcpTopologyManagerIT.java     |  13 +-
 .../cluster/net/local/LocalNetwork.java       |  16 +-
 .../org/pragmatica/node/RabiaNodeNettyIT.java |  14 +-
 .../binary/RabiaFurySerializerTest.java       |  12 +-
 .../binary/RabiaKryoSerializerTest.java       |  12 +-
 .../http/server/HttpServerConfig.java         |   2 +-
 .../java/org/pragmatica/net/NodeAddress.java  |  19 -
 .../main/java/org/pragmatica/net/Server.java  |   1 +
 .../java/org/pragmatica/net/ServerConfig.java |   1 +
 .../java/org/pragmatica/net/TlsConfig.java    |  59 --
 .../org/pragmatica/net/TlsContextFactory.java |   1 +
 .../pragmatica/aether/forge/ForgeCluster.java |  10 +-
 .../main/java/org/pragmatica/aether/Main.java |   8 +-
 .../pragmatica/aether/api/AlertManager.java   |   2 +-
 .../aether/api/DashboardMetricsPublisher.java |   2 +-
 .../aether/api/ManagementServer.java          |   4 +-
 .../aether/controller/ClusterController.java  |   2 +-
 .../aether/controller/ControlLoop.java        |  10 +-
 .../cluster/ClusterDeploymentManager.java     |  10 +-
 .../node/NodeDeploymentManager.java           |   4 +-
 .../aether/endpoint/EndpointRegistry.java     |   2 +-
 .../pragmatica/aether/http/RouterConfig.java  |   2 +-
 .../aether/invoke/InvocationHandler.java      |   4 +-
 .../aether/invoke/InvocationMessage.java      |   4 +-
 .../aether/invoke/SliceInvoker.java           |  14 +-
 .../aether/metrics/MetricsCollector.java      |   4 +-
 .../aether/metrics/MetricsScheduler.java      |  12 +-
 .../metrics/deployment/DeploymentEvent.java   |   2 +-
 .../metrics/deployment/DeploymentMetrics.java |   2 +-
 .../DeploymentMetricsCollector.java           |   6 +-
 .../DeploymentMetricsScheduler.java           |  12 +-
 .../pragmatica/aether/node/AetherNode.java    |   8 +-
 .../aether/node/AetherNodeConfig.java         |   8 +-
 .../cluster/BlueprintServiceTest.java         |   2 +-
 .../cluster/ClusterDeploymentManagerTest.java |   6 +-
 .../node/NodeDeploymentManagerTest.java       |   4 +-
 .../aether/endpoint/EndpointRegistryTest.java |   2 +-
 .../aether/http/RouteRegistryTest.java        |   6 +-
 .../DeploymentMetricsCollectorTest.java       |  14 +-
 .../DeploymentMetricsSchedulerTest.java       |  14 +-
 .../deployment/DeploymentMetricsTest.java     |   2 +-
 .../pragmatica/aether/node/AetherNodeIT.java  |  10 +-
 .../aether/node/ClusterFailoverIT.java        |  10 +-
 pom.xml                                       |   2 +-
 .../aether/slice/kvstore/AetherKey.java       |   2 +-
 .../aether/slice/kvstore/AetherValue.java     |   2 +-
 95 files changed, 273 insertions(+), 1621 deletions(-)
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/ConsensusErrors.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/BatchId.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/CorrelationId.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/state/Command.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
 delete mode 100644 cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/NodeAddress.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/TlsConfig.java

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3141a681..67d082e0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,21 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.4] - 2025-12-31
+
+### Changed
+- **Consensus module** - Migrated to use pragmatica-lite consensus module instead of local implementation
+- **Package reorganization** - All consensus-related imports moved from `org.pragmatica.cluster.*` to `org.pragmatica.consensus.*`
+- **TlsConfig/NodeAddress** - Now use pragmatica-lite `org.pragmatica.net.tcp` package
+- **ID generation** - Switched from ULID to KSUID for correlation IDs (pragmatica-lite alignment)
+
+### Removed
+- **Duplicate consensus files** - Removed 30+ files now provided by pragmatica-lite consensus module
+- **Duplicate network types** - Removed local TlsConfig and NodeAddress (use pragmatica-lite versions)
+
+### Fixed
+- **LeaderManagerTest** - Updated to use deterministic node IDs for reliable test ordering
+
 ## [0.6.3] - 2025-12-29
 
 ### Added
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/ConsensusErrors.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/ConsensusErrors.java
deleted file mode 100644
index c64e3428..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/ConsensusErrors.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.pragmatica.cluster.consensus;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.lang.Cause;
-
-public sealed interface ConsensusErrors extends Cause {
-    record NodeInactive(String message) implements ConsensusErrors {}
-
-    record CommandBatchIsEmpty(String message) implements ConsensusErrors {}
-
-    static NodeInactive nodeInactive(NodeId nodeId) {
-        return new NodeInactive("Node [" + nodeId.id() + "] is inactive");
-    }
-
-    static CommandBatchIsEmpty commandBatchIsEmpty() {
-        return new CommandBatchIsEmpty("Submitted command batch is empty");
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
deleted file mode 100644
index f08bdf9f..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/ProtocolMessage.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.pragmatica.cluster.consensus;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.messaging.Message;
-
-/// Marker interface for all protocol messages
-public interface ProtocolMessage extends Message.Wired {
-    NodeId sender();
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
deleted file mode 100644
index 02ea3e74..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Batch.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.cluster.state.Command;
-
-import java.util.List;
-
-/// Represents a proposal value in the Rabia protocol.
-public record Batch<C extends Command>(BatchId id,
-                                       CorrelationId correlationId,
-                                       long timestamp,
-                                       List<C> commands) implements Comparable<Batch<C>> {
-    @Override
-    public int compareTo(Batch<C> o) {
-        var timestampCompare = Long.compare(timestamp, o.timestamp);
-        if (timestampCompare != 0) {
-            return timestampCompare;
-        }
-        var idCompare = Integer.compare(id.hashCode(), o.id.hashCode());
-        if (idCompare != 0) {
-            return idCompare;
-        }
-        return correlationId.id()
-                            .compareTo(o.correlationId.id());
-    }
-
-    public static <C extends Command> Batch<C> batch(List<C> commands) {
-        return new Batch<>(BatchId.randomBatchId(), CorrelationId.randomCorrelationId(), System.nanoTime(), commands);
-    }
-
-    public static <C extends Command> Batch<C> emptyBatch() {
-        return new Batch<>(BatchId.emptyBatchId(), CorrelationId.emptyCorrelationId(), System.nanoTime(), List.of());
-    }
-
-    @Override
-    public int hashCode() {
-        return id.hashCode();
-    }
-
-    public boolean isNotEmpty() {
-        return !commands.isEmpty();
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/BatchId.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/BatchId.java
deleted file mode 100644
index c7e2c494..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/BatchId.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.utility.IdGenerator;
-
-/// Unique identifier for the proposal value (list of commands).
-public record BatchId(String id) {
-    public static BatchId batchId(String id) {
-        return new BatchId(id);
-    }
-
-    public static BatchId randomBatchId() {
-        return batchId(IdGenerator.generate("batch"));
-    }
-
-    public static BatchId emptyBatchId() {
-        return batchId("empty");
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/CorrelationId.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/CorrelationId.java
deleted file mode 100644
index 62cbf2f6..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/CorrelationId.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.utility.IdGenerator;
-
-public record CorrelationId(String id) {
-    public static CorrelationId correlationId(String id) {
-        return new CorrelationId(id);
-    }
-
-    public static CorrelationId randomCorrelationId() {
-        return correlationId(IdGenerator.generate("xref"));
-    }
-
-    public static CorrelationId emptyCorrelationId() {
-        return correlationId("");
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
deleted file mode 100644
index 446830ec..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/Phase.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-/// Represents a protocol phase as defined in the Rabia formal specification.
-public record Phase(long value) implements Comparable<Phase> {
-    public static final Phase ZERO = new Phase(0);
-
-    /// Creates the successor phase to this phase.
-    ///
-    /// @return The next phase
-    public Phase successor() {
-        return new Phase(value + 1);
-    }
-
-    @Override
-    public int compareTo(Phase other) {
-        return Long.compare(this.value, other.value);
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
deleted file mode 100644
index 21bc7b78..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/ProtocolConfig.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.lang.io.TimeSpan;
-
-import static org.pragmatica.lang.io.TimeSpan.timeSpan;
-
-/**
- * Configuration for the Rabia consensus engine.
- */
-public record ProtocolConfig(
- TimeSpan cleanupInterval,
- TimeSpan syncRetryInterval,
- long removeOlderThanPhases) {
-    /// Creates a default (production) configuration.
-    public static ProtocolConfig defaultConfig() {
-        return new ProtocolConfig(timeSpan(60)
-                                  .seconds(), timeSpan(5)
-                                             .seconds(), 100);
-    }
-
-    /// Creates a test configuration.
-    public static ProtocolConfig testConfig() {
-        return new ProtocolConfig(timeSpan(60)
-                                  .seconds(), timeSpan(100)
-                                             .millis(), 100);
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
deleted file mode 100644
index 607c97dd..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngine.java
+++ /dev/null
@@ -1,614 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.cluster.consensus.ConsensusErrors;
-import org.pragmatica.cluster.consensus.rabia.RabiaEngineIO.SubmitCommands;
-import org.pragmatica.cluster.consensus.rabia.RabiaPersistence.SavedState;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage.Asynchronous.NewBatch;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage.Synchronous.*;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.state.Command;
-import org.pragmatica.cluster.state.StateMachine;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyManager;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.utils.SharedScheduler;
-import org.pragmatica.messaging.MessageReceiver;
-import org.pragmatica.messaging.MessageRouter;
-
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.cluster.consensus.rabia.Batch.batch;
-import static org.pragmatica.cluster.consensus.rabia.Batch.emptyBatch;
-import static org.pragmatica.cluster.consensus.rabia.RabiaPersistence.SavedState.savedState;
-import static org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage.Asynchronous.SyncRequest;
-
-/// Implementation of the Rabia consensus protocol.
-public class RabiaEngine<C extends Command> {
-    private static final Logger log = LoggerFactory.getLogger(RabiaEngine.class);
-    private static final double SCALE = 0.5d;
-
-    private final NodeId self;
-    private final TopologyManager topologyManager;
-    private final ClusterNetwork network;
-    private final StateMachine<C> stateMachine;
-    private final ProtocolConfig config;
-    private final ExecutorService executor = Executors.newSingleThreadExecutor();
-    private final Map<CorrelationId, Batch<C>> pendingBatches = new ConcurrentHashMap<>();
-    private final Map<NodeId, SavedState<C>> syncResponses = new ConcurrentHashMap<>();
-    private final RabiaPersistence<C> persistence = RabiaPersistence.inMemory();
-    @SuppressWarnings("rawtypes")
-    private final Map<CorrelationId, Promise> correlationMap = new ConcurrentHashMap<>();
-
-    //--------------------------------- Node State Start
-    private final Map<Phase, PhaseData<C>> phases = new ConcurrentHashMap<>();
-    private final AtomicReference<Phase> currentPhase = new AtomicReference<>(Phase.ZERO);
-    private final AtomicBoolean active = new AtomicBoolean(false);
-    private final AtomicBoolean isInPhase = new AtomicBoolean(false);
-    private final AtomicReference<Promise<Unit>> startPromise = new AtomicReference<>(Promise.promise());
-    private final AtomicReference<Phase> lastCommittedPhase = new AtomicReference<>(Phase.ZERO);
-
-    //--------------------------------- Node State End
-    /// Creates a new Rabia consensus engine.
-    ///
-    /// @param topologyManager The address book for node communication
-    /// @param network         The network implementation
-    /// @param stateMachine    The state machine to apply commands to
-    /// @param config          Configuration for the consensus engine
-    public RabiaEngine(TopologyManager topologyManager,
-                       ClusterNetwork network,
-                       StateMachine<C> stateMachine,
-                       ProtocolConfig config) {
-        this.self = topologyManager.self()
-                                   .id();
-        this.topologyManager = topologyManager;
-        this.network = network;
-        this.stateMachine = stateMachine;
-        this.config = config;
-        // Setup periodic tasks
-        SharedScheduler.scheduleAtFixedRate(this::cleanupOldPhases, config.cleanupInterval());
-        SharedScheduler.schedule(this::synchronize, config.syncRetryInterval());
-    }
-
-    public void configure(MessageRouter.MutableRouter router) {
-        // Subscribe to quorum events
-        router.addRoute(QuorumStateNotification.class, this::quorumState);
-        // Synchronous messages
-        router.addRoute(Propose.class, this::processPropose);
-        router.addRoute(VoteRound1.class, this::processVoteRound1);
-        router.addRoute(VoteRound2.class, this::processVoteRound2);
-        router.addRoute(Decision.class, this::processDecision);
-        router.addRoute(SyncResponse.class, this::processSyncResponse);
-        // Asynchronous messages
-        router.addRoute(SyncRequest.class, this::handleSyncRequest);
-        router.addRoute(NewBatch.class, this::handleNewBatch);
-        // Local command submission requests
-        router.addRoute(SubmitCommands.class, this::handleSubmit);
-    }
-
-    @MessageReceiver
-    public void quorumState(QuorumStateNotification quorumStateNotification) {
-        log.trace("Node {} received quorum state {}", self, quorumStateNotification);
-        switch (quorumStateNotification) {
-            case ESTABLISHED -> clusterConnected();
-            case DISAPPEARED -> clusterDisconnected();
-        }
-    }
-
-    private void clusterConnected() {
-        log.info("Node {}: quorum connected. Starting synchronization attempts", self);
-        SharedScheduler.schedule(this::synchronize,
-                                 config.syncRetryInterval()
-                                       .randomize(SCALE));
-    }
-
-    private void clusterDisconnected() {
-        if (!active.compareAndSet(true, false)) {
-            return;
-        }
-        persistence.save(stateMachine,
-                         lastCommittedPhase.get(),
-                         pendingBatches.values())
-                   .onSuccessRun(() -> log.info("Node {} disconnected. State persisted", self))
-                   .onFailure(cause -> log.error("Node {} failed to persist state: {}", self, cause));
-        phases.clear();
-        currentPhase.set(Phase.ZERO);
-        isInPhase.set(false);
-        stateMachine.reset();
-        startPromise.set(Promise.promise());
-        pendingBatches.clear();
-    }
-
-    public <R> Promise<List<R>> apply(List<C> commands) {
-        var pendingAnswer = Promise.<List<R>>promise();
-        return submitCommands(commands,
-                              batch -> correlationMap.put(batch.correlationId(),
-                                                          pendingAnswer))
-               .async()
-               .flatMap(_ -> pendingAnswer);
-    }
-
-    @MessageReceiver
-    public void handleSubmit(SubmitCommands<C> submitCommands) {
-        submitCommands(submitCommands.commands(),
-                       _ -> {});
-    }
-
-    private Result<Batch<C>> submitCommands(List<C> commands, Consumer<Batch<C>> onBatchPrepared) {
-        if (commands.isEmpty()) {
-            return ConsensusErrors.commandBatchIsEmpty()
-                                  .result();
-        }
-        if (!active.get()) {
-            return ConsensusErrors.nodeInactive(self)
-                                  .result();
-        }
-        var batch = batch(commands);
-        log.trace("Node {}: client submitted {} command(s). Prepared batch: {}", self, commands.size(), batch);
-        pendingBatches.put(batch.correlationId(), batch);
-        onBatchPrepared.accept(batch);
-        network.broadcast(new NewBatch<>(self, batch));
-        if (!isInPhase.get()) {
-            executor.execute(this::startPhase);
-        }
-        return Result.success(batch);
-    }
-
-    public Promise<Unit> start() {
-        return startPromise.get();
-    }
-
-    public Promise<Unit> stop() {
-        return Promise.promise(promise -> {
-            clusterDisconnected();
-            executor.shutdown();
-            promise.succeed(Unit.unit());
-        });
-    }
-
-    @MessageReceiver
-    public void processPropose(Propose<C> propose) {
-        executor.execute(() -> handlePropose(propose));
-    }
-
-    @MessageReceiver
-    public void processVoteRound1(VoteRound1 voteRound1) {
-        executor.execute(() -> handleVoteRound1(voteRound1));
-    }
-
-    @MessageReceiver
-    public void processVoteRound2(VoteRound2 voteRound2) {
-        executor.execute(() -> handleVoteRound2(voteRound2));
-    }
-
-    @MessageReceiver
-    public void processDecision(Decision<C> decision) {
-        executor.execute(() -> handleDecision(decision));
-    }
-
-    @MessageReceiver
-    public void processSyncResponse(SyncResponse<C> syncResponse) {
-        executor.execute(() -> handleSyncResponse(syncResponse));
-    }
-
-    @SuppressWarnings("unchecked")
-    @MessageReceiver
-    public void handleNewBatch(NewBatch< ? > newBatch) {
-        pendingBatches.put(newBatch.batch()
-                                   .correlationId(),
-                           (Batch<C>) newBatch.batch());
-    }
-
-    /// Starts a new phase with pending commands.
-    private void startPhase() {
-        // Use compareAndSet to atomically check and set - prevents race condition
-        if (!isInPhase.compareAndSet(false, true)) {
-            return;
-        }
-        if (pendingBatches.isEmpty()) {
-            isInPhase.set(false);
-            // Reset since we won't actually start
-            return;
-        }
-        var phase = currentPhase.get();
-        var batch = pendingBatches.values()
-                                  .stream()
-                                  .sorted()
-                                  .findFirst()
-                                  .orElse(emptyBatch());
-        log.trace("Node {} starting phase {} with batch {}", self, phase, batch.id());
-        var phaseData = getOrCreatePhaseData(phase);
-        phaseData.proposals.put(self, batch);
-        network.broadcast(new Propose<>(self, phase, batch));
-    }
-
-    /// Synchronizes with other nodes to catch up if needed.
-    private void synchronize() {
-        if (active.get()) {
-            return;
-        }
-        // Clear stale responses
-        syncResponses.clear();
-        var request = new SyncRequest(self);
-        log.trace("Node {}: requesting phase synchronization {}", self, request);
-        network.broadcast(request);
-        SharedScheduler.schedule(this::synchronize,
-                                 config.syncRetryInterval()
-                                       .randomize(SCALE));
-    }
-
-    /// Handles a synchronization response from another node.
-    private void handleSyncResponse(SyncResponse<C> response) {
-        if (active.get()) {
-            log.trace("Node {} ignoring synchronization response {}. Node is active", self, response);
-            return;
-        }
-        syncResponses.put(response.sender(), response.state());
-        if (syncResponses.size() < topologyManager.quorumSize()) {
-            log.trace("Node {} received {} responses {}, not enough to proceed (quorum size = {})",
-                      self,
-                      syncResponses.size(),
-                      syncResponses.keySet(),
-                      topologyManager.quorumSize());
-            return;
-        }
-        log.trace("Node {} received {} responses, collected: {}", self, syncResponses.size(), syncResponses);
-        // Use the latest known state among received responses
-        var candidate = syncResponses.values()
-                                     .stream()
-                                     .sorted(Comparator.comparing(SavedState::lastCommittedPhase))
-                                     .toList()
-                                     .getLast();
-        log.trace("Node {} uses {} as synchronization candidate out of {}", self, candidate, syncResponses.size());
-        restoreState(candidate);
-    }
-
-    private void restoreState(SavedState<C> state) {
-        syncResponses.clear();
-        if (state.snapshot().length == 0) {
-            activate();
-            return;
-        }
-        stateMachine.restoreSnapshot(state.snapshot())
-                    .onSuccess(_ -> {
-                                   currentPhase.set(state.lastCommittedPhase());
-                                   lastCommittedPhase.set(state.lastCommittedPhase());
-                                   state.pendingBatches()
-                                        .forEach(batch -> pendingBatches.put(batch.correlationId(),
-                                                                             batch));
-                                   persistence.save(stateMachine,
-                                                    currentPhase.get(),
-                                                    pendingBatches.values());
-                                   log.info("Node {} restored state from persistence. Current phase {}",
-                                            self,
-                                            currentPhase.get());
-                               })
-                    .onSuccessRun(this::activate)
-                    .onFailure(cause -> log.error("Node {} failed to restore state: {}", self, cause));
-    }
-
-    /// Activate node and adjust phase, if necessary.
-    private void activate() {
-        active.set(true);
-        startPromise.get()
-                    .succeed(Unit.unit());
-        syncResponses.clear();
-        log.info("Node {} activated in phase {}", self, currentPhase.get());
-        executor.execute(this::startPhase);
-    }
-
-    /// Handles a synchronization request from another node.
-    @MessageReceiver
-    public void handleSyncRequest(SyncRequest request) {
-        if (active.get()) {
-            stateMachine.makeSnapshot()
-                        .map(snapshot -> new SyncResponse<>(self,
-                                                            savedState(snapshot,
-                                                                       lastCommittedPhase.get(),
-                                                                       pendingBatches.values())))
-                        .onSuccess(response -> network.send(request.sender(),
-                                                            response))
-                        .onFailure(cause -> log.error("Node {} failed to create snapshot: {}", self, cause));
-        }else {
-            log.trace("Node {} is inactive, trying to share saved (or empty) state for request: {}", self, request);
-            var response = new SyncResponse<>(self,
-                                              persistence.load()
-                                                         .or(SavedState.empty()));
-            network.send(request.sender(), response);
-        }
-    }
-
-    /// Cleans up old phase data to prevent memory leaks.
-    private void cleanupOldPhases() {
-        if (!active.get()) {
-            return;
-        }
-        var current = currentPhase.get();
-        phases.keySet()
-              .removeIf(phase -> isExpiredPhase(phase, current));
-    }
-
-    private boolean isExpiredPhase(Phase phase, Phase current) {
-        return phase.compareTo(current) < 0 && current.value() - phase.value() > config.removeOlderThanPhases();
-    }
-
-    /// Handles a Propose message from another node.
-    private void handlePropose(Propose<C> propose) {
-        if (!active.get()) {
-            log.warn("Node {} ignores proposal {}. Node is dormant", self, propose);
-            return;
-        }
-        log.trace("Node {} received proposal from {} for phase {}", self, propose.sender(), propose.phase());
-        var currentPhaseValue = currentPhase.get();
-        // Ignore proposals for past phases
-        if (propose.phase()
-                   .compareTo(currentPhaseValue) < 0) {
-            log.trace("Node {} ignoring proposal for past phase {}", self, propose.phase());
-            return;
-        }
-        // Potentially add check for proposals too far in the future
-        var phaseData = getOrCreatePhaseData(propose.phase());
-        // Ensure the phase state is correct. If we receive a proposal for the current
-        // phase value but aren't "in" it, enter it now.
-        // This assumes the currentPhaseValue is correctly managed by sync/moveToNextPhase
-        if (propose.phase()
-                   .equals(currentPhaseValue) && !isInPhase.get()) {
-            log.trace("Node {} entering phase {} triggered by proposal from {}", self, propose.phase(), propose.sender());
-            isInPhase.set(true);
-        }
-        phaseData.proposals.putIfAbsent(propose.sender(), propose.value());
-        if (isInPhase.get() && currentPhase.get()
-                                           .equals(propose.phase()) && !phaseData.round1Votes.containsKey(self)) {
-            var vote = phaseData.evaluateInitialVote(self, propose);
-            log.trace("Node {} broadcasting R1 vote {} for phase {} based on received proposal from {}",
-                      self,
-                      vote,
-                      propose.phase(),
-                      propose.sender());
-            network.broadcast(vote);
-            phaseData.round1Votes.put(self, vote.stateValue());
-        }else {
-            log.trace(
-            "Node {} conditions not met to vote R1 on proposal from {} for phase {}. Active: {}, InPhase: {}, CurrentPhase: {}, HasVotedR1: {}",
-            self,
-            propose.sender(),
-            propose.phase(),
-            active.get(),
-            isInPhase.get(),
-            currentPhase.get(),
-            phaseData.round1Votes.containsKey(self));
-        }
-    }
-
-    /// Handles a round 1 vote from another node.
-    private void handleVoteRound1(VoteRound1 vote) {
-        if (!active.get()) {
-            log.warn("Node {} ignores vote1 {}. Node is dormant", self, vote);
-            return;
-        }
-        log.trace("Node {} received round 1 vote from {} for phase {} with value {}",
-                  self,
-                  vote.sender(),
-                  vote.phase(),
-                  vote.stateValue());
-        var phaseData = getOrCreatePhaseData(vote.phase());
-        phaseData.round1Votes.put(vote.sender(), vote.stateValue());
-        // If we're active and in this phase, check if we can proceed to round 2
-        if (isInPhase.get() && currentPhase.get()
-                                           .equals(vote.phase()) && !phaseData.round2Votes.containsKey(self)) {
-            if (!phaseData.hasRound1MajorityVotes(topologyManager.quorumSize())) {
-                return;
-            }
-            var round2Vote = phaseData.evaluateRound2Vote(topologyManager.quorumSize());
-            log.trace("Node {} votes in round 2 {}", self, round2Vote);
-            network.broadcast(new VoteRound2(self, vote.phase(), round2Vote));
-            phaseData.round2Votes.put(self, round2Vote);
-        }
-    }
-
-    /// Handles a round 2 vote from another node.
-    private void handleVoteRound2(VoteRound2 vote) {
-        if (!active.get()) {
-            log.warn("Node {} ignores vote2 {}. Node is dormant", self, vote);
-            return;
-        }
-        log.trace("Node {} received round 2 vote from {} for phase {} with value {}",
-                  self,
-                  vote.sender(),
-                  vote.phase(),
-                  vote.stateValue());
-        var phaseData = getOrCreatePhaseData(vote.phase());
-        phaseData.round2Votes.put(vote.sender(), vote.stateValue());
-        // If we're active and in this phase, check if we can make a decision
-        if (isInPhase.get() && currentPhase.get()
-                                           .equals(vote.phase()) && !phaseData.hasDecided.get()) {
-            if (phaseData.hasRound2MajorityVotes(topologyManager.quorumSize())) {
-                var decision = phaseData.processRound2Completion(self, topologyManager.fPlusOne());
-                network.broadcast(decision);
-                processDecision(decision);
-            }
-        }
-    }
-
-    private void commitDecision(PhaseData<C> phaseData, Decision<C> decision) {
-        // Broadcast the decision
-        if (phaseData.hasDecided.compareAndSet(false, true)) {
-            // Apply commands to state machine ONLY if it was a V1 decision with a non-empty batch
-            if (decision.stateValue() == StateValue.V1 && !decision.value()
-                                                                   .commands()
-                                                                   .isEmpty()) {
-                commitChanges(phaseData, decision);
-            }
-            moveToNextPhase(phaseData.phase);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private void commitChanges(PhaseData<C> phaseData, Decision<C> decision) {
-        log.trace("Node {} applies decision {}", self, decision);
-        var results = stateMachine.process(decision.value()
-                                                   .commands());
-        lastCommittedPhase.set(phaseData.phase);
-        pendingBatches.remove(decision.value()
-                                      .correlationId());
-        correlationMap.computeIfPresent(decision.value()
-                                                .correlationId(),
-                                        (_, promise) -> {
-                                            promise.succeed(results);
-                                            return null;
-                                        });
-    }
-
-    /// Handles a decision message from another node.
-    private void handleDecision(Decision<C> decision) {
-        if (!active.get()) {
-            log.warn("Node {} ignores decision {}. Node is dormant", self, decision);
-            return;
-        }
-        log.trace("Node {} received decision {}", self, decision);
-        commitDecision(getOrCreatePhaseData(decision.phase()), decision);
-    }
-
-    /// Moves to the next phase after a decision.
-    private void moveToNextPhase(Phase currentPhase) {
-        var nextPhase = currentPhase.successor();
-        this.currentPhase.set(nextPhase);
-        isInPhase.set(false);
-        log.trace("Node {} moving to phase {}", self, nextPhase);
-        // If we have more commands to process, start a new phase
-        if (!pendingBatches.isEmpty()) {
-            executor.execute(this::startPhase);
-        }
-    }
-
-    /// Gets or creates phase data for a specific phase.
-    private PhaseData<C> getOrCreatePhaseData(Phase phase) {
-        return phases.computeIfAbsent(phase, PhaseData::new);
-    }
-
-    /// Data structure to hold all state related to a specific phase.
-    private static class PhaseData<C extends Command> {
-        final Phase phase;
-        final Map<NodeId, Batch<C>> proposals = new ConcurrentHashMap<>();
-        final Map<NodeId, StateValue> round1Votes = new ConcurrentHashMap<>();
-        final Map<NodeId, StateValue> round2Votes = new ConcurrentHashMap<>();
-        final AtomicBoolean hasDecided = new AtomicBoolean(false);
-
-        PhaseData(Phase phase) {
-            this.phase = phase;
-        }
-
-        /// Checks if we have a majority of votes in round 1.
-        boolean hasRound1MajorityVotes(int quorumSize) {
-            return round1Votes.size() >= quorumSize;
-        }
-
-        /// Checks if we have a majority of votes in round 2.
-        boolean hasRound2MajorityVotes(int quorumSize) {
-            return round2Votes.size() >= quorumSize;
-        }
-
-        /// Finds the agreed proposal when a V1 decision is made.
-        public Batch<C> findAgreedProposal(NodeId self) {
-            // If all proposals are the same, return that one
-            long distinctProposals = proposals.values()
-                                              .stream()
-                                              .map(Batch::correlationId)
-                                              .distinct()
-                                              .count();
-            if (distinctProposals == 1) {
-                return proposals.values()
-                                .iterator()
-                                .next();
-            }
-            // Otherwise, just use our own proposal or an empty one
-            return proposals.getOrDefault(self, emptyBatch());
-        }
-
-        public VoteRound1 evaluateInitialVote(NodeId self, Propose<C> propose) {
-            var existingProposal = proposals.values()
-                                            .stream()
-                                            .filter(Batch::isNotEmpty)
-                                            .map(Batch::correlationId)
-                                            .filter(correlationId -> correlationId.equals(propose.value()
-                                                                                                 .correlationId()))
-                                            .distinct()
-                                            .toList();
-            if (existingProposal.size() > 1) {
-                return new VoteRound1(self, propose.phase(), StateValue.V0);
-            }
-            proposals.put(self, propose.value());
-            return new VoteRound1(self, propose.phase(), StateValue.V1);
-        }
-
-        public StateValue evaluateRound2Vote(int quorumSize) {
-            // If a majority voted for the same value in round 1, vote that value
-            for (var value : List.of(StateValue.V0, StateValue.V1)) {
-                if (countRound1VotesForValue(value) >= quorumSize) {
-                    return value;
-                }
-            }
-            // Otherwise, vote VQUESTION
-            return StateValue.VQUESTION;
-        }
-
-        public int countRound1VotesForValue(StateValue value) {
-            return (int) round1Votes.values()
-                                   .stream()
-                                   .filter(v -> v == value)
-                                   .count();
-        }
-
-        public int countRound2VotesForValue(StateValue value) {
-            return (int) round2Votes.values()
-                                   .stream()
-                                   .filter(v -> v == value)
-                                   .count();
-        }
-
-        public Decision<C> processRound2Completion(NodeId self, int fPlusOneSize) {
-            // 1. Check for f+1 votes for V1
-            if (countRound2VotesForValue(StateValue.V1) >= fPlusOneSize) {
-                return new Decision<>(self, phase, StateValue.V1, findAgreedProposal(self));
-            }
-            // 2. Check for f+1 votes for V0
-            if (countRound2VotesForValue(StateValue.V0) >= fPlusOneSize) {
-                return new Decision<>(self, phase, StateValue.V0, emptyBatch());
-            }
-            // 3. Fallback: If none of the above conditions are met, use the coin flip.
-            //    This covers the ambiguous cases (mixed votes, including VQUESTION,
-            //    that don't meet thresholds) and the "all VQUESTION" case implicitly.
-            var decision = coinFlip(self);
-            // If coin flip is V1, we still need to try and find *an* agreed proposal.
-            // The definition of findAgreedProposal might need review for this case,
-            // but typically it would look for *any* proposal associated with V1 votes
-            // or a default empty batch if none is found.
-            var batch = decision == StateValue.V1
-                        ? findAgreedProposal(self)
-                        : Batch.<C>emptyBatch();
-            return new Decision<>(self, phase, decision, batch);
-        }
-
-        /// Gets a coin flip value for a phase, creating one if needed.
-        private StateValue coinFlip(NodeId self) {
-            long seed = phase.value() ^ self.id()
-                                            .hashCode();
-            return (Math.abs(seed) % 2 == 0)
-                   ? StateValue.V0
-                   : StateValue.V1;
-        }
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
deleted file mode 100644
index a7aa2e1c..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaEngineIO.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.cluster.state.Command;
-import org.pragmatica.messaging.Message;
-
-import java.util.List;
-
-public interface RabiaEngineIO extends Message.Local {
-    record SubmitCommands<C extends Command>(List<C> commands) implements RabiaEngineIO {}
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
deleted file mode 100644
index c7d36fe6..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaPersistence.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.cluster.state.Command;
-import org.pragmatica.cluster.state.StateMachine;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicReference;
-
-public interface RabiaPersistence<C extends Command> {
-    Result<Unit> save(StateMachine<C> stateMachine, Phase lastCommittedPhase, Collection<Batch<C>> pendingBatches);
-
-    Option<SavedState<C>> load();
-
-    static <C extends Command> RabiaPersistence<C> inMemory() {
-        record inMemory <C extends Command>(AtomicReference<SavedState<C>> state) implements RabiaPersistence<C> {
-            @Override
-            public Result<Unit> save(StateMachine<C> stateMachine,
-                                     Phase lastCommittedPhase,
-                                     Collection<Batch<C>> pendingBatches) {
-                return stateMachine.makeSnapshot()
-                                   .map(snapshot -> SavedState.savedState(snapshot,
-                                                                          lastCommittedPhase,
-                                                                          List.copyOf(pendingBatches)))
-                                   .onSuccess(state::set)
-                                   .onFailure(_ -> state.set(null))
-                                   .map(_ -> Unit.unit());
-            }
-
-            @Override
-            public Option<SavedState<C>> load() {
-                return Option.option(state()
-                                     .get());
-            }
-        }
-        return new inMemory <>(new AtomicReference<>());
-    }
-
-    interface SavedState<C extends Command> {
-        byte[] snapshot();
-
-        Phase lastCommittedPhase();
-
-        List<Batch<C>> pendingBatches();
-
-        static <C extends Command> SavedState<C> savedState(byte[] snapshot,
-                                                            Phase lastCommittedPhase,
-                                                            Collection<Batch<C>> pendingBatches) {
-            record savedState <C extends Command>(byte[] snapshot,
-                                                  Phase lastCommittedPhase,
-                                                  List<Batch<C>> pendingBatches) implements SavedState<C> {
-                @Override
-                public boolean equals(Object o) {
-                    if (! (o instanceof savedState < ? >(byte[] snapshot1, Phase committedPhase, List< ? > batches))) {
-                        return false;
-                    }
-                    return Objects.deepEquals(snapshot(), snapshot1) && Objects.equals(lastCommittedPhase(),
-                                                                                       committedPhase) && Objects.equals(pendingBatches(),
-                                                                                                                         batches);
-                }
-
-                @Override
-                public int hashCode() {
-                    return Objects.hash(Arrays.hashCode(snapshot()), lastCommittedPhase(), pendingBatches());
-                }
-            }
-            return new savedState <>(snapshot, lastCommittedPhase, List.copyOf(pendingBatches));
-        }
-
-        static <C extends Command> SavedState<C> empty() {
-            return savedState(new byte[0], Phase.ZERO, List.of());
-        }
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
deleted file mode 100644
index ccce3469..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/RabiaProtocolMessage.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.consensus.rabia.RabiaPersistence.SavedState;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.state.Command;
-
-/// Message types for the Rabia consensus protocol.
-public sealed interface RabiaProtocolMessage extends ProtocolMessage {
-    sealed interface Synchronous extends RabiaProtocolMessage {
-        /// Initial proposal from a node.
-        record Propose<C extends Command>(NodeId sender, Phase phase, Batch<C> value)
-        implements Synchronous {}
-
-        /// Round 1 vote message.
-        record VoteRound1(NodeId sender, Phase phase, StateValue stateValue)
-        implements Synchronous {}
-
-        /// Round 2 vote message.
-        record VoteRound2(NodeId sender, Phase phase, StateValue stateValue)
-        implements Synchronous {}
-
-        /// Decision broadcast message.
-        record Decision<C extends Command>(
-        NodeId sender,
-        Phase phase,
-        StateValue stateValue,
-        Batch<C> value)
-        implements Synchronous {}
-
-        /// State synchronization response.
-        record SyncResponse<C extends Command>(NodeId sender, SavedState<C> state) implements Synchronous {}
-    }
-
-    sealed interface Asynchronous extends RabiaProtocolMessage {
-        /// State synchronization request.
-        record SyncRequest(NodeId sender) implements Asynchronous {}
-
-        /// Distribute a new batch
-        record NewBatch<C extends Command>(NodeId sender, Batch<C> batch) implements Asynchronous {}
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java b/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
deleted file mode 100644
index 39895d50..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/StateValue.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.pragmatica.cluster.consensus.rabia;
-/// Represents the state values defined in the Rabia protocol (v0, v1, vquestion).
-public enum StateValue {
-    /// Negative vote (no agreement).
-    V0,
-    /// Positive vote (agreement).
-    V1,
-    /// Uncertain/question (needs coin flip).
-    VQUESTION
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
deleted file mode 100644
index d019cae2..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderManager.java
+++ /dev/null
@@ -1,111 +0,0 @@
-package org.pragmatica.cluster.leader;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeDown;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.messaging.MessageReceiver;
-import org.pragmatica.messaging.MessageRouter;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.pragmatica.cluster.leader.LeaderNotification.leaderChange;
-import static org.pragmatica.lang.Option.option;
-
-/// Leader manager is responsible for choosing which node is the leader.
-/// Although consensus is leaderless, it is often necessary to have a single
-/// source of truth for the cluster management. The leader node can be used for this purpose.
-public interface LeaderManager {
-    static LeaderManager leaderManager(NodeId self, MessageRouter router) {
-        record leaderManager(NodeId self,
-                             MessageRouter router,
-                             AtomicBoolean active,
-                             AtomicReference<NodeId> currentLeader) implements LeaderManager {
-            @Override
-            public void nodeAdded(NodeAdded nodeAdded) {
-                tryElect(nodeAdded.topology()
-                                  .getFirst());
-            }
-
-            @Override
-            public void nodeRemoved(NodeRemoved nodeRemoved) {
-                // Should not happen, but better be safe than sorry.
-                if (nodeRemoved.topology()
-                               .isEmpty()) {
-                    return;
-                }
-                tryElect(nodeRemoved.topology()
-                                    .getFirst());
-            }
-
-            @Override
-            public void nodeDown(NodeDown nodeDown) {
-                currentLeader()
-                .set(null);
-                stop();
-            }
-
-            private void tryElect(NodeId candidate) {
-                var oldLeader = currentLeader()
-                                .get();
-                // Potential leader change. Implicitly handles initial election.
-                if (currentLeader()
-                    .compareAndSet(oldLeader, candidate)) {
-                    if (!candidate.equals(oldLeader)) {
-                        notifyLeaderChange();
-                    }
-                }
-            }
-
-            private void notifyLeaderChange() {
-                if (active()
-                    .get()) {
-                    var nodeId = currentLeader()
-                                 .get();
-                    router()
-                    .route(leaderChange(option(nodeId),
-                                        self.equals(nodeId)));
-                }
-            }
-
-            @Override
-            public void watchQuorumState(QuorumStateNotification quorumState) {
-                switch (quorumState) {
-                    case ESTABLISHED -> start();
-                    case DISAPPEARED -> stop();
-                }
-            }
-
-            private void start() {
-                active.set(true);
-                notifyLeaderChange();
-            }
-
-            private void stop() {
-                // Set inactive first to prevent new elections during shutdown
-                active.set(false);
-                currentLeader()
-                .set(null);
-                // Send notification directly since active is now false
-                router()
-                .route(leaderChange(option(null),
-                                    false));
-            }
-        }
-        return new leaderManager(self, router, new AtomicBoolean(false), new AtomicReference<>());
-    }
-
-    @MessageReceiver
-    void nodeAdded(NodeAdded nodeAdded);
-
-    @MessageReceiver
-    void nodeRemoved(NodeRemoved nodeRemoved);
-
-    @MessageReceiver
-    void nodeDown(NodeDown nodeDown);
-
-    @MessageReceiver
-    void watchQuorumState(QuorumStateNotification quorumState);
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java b/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
deleted file mode 100644
index 25ba819a..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/leader/LeaderNotification.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.pragmatica.cluster.leader;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.lang.Option;
-import org.pragmatica.messaging.Message;
-
-public sealed interface LeaderNotification extends Message.Local {
-    record LeaderChange(Option<NodeId> leaderId, boolean localNodeIsLeader) implements LeaderNotification {}
-
-    static LeaderChange leaderChange(Option<NodeId> leaderId, boolean localNodeIsLeader) {
-        return new LeaderChange(leaderId, localNodeIsLeader);
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java b/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
index 7eab3d05..2898801e 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/metrics/DeploymentMetricsMessage.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.metrics;
 
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.List;
 import java.util.Map;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java b/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
index 1b3d0bea..558d4d62 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/metrics/MetricsMessage.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.metrics;
 
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.Map;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
deleted file mode 100644
index ee73fd3a..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/net/ClusterNetwork.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package org.pragmatica.cluster.net;
-
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.messaging.MessageReceiver;
-import org.pragmatica.messaging.MessageRouter;
-
-/// Generalized Network API
-public interface ClusterNetwork {
-    /// Broadcast a message to all nodes in the cluster
-    /// Note that actual implementation may just send messages directly, not necessarily use broadcasting in
-    /// underlying protocol.
-    <M extends ProtocolMessage> void broadcast(M message);
-
-    @MessageReceiver
-    void connect(NetworkManagementOperation.ConnectNode connectNode);
-
-    @MessageReceiver
-    void disconnect(NetworkManagementOperation.DisconnectNode disconnectNode);
-
-    @MessageReceiver
-    void listNodes(NetworkManagementOperation.ListConnectedNodes listConnectedNodes);
-
-    @MessageReceiver
-    void handlePing(NetworkMessage.Ping ping);
-
-    @MessageReceiver
-    void handlePong(NetworkMessage.Pong pong);
-
-    /// Send a message to a specific node
-    <M extends ProtocolMessage> void send(NodeId nodeId, M message);
-
-    /// Start the network.
-    Promise<Unit> start();
-
-    /// Stop the network.
-    Promise<Unit> stop();
-
-    /// Configure message routing
-    void configure(MessageRouter.MutableRouter router);
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
deleted file mode 100644
index 4478a94e..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkManagementOperation.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.pragmatica.cluster.net;
-
-import org.pragmatica.messaging.Message;
-
-import java.util.List;
-
-public sealed interface NetworkManagementOperation extends Message.Local {
-    record ConnectNode(NodeId node) implements NetworkManagementOperation {}
-
-    record DisconnectNode(NodeId nodeId) implements NetworkManagementOperation {}
-
-    record ListConnectedNodes() implements NetworkManagementOperation {}
-
-    record ConnectedNodesList(List<NodeId> connected) implements NetworkManagementOperation {}
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java b/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
deleted file mode 100644
index 957a9530..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NetworkMessage.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.pragmatica.cluster.net;
-
-import org.pragmatica.messaging.Message;
-
-public sealed interface NetworkMessage extends Message.Wired {
-    /// Ping - test connection request
-    record Ping(NodeId sender) implements NetworkMessage {}
-
-    /// Pong - test connection response
-    record Pong(NodeId sender) implements NetworkMessage {}
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java b/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
deleted file mode 100644
index 3f37d583..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NodeId.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package org.pragmatica.cluster.net;
-
-import org.pragmatica.utility.IdGenerator;
-
-/// Cluster node ID
-public record NodeId(String id) implements Comparable<NodeId> {
-    @Override
-    public int compareTo(NodeId o) {
-        return id()
-               .compareTo(o.id());
-    }
-
-    /// Create new node ID from the given string.
-    public static NodeId nodeId(String id) {
-        return new NodeId(id);
-    }
-
-    /// Automatically generate unique node ID.
-    public static NodeId randomNodeId() {
-        return nodeId(IdGenerator.generate("node"));
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java b/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
deleted file mode 100644
index edf55dea..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/net/NodeInfo.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.pragmatica.cluster.net;
-
-import org.pragmatica.net.NodeAddress;
-
-/// Node information: ID and address.
-public interface NodeInfo {
-    NodeId id();
-
-    NodeAddress address();
-
-    /// Create new node information.
-    static NodeInfo nodeInfo(NodeId id, NodeAddress address) {
-        record nodeInfo(NodeId id, NodeAddress address) implements NodeInfo {}
-        return new nodeInfo(id, address);
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 5e6a92f6..81c5f0ac 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -1,16 +1,16 @@
 package org.pragmatica.cluster.net.netty;
 
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NetworkManagementOperation.ListConnectedNodes;
-import org.pragmatica.cluster.net.NetworkMessage.Ping;
-import org.pragmatica.cluster.net.NetworkMessage.Pong;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NetworkManagementOperation.ListConnectedNodes;
+import org.pragmatica.consensus.net.NetworkMessage.Ping;
+import org.pragmatica.consensus.net.NetworkMessage.Pong;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
@@ -41,8 +41,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.pragmatica.cluster.net.NetworkManagementOperation.ConnectNode;
-import static org.pragmatica.cluster.net.NetworkManagementOperation.DisconnectNode;
+import static org.pragmatica.consensus.net.NetworkManagementOperation.ConnectNode;
+import static org.pragmatica.consensus.net.NetworkManagementOperation.DisconnectNode;
 import static org.pragmatica.cluster.net.netty.NettyClusterNetwork.ViewChangeOperation.*;
 
 /**
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/ClusterNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/ClusterNode.java
index fd486d31..a0db6732 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/ClusterNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/ClusterNode.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.node;
 
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.state.Command;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.Command;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
index d8bf4494..3227192b 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/CustomClasses.java
@@ -1,8 +1,8 @@
 package org.pragmatica.cluster.node.rabia;
 
-import org.pragmatica.cluster.consensus.rabia.*;
-import org.pragmatica.cluster.net.NetworkMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.*;
+import org.pragmatica.consensus.net.NetworkMessage;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 
 import java.util.HashMap;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
index 24f6f533..31b97ccc 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/NodeConfig.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.node.rabia;
 
-import org.pragmatica.cluster.consensus.rabia.ProtocolConfig;
+import org.pragmatica.consensus.rabia.ProtocolConfig;
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 
 public interface NodeConfig {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index cde55704..3f8b3e12 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -1,20 +1,20 @@
 package org.pragmatica.cluster.node.rabia;
 
-import org.pragmatica.cluster.consensus.rabia.RabiaEngine;
-import org.pragmatica.cluster.leader.LeaderManager;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.RabiaEngine;
+import org.pragmatica.consensus.leader.LeaderManager;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.net.netty.NettyClusterNetwork;
 import org.pragmatica.cluster.node.ClusterNode;
-import org.pragmatica.cluster.state.Command;
-import org.pragmatica.cluster.state.StateMachine;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeDown;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
-import org.pragmatica.cluster.topology.TopologyManagementMessage;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.Command;
+import org.pragmatica.consensus.StateMachine;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeDown;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.topology.TopologyManagementMessage;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.cluster.topology.ip.TcpTopologyManager;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/Command.java b/cluster/src/main/java/org/pragmatica/cluster/state/Command.java
deleted file mode 100644
index afa1f8e8..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/state/Command.java
+++ /dev/null
@@ -1,3 +0,0 @@
-package org.pragmatica.cluster.state;
-/// Marker interface for state machine commands.
-public interface Command {}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
deleted file mode 100644
index f315ca5a..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachine.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package org.pragmatica.cluster.state;
-
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.messaging.MessageRouter;
-
-import java.util.List;
-
-/// Generalized state machine which can be replicated across cluster.
-public interface StateMachine<T extends Command> {
-    /// Process a command and update the machine's state.
-    /// The command must be immutable and its execution must be deterministic.
-    ///
-    /// @param command The command to process
-    <R> R process(T command);
-
-    @SuppressWarnings("unchecked")
-    default <R> List<R> process(List<T> commands) {
-        return commands.stream()
-                       .map(command -> (R) process(command))
-                       .toList();
-    }
-
-    /// Create a snapshot of the current state machine state.
-    /// The snapshot should be serializable and should capture the complete state.
-    ///
-    /// @return A Result containing the serialized state snapshot
-    Result<byte[] > makeSnapshot();
-
-    /// Restore the machine's state from a snapshot.
-    /// This should completely replace the current state with the state from the snapshot.
-    ///
-    /// @return A Result indicating the success or failure of the restoration
-    Result<Unit> restoreSnapshot(byte[] snapshot);
-
-    /// Reset state machine to its initial state
-    void reset();
-
-    /// Configure message routing
-    void configure(MessageRouter.MutableRouter router);
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java b/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
deleted file mode 100644
index 879f2c88..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/state/StateMachineNotification.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package org.pragmatica.cluster.state;
-
-import org.pragmatica.messaging.Message;
-
-/// State machine notifications root.
-public interface StateMachineNotification<T> extends Message.Local {
-    T cause();
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVCommand.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVCommand.java
index a2c15811..28395c29 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVCommand.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVCommand.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.state.kvstore;
 
-import org.pragmatica.cluster.state.Command;
+import org.pragmatica.consensus.Command;
 
 public sealed interface KVCommand<K extends StructuredKey> extends Command {
     K key();
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index 832da716..a5318745 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.state.kvstore;
 
-import org.pragmatica.cluster.state.StateMachine;
+import org.pragmatica.consensus.StateMachine;
 import org.pragmatica.cluster.state.kvstore.KVCommand.Get;
 import org.pragmatica.cluster.state.kvstore.KVCommand.Put;
 import org.pragmatica.cluster.state.kvstore.KVCommand.Remove;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
index c711358c..1555bdb5 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStoreNotification.java
@@ -1,6 +1,6 @@
 package org.pragmatica.cluster.state.kvstore;
 
-import org.pragmatica.cluster.state.StateMachineNotification;
+import org.pragmatica.consensus.state.StateMachineNotification;
 import org.pragmatica.lang.Option;
 
 public sealed interface KVStoreNotification<K extends StructuredKey> extends StateMachineNotification<KVCommand<K>> {
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java b/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
deleted file mode 100644
index 343f1f16..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/QuorumStateNotification.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.pragmatica.cluster.topology;
-
-import org.pragmatica.messaging.Message;
-
-/// Quorum state notifications
-public enum QuorumStateNotification implements Message.Local {
-    ESTABLISHED,
-    DISAPPEARED
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
deleted file mode 100644
index 0938c345..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyChangeNotification.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package org.pragmatica.cluster.topology;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.messaging.Message;
-
-import java.util.List;
-
-/// Notifications for topology change: node added/removed/down.
-public sealed interface TopologyChangeNotification extends Message.Local {
-    /// The node which added or removed. For the `NodeDown` notification, this is the own ID of the node.
-    NodeId nodeId();
-
-    /// Ordered list of the connected nodes in the cluster. The topology returned by this method
-    /// is the topology AFTER the change, i.e., current state of the topology as the node knows it.
-    List<NodeId> topology();
-
-    /// Node added notification. Sent when a new node joins the cluster.
-    record NodeAdded(NodeId nodeId, List<NodeId> topology) implements TopologyChangeNotification {}
-
-    /// Node removed notification. Sent when a node leaves the cluster.
-    record NodeRemoved(NodeId nodeId, List<NodeId> topology) implements TopologyChangeNotification {}
-
-    /// Node down notification. Send when the current node goes down. Topology is always empty in this notification.
-    record NodeDown(NodeId nodeId, List<NodeId> topology) implements TopologyChangeNotification {}
-
-    static NodeAdded nodeAdded(NodeId nodeId, List<NodeId> changedView) {
-        return new NodeAdded(nodeId, changedView);
-    }
-
-    static NodeRemoved nodeRemoved(NodeId nodeId, List<NodeId> changedView) {
-        return new NodeRemoved(nodeId, changedView);
-    }
-
-    static NodeDown nodeDown(NodeId nodeId) {
-        return new NodeDown(nodeId, List.of());
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
deleted file mode 100644
index c255fdf9..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManagementMessage.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.pragmatica.cluster.topology;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.messaging.Message;
-
-import java.util.List;
-
-/// Notification related to topology change and discovery
-sealed public interface TopologyManagementMessage extends Message.Local {
-    record AddNode(NodeInfo nodeInfo) implements TopologyManagementMessage {}
-
-    record RemoveNode(NodeId nodeId) implements TopologyManagementMessage {}
-
-    record DiscoverNodes(NodeId sender) implements TopologyManagementMessage {}
-
-    record DiscoveredNodes(List<NodeInfo> nodeInfos) implements TopologyManagementMessage {}
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
deleted file mode 100644
index 1f6d25d1..00000000
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/TopologyManager.java
+++ /dev/null
@@ -1,46 +0,0 @@
-package org.pragmatica.cluster.topology;
-
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.net.TlsConfig;
-
-import java.net.SocketAddress;
-
-/// Representation of our knowledge about the cluster structure: known nodes and cluster/quorum size.
-/// Note that this is not a representation of the actual cluster topology.
-public interface TopologyManager {
-    /// This node information
-    NodeInfo self();
-
-    /// Retrieve information about the node
-    Option<NodeInfo> get(NodeId id);
-
-    /// Configured cluster size
-    int clusterSize();
-
-    /// The quorum size (majority) for the cluster.
-    default int quorumSize() {
-        return clusterSize() / 2 + 1;
-    }
-
-    /// Gets the f+1 size for the cluster (where f is the maximum number of failures).
-    default int fPlusOne() {
-        return clusterSize() - quorumSize() + 1;
-    }
-
-    /// Mapping from IP address (host and port) to node ID
-    Option<NodeId> reverseLookup(SocketAddress socketAddress);
-
-    void start();
-
-    void stop();
-
-    TimeSpan pingInterval();
-
-    /// TLS configuration for cluster communication (empty for plain TCP).
-    default Option<TlsConfig> tls() {
-        return Option.empty();
-    }
-}
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
index 88fd1043..33466e28 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TcpTopologyManager.java
@@ -1,17 +1,17 @@
 package org.pragmatica.cluster.topology.ip;
 
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.cluster.topology.TopologyManagementMessage;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
+import org.pragmatica.consensus.topology.TopologyManagementMessage;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
 import org.pragmatica.lang.utils.SharedScheduler;
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.NodeAddress;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.NodeAddress;
+import org.pragmatica.net.tcp.TlsConfig;
 
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
index a85b0fcb..1405f30d 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/topology/ip/TopologyConfig.java
@@ -1,10 +1,10 @@
 package org.pragmatica.cluster.topology.ip;
 
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.TlsConfig;
 
 import java.util.List;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ByzantineBehaviorsIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ByzantineBehaviorsIT.java
index c62df2a7..40cc6988 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ByzantineBehaviorsIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ByzantineBehaviorsIT.java
@@ -1,8 +1,8 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -13,7 +13,7 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.fail;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
 /// Test Suite 4: Byzantine Behaviors
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/CrashStopFailuresIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/CrashStopFailuresIT.java
index a752d93e..53cf361c 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/CrashStopFailuresIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/CrashStopFailuresIT.java
@@ -1,10 +1,10 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification;
 import org.slf4j.Logger;
@@ -20,8 +20,8 @@
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.fail;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
-import static org.pragmatica.cluster.net.NodeId.nodeId;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.NodeId.nodeId;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
 /**
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/MessageSemanticsIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/MessageSemanticsIT.java
index 9db16690..62831f23 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/MessageSemanticsIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/MessageSemanticsIT.java
@@ -1,10 +1,10 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.net.local.LocalNetwork;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.lang.io.TimeSpan;
@@ -19,7 +19,7 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.assertTrue;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 
 /**
  * Test Suite 2: Message Semantics
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/NominalOperationIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/NominalOperationIT.java
index 1483a1eb..6ca5ea6f 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/NominalOperationIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/NominalOperationIT.java
@@ -1,9 +1,9 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification;
@@ -22,8 +22,8 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.*;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
 /**
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/RabiaIntegrationIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/RabiaIntegrationIT.java
index 9799f504..dc92c33a 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/RabiaIntegrationIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/RabiaIntegrationIT.java
@@ -1,10 +1,10 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.awaitility.Awaitility;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.ConsensusErrors;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.ConsensusErrors;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -15,7 +15,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
 class RabiaIntegrationIT {
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ReconfigurationIT.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ReconfigurationIT.java
index 8f1d9806..74fcc59c 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ReconfigurationIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/ReconfigurationIT.java
@@ -1,9 +1,9 @@
-package org.pragmatica.cluster.consensus.rabia;
+package org.pragmatica.consensus.rabia;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -17,7 +17,7 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.*;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
 /**
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
index 1b10a41f..eefe2185 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/StateChangePrinter.java
@@ -1,7 +1,7 @@
-package org.pragmatica.cluster.consensus.rabia.infrastructure;
+package org.pragmatica.consensus.rabia.infrastructure;
 
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.state.StateMachineNotification;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.state.StateMachineNotification;
 import org.pragmatica.messaging.MessageReceiver;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
index fcfd5eb3..00f9b8b9 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
@@ -1,13 +1,13 @@
-package org.pragmatica.cluster.consensus.rabia.infrastructure;
+package org.pragmatica.consensus.rabia.infrastructure;
 
-import org.pragmatica.cluster.consensus.rabia.ProtocolConfig;
-import org.pragmatica.cluster.consensus.rabia.RabiaEngine;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.ProtocolConfig;
+import org.pragmatica.consensus.rabia.RabiaEngine;
+import org.pragmatica.consensus.rabia.RabiaProtocolMessage;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.net.local.LocalNetwork;
 import org.pragmatica.cluster.net.local.LocalNetwork.FaultInjector;
 import org.pragmatica.cluster.node.rabia.CustomClasses;
-import org.pragmatica.cluster.state.Command;
+import org.pragmatica.consensus.Command;
 import org.pragmatica.cluster.state.kvstore.*;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.messaging.MessageRouter;
@@ -21,12 +21,12 @@
 import java.util.function.Consumer;
 
 import static org.junit.jupiter.api.Assertions.fail;
-import static org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage.Asynchronous;
-import static org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage.Synchronous;
-import static org.pragmatica.cluster.net.NodeId.randomNodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
+import static org.pragmatica.consensus.rabia.RabiaProtocolMessage.Asynchronous;
+import static org.pragmatica.consensus.rabia.RabiaProtocolMessage.Synchronous;
+import static org.pragmatica.consensus.NodeId.randomNodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
 import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestTopologyManager.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestTopologyManager.java
index dcac90ea..41b248a8 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestTopologyManager.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestTopologyManager.java
@@ -1,8 +1,8 @@
-package org.pragmatica.cluster.consensus.rabia.infrastructure;
+package org.pragmatica.consensus.rabia.infrastructure;
 
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java b/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
index ddbf3465..ad11553b 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/leader/LeaderManagerTest.java
@@ -1,13 +1,13 @@
-package org.pragmatica.cluster.leader;
+package org.pragmatica.consensus.leader;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.leader.LeaderNotification.LeaderChange;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeDown;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.leader.LeaderNotification.LeaderChange;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeDown;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.lang.Option;
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.messaging.MessageRouter;
@@ -17,9 +17,10 @@
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.pragmatica.cluster.leader.LeaderNotification.leaderChange;
-import static org.pragmatica.cluster.topology.TopologyChangeNotification.nodeAdded;
-import static org.pragmatica.cluster.topology.TopologyChangeNotification.nodeRemoved;
+import static org.pragmatica.consensus.NodeId.nodeId;
+import static org.pragmatica.consensus.leader.LeaderNotification.leaderChange;
+import static org.pragmatica.consensus.topology.TopologyChangeNotification.nodeAdded;
+import static org.pragmatica.consensus.topology.TopologyChangeNotification.nodeRemoved;
 
 class LeaderManagerTest {
     record Watcher<T>(List<T> collected) {
@@ -29,8 +30,9 @@ public void watch(T notification) {
         }
     }
 
-    private final NodeId self = NodeId.randomNodeId();
-    private final List<NodeId> nodes = List.of(NodeId.randomNodeId(), self, NodeId.randomNodeId());
+    // Use deterministic IDs to ensure predictable ordering (a < b < c)
+    private final NodeId self = NodeId.nodeId("node-b");
+    private final List<NodeId> nodes = List.of(NodeId.nodeId("node-a"), self, NodeId.nodeId("node-c"));
 
     private final MessageRouter.MutableRouter router = MessageRouter.mutable();
     private final Watcher<LeaderNotification> watcher = new Watcher<>(new ArrayList<>());
@@ -63,7 +65,8 @@ void nodesAddedThenQuorumReached() {
     void nodesAddedAndRemovedLeaderStaysStable() {
         var expected = simulateClusterStart();
 
-        sendNodeAdded(NodeId.randomNodeId());
+        // Use deterministic ID that sorts after existing nodes (a < b < c < d)
+        sendNodeAdded(nodeId("node-d"));
         sendNodeRemoved(nodes.getLast());
 
         // When quorum disappears, we should see disappearance of the leader
@@ -77,9 +80,10 @@ void nodesAddedAndRemovedLeaderStaysStable() {
     void leaderRemovedAndReplacedWithNewOne() {
         var expected = simulateClusterStart();
 
-        sendNodeRemoved(self);
-        // Here should appear new leader, which is not a local node
-        expected.add(leaderChange(Option.option(nodes.getFirst()), false));
+        // Remove the leader (node-a, which is first in sorted order)
+        sendNodeRemoved(nodes.getFirst());
+        // New leader should be the next in sorted order (self = node-b)
+        expected.add(leaderChange(Option.option(self), true));
 
         // When quorum disappears, we should see disappearance of the leader
         expected.add(leaderChange(Option.none(), false));
diff --git a/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java b/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
index a5dba6be..e3ab9ea7 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/net/TcpTopologyManagerIT.java
@@ -2,20 +2,23 @@
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.topology.TopologyManagementMessage;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NodeInfo;
+import org.pragmatica.consensus.topology.TopologyManagementMessage;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.io.TimeSpan;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.NodeAddress;
+import org.pragmatica.net.tcp.NodeAddress;
 
 import java.net.InetSocketAddress;
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.pragmatica.cluster.net.NodeId.randomNodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
+import static org.pragmatica.consensus.NodeId.randomNodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
 import static org.pragmatica.cluster.topology.ip.TcpTopologyManager.tcpTopologyManager;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 
diff --git a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
index f3cff73c..362110f8 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
@@ -1,13 +1,13 @@
 package org.pragmatica.cluster.net.local;
 
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NetworkMessage;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyManager;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.rabia.RabiaProtocolMessage;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NetworkMessage;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.TopologyManager;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.io.TimeSpan;
diff --git a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
index bea4cdde..cd57048e 100644
--- a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
+++ b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
@@ -4,9 +4,9 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.ProtocolConfig;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.rabia.ProtocolConfig;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.node.rabia.CustomClasses;
 import org.pragmatica.cluster.node.rabia.RabiaNode;
@@ -25,12 +25,12 @@
 
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.fail;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
-import static org.pragmatica.cluster.net.NodeId.nodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.NodeId.nodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
 import static org.pragmatica.cluster.node.rabia.NodeConfig.nodeConfig;
 import static org.pragmatica.cluster.node.rabia.RabiaNode.rabiaNode;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
 import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
 
diff --git a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
index 74f2fdeb..6a4fc9b5 100644
--- a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
+++ b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
@@ -1,18 +1,18 @@
 package org.pragmatica.serialization.binary;
 
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.Batch;
-import org.pragmatica.cluster.consensus.rabia.Phase;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.Batch;
+import org.pragmatica.consensus.rabia.Phase;
+import org.pragmatica.consensus.rabia.RabiaProtocolMessage;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.rabia.CustomClasses;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
 import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
 
diff --git a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
index dc28ad17..6753a9d8 100644
--- a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
+++ b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
@@ -1,11 +1,11 @@
 package org.pragmatica.serialization.binary;
 
 import org.junit.jupiter.api.Test;
-import org.pragmatica.cluster.consensus.rabia.Batch;
-import org.pragmatica.cluster.consensus.rabia.Phase;
-import org.pragmatica.cluster.consensus.rabia.RabiaProtocolMessage;
-import org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.rabia.Batch;
+import org.pragmatica.consensus.rabia.Phase;
+import org.pragmatica.consensus.rabia.RabiaProtocolMessage;
+import org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.rabia.CustomClasses;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.net.serialization.binary.kryo.KryoDeserializer;
@@ -14,7 +14,7 @@
 import java.util.List;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.pragmatica.cluster.consensus.rabia.infrastructure.TestCluster.StringKey.key;
+import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
 
 class RabiaKryoSerializerTest {
 
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java b/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
index e9be9097..66c52ef2 100644
--- a/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
+++ b/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
@@ -3,7 +3,7 @@
 import org.pragmatica.http.websocket.WebSocketEndpoint;
 import org.pragmatica.lang.Option;
 import org.pragmatica.net.SocketOptions;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.TlsConfig;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/common/src/main/java/org/pragmatica/net/NodeAddress.java b/common/src/main/java/org/pragmatica/net/NodeAddress.java
deleted file mode 100644
index a071c5ff..00000000
--- a/common/src/main/java/org/pragmatica/net/NodeAddress.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.pragmatica.net;
-
-import java.net.InetSocketAddress;
-
-/// Network node address. At present TCP/IP address structure is assumed
-public interface NodeAddress {
-    String host();
-
-    int port();
-
-    static NodeAddress nodeAddress(String host, int port) {
-        record nodeAddress(String host, int port) implements NodeAddress {}
-        return new nodeAddress(host, port);
-    }
-
-    static NodeAddress nodeAddress(InetSocketAddress socketAddress) {
-        return nodeAddress(socketAddress.getHostName(), socketAddress.getPort());
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/Server.java b/common/src/main/java/org/pragmatica/net/Server.java
index d9e5699a..93128849 100644
--- a/common/src/main/java/org/pragmatica/net/Server.java
+++ b/common/src/main/java/org/pragmatica/net/Server.java
@@ -3,6 +3,7 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
+import org.pragmatica.net.tcp.NodeAddress;
 
 import java.util.List;
 import java.util.function.Supplier;
diff --git a/common/src/main/java/org/pragmatica/net/ServerConfig.java b/common/src/main/java/org/pragmatica/net/ServerConfig.java
index 395a191e..64db4bc1 100644
--- a/common/src/main/java/org/pragmatica/net/ServerConfig.java
+++ b/common/src/main/java/org/pragmatica/net/ServerConfig.java
@@ -1,6 +1,7 @@
 package org.pragmatica.net;
 
 import org.pragmatica.lang.Option;
+import org.pragmatica.net.tcp.TlsConfig;
 
 /**
  * Configuration for TCP server.
diff --git a/common/src/main/java/org/pragmatica/net/TlsConfig.java b/common/src/main/java/org/pragmatica/net/TlsConfig.java
deleted file mode 100644
index 1223d78c..00000000
--- a/common/src/main/java/org/pragmatica/net/TlsConfig.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Option;
-
-import java.nio.file.Path;
-
-/**
- * TLS configuration for secure server connections.
- * <p>
- * Two modes supported:
- * <ul>
- *   <li>{@link SelfSigned} - generates self-signed certificate at startup (for development)</li>
- *   <li>{@link FromFiles} - loads certificate and private key from PEM files (for production)</li>
- * </ul>
- */
-public sealed interface TlsConfig {
-    /**
-     * Self-signed certificate generated at startup.
-     * Suitable for development and testing only.
-     */
-    record SelfSigned() implements TlsConfig {}
-
-    /**
-     * Certificate and private key loaded from PEM files.
-     * Suitable for production use.
-     */
-    record FromFiles(
-    Path certificatePath,
-    Path privateKeyPath,
-    Option<String> keyPassword) implements TlsConfig {}
-
-    /**
-     * Create self-signed TLS configuration.
-     */
-    static TlsConfig selfSigned() {
-        return new SelfSigned();
-    }
-
-    /**
-     * Create TLS configuration from certificate files.
-     *
-     * @param certificatePath path to PEM certificate file
-     * @param privateKeyPath  path to PEM private key file
-     */
-    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath) {
-        return new FromFiles(certificatePath, privateKeyPath, Option.empty());
-    }
-
-    /**
-     * Create TLS configuration from password-protected certificate files.
-     *
-     * @param certificatePath path to PEM certificate file
-     * @param privateKeyPath  path to PEM private key file
-     * @param keyPassword     password for the private key
-     */
-    static TlsConfig fromFiles(Path certificatePath, Path privateKeyPath, String keyPassword) {
-        return new FromFiles(certificatePath, privateKeyPath, Option.some(keyPassword));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/TlsContextFactory.java b/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
index c0227170..0d77c3c8 100644
--- a/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
+++ b/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
@@ -1,6 +1,7 @@
 package org.pragmatica.net;
 
 import org.pragmatica.lang.Result;
+import org.pragmatica.net.tcp.TlsConfig;
 
 import io.netty.handler.ssl.SslContext;
 import io.netty.handler.ssl.SslContextBuilder;
diff --git a/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java b/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
index a19cbc8a..76be5b68 100644
--- a/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
+++ b/forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java
@@ -2,8 +2,8 @@
 
 import org.pragmatica.aether.node.AetherNode;
 import org.pragmatica.aether.node.AetherNodeConfig;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
@@ -19,9 +19,9 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.pragmatica.cluster.net.NodeId.nodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.consensus.NodeId.nodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 
 /**
  * Manages a cluster of AetherNodes for Forge.
diff --git a/node/src/main/java/org/pragmatica/aether/Main.java b/node/src/main/java/org/pragmatica/aether/Main.java
index 3c0c822d..9fab2f51 100644
--- a/node/src/main/java/org/pragmatica/aether/Main.java
+++ b/node/src/main/java/org/pragmatica/aether/Main.java
@@ -2,8 +2,8 @@
 
 import org.pragmatica.aether.node.AetherNode;
 import org.pragmatica.aether.node.AetherNodeConfig;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 
 import java.util.Arrays;
 import java.util.List;
@@ -11,8 +11,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 
 /**
  * Main entry point for starting an Aether cluster node.
diff --git a/node/src/main/java/org/pragmatica/aether/api/AlertManager.java b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
index 8e7d9e6c..c66a67df 100644
--- a/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
+++ b/node/src/main/java/org/pragmatica/aether/api/AlertManager.java
@@ -1,6 +1,6 @@
 package org.pragmatica.aether.api;
 
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.ArrayList;
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
index 7a2861b5..6a0e4727 100644
--- a/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
+++ b/node/src/main/java/org/pragmatica/aether/api/DashboardMetricsPublisher.java
@@ -1,7 +1,7 @@
 package org.pragmatica.aether.api;
 
 import org.pragmatica.aether.node.AetherNode;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
diff --git a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
index bed4981e..0794512e 100644
--- a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
+++ b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
@@ -5,13 +5,13 @@
 import org.pragmatica.aether.slice.blueprint.BlueprintParser;
 import org.pragmatica.aether.slice.kvstore.AetherKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.TlsConfig;
 import org.pragmatica.net.TlsContextFactory;
 
 import java.io.InputStream;
diff --git a/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java b/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
index 23be9714..2b939914 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/ClusterController.java
@@ -1,7 +1,7 @@
 package org.pragmatica.aether.controller;
 
 import org.pragmatica.aether.artifact.Artifact;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.lang.Promise;
 
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
index 2ccd1c7e..3c338ac2 100644
--- a/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
+++ b/node/src/main/java/org/pragmatica/aether/controller/ControlLoop.java
@@ -8,13 +8,13 @@
 import org.pragmatica.aether.slice.kvstore.AetherKey.BlueprintKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.BlueprintValue;
-import org.pragmatica.cluster.leader.LeaderNotification.LeaderChange;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.leader.LeaderNotification.LeaderChange;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
index 42694040..2cbbe687 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManager.java
@@ -8,15 +8,15 @@
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.BlueprintValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.SliceNodeValue;
-import org.pragmatica.cluster.leader.LeaderNotification.LeaderChange;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.leader.LeaderNotification.LeaderChange;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.aether.metrics.deployment.DeploymentEvent.DeploymentStarted;
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.messaging.MessageRouter;
diff --git a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
index bc2e77f1..c150b8ee 100644
--- a/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
+++ b/node/src/main/java/org/pragmatica/aether/deployment/node/NodeDeploymentManager.java
@@ -19,13 +19,13 @@
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.EndpointValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.SliceNodeValue;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
 import org.pragmatica.lang.Cause;
 import org.pragmatica.lang.Functions.Fn1;
 import org.pragmatica.lang.Promise;
diff --git a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
index 87e8e713..b49362d3 100644
--- a/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
+++ b/node/src/main/java/org/pragmatica/aether/endpoint/EndpointRegistry.java
@@ -6,7 +6,7 @@
 import org.pragmatica.aether.slice.kvstore.AetherKey.EndpointKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.EndpointValue;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
 import org.pragmatica.lang.Option;
diff --git a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
index d20abe30..f8017ef4 100644
--- a/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/http/RouterConfig.java
@@ -1,7 +1,7 @@
 package org.pragmatica.aether.http;
 
 import org.pragmatica.lang.Option;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.TlsConfig;
 
 /**
  * Configuration for the HTTP router.
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
index e150f1ce..7790c00a 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/InvocationHandler.java
@@ -5,8 +5,8 @@
 import org.pragmatica.aether.invoke.InvocationMessage.InvokeResponse;
 import org.pragmatica.aether.metrics.invocation.InvocationMetricsCollector;
 import org.pragmatica.aether.slice.SliceBridge;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.lang.Option;
 import org.pragmatica.messaging.MessageReceiver;
 
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java b/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
index 403ab24f..8408cfe1 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/InvocationMessage.java
@@ -2,8 +2,8 @@
 
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.slice.MethodName;
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.NodeId;
 
 /**
  * Messages for inter-slice remote invocation.
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
index a0dabd2e..25cc430a 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
@@ -7,8 +7,8 @@
 import org.pragmatica.aether.invoke.InvocationMessage.InvokeResponse;
 import org.pragmatica.aether.slice.MethodName;
 import org.pragmatica.aether.slice.SliceRuntime.SliceInvokerFacade;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.lang.Cause;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
@@ -18,7 +18,7 @@
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.net.serialization.Deserializer;
 import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.utility.ULID;
+import org.pragmatica.utility.KSUID;
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.Executors;
@@ -300,8 +300,8 @@ public Promise<Unit> invoke(Artifact slice, MethodName method, Object request) {
         return selectEndpoint(slice, method)
                .flatMap(endpoint -> {
                             var payload = serializeRequest(request);
-                            var correlationId = ULID.randomULID()
-                                                    .toString();
+                            var correlationId = KSUID.ksuid()
+                                                     .toString();
                             var invokeRequest = new InvokeRequest(
         self, correlationId, slice, method, payload, false);
                             network.send(endpoint.nodeId(),
@@ -323,8 +323,8 @@ public <R> Promise<R> invokeAndWait(Artifact slice, MethodName method, Object re
         return selectEndpoint(slice, method)
                .flatMap(endpoint -> {
                             var payload = serializeRequest(request);
-                            var correlationId = ULID.randomULID()
-                                                    .toString();
+                            var correlationId = KSUID.ksuid()
+                                                     .toString();
                             // Create pending promise using callback pattern
         return Promise.<R>promise(pendingPromise -> {
                                       // Store with timestamp for cleanup
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
index 162b777b..75f224c7 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsCollector.java
@@ -3,8 +3,8 @@
 import org.pragmatica.aether.slice.MethodName;
 import org.pragmatica.cluster.metrics.MetricsMessage.MetricsPing;
 import org.pragmatica.cluster.metrics.MetricsMessage.MetricsPong;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.utility.RingBuffer;
 
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
index cc2a14f9..f382defa 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/MetricsScheduler.java
@@ -1,12 +1,12 @@
 package org.pragmatica.aether.metrics;
 
-import org.pragmatica.cluster.leader.LeaderNotification.LeaderChange;
+import org.pragmatica.consensus.leader.LeaderNotification.LeaderChange;
 import org.pragmatica.cluster.metrics.MetricsMessage.MetricsPing;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
index 94508316..6cb808d4 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentEvent.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.slice.SliceState;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.messaging.Message;
 
 /**
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
index 7a06830c..4e28f024 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetrics.java
@@ -2,7 +2,7 @@
 
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsEntry;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
index 42c0c486..66d31a82 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollector.java
@@ -7,9 +7,9 @@
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsEntry;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsPing;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsPong;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
 import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.*;
diff --git a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
index 926e66e6..4861b0df 100644
--- a/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
+++ b/node/src/main/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsScheduler.java
@@ -1,12 +1,12 @@
 package org.pragmatica.aether.metrics.deployment;
 
-import org.pragmatica.cluster.leader.LeaderNotification.LeaderChange;
+import org.pragmatica.consensus.leader.LeaderNotification.LeaderChange;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsPing;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeAdded;
-import org.pragmatica.cluster.topology.TopologyChangeNotification.NodeRemoved;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeAdded;
+import org.pragmatica.consensus.topology.TopologyChangeNotification.NodeRemoved;
 import org.pragmatica.messaging.MessageReceiver;
 
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index 2b74a4e2..d9e8fa3b 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -30,17 +30,17 @@
 import org.pragmatica.aether.slice.kvstore.AetherKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.repository.Repository;
-import org.pragmatica.cluster.leader.LeaderNotification;
+import org.pragmatica.consensus.leader.LeaderNotification;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage;
 import org.pragmatica.cluster.metrics.MetricsMessage;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.rabia.NodeConfig;
 import org.pragmatica.cluster.node.rabia.RabiaNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
 import org.pragmatica.dht.ConsistentHashRing;
 import org.pragmatica.dht.DHTNode;
 import org.pragmatica.dht.LocalDHTClient;
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
index aa9461ca..3220c0ed 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNodeConfig.java
@@ -3,13 +3,13 @@
 import org.pragmatica.aether.http.RouterConfig;
 import org.pragmatica.aether.slice.SliceActionConfig;
 import org.pragmatica.aether.slice.serialization.FurySerializerFactoryProvider;
-import org.pragmatica.cluster.consensus.rabia.ProtocolConfig;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.rabia.ProtocolConfig;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.cluster.topology.ip.TopologyConfig;
 import org.pragmatica.dht.DHTConfig;
 import org.pragmatica.lang.Option;
-import org.pragmatica.net.TlsConfig;
+import org.pragmatica.net.tcp.TlsConfig;
 
 import java.util.List;
 
diff --git a/node/src/test/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceTest.java b/node/src/test/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceTest.java
index 1bdca973..e097789f 100644
--- a/node/src/test/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceTest.java
+++ b/node/src/test/java/org/pragmatica/aether/deployment/cluster/BlueprintServiceTest.java
@@ -14,7 +14,7 @@
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.AppBlueprintValue;
 import org.pragmatica.aether.slice.repository.Repository;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
diff --git a/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java b/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
index d7021e3e..c68f475e 100644
--- a/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/deployment/cluster/ClusterDeploymentManagerTest.java
@@ -10,14 +10,14 @@
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.BlueprintValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.SliceNodeValue;
-import org.pragmatica.cluster.leader.LeaderNotification;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.leader.LeaderNotification;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
diff --git a/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java b/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
index 810ab960..831b8736 100644
--- a/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/deployment/node/NodeDeploymentManagerTest.java
@@ -15,13 +15,13 @@
 import org.pragmatica.aether.metrics.deployment.DeploymentEvent.*;
 import org.pragmatica.aether.slice.SliceBridge;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.*;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.ClusterNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
-import org.pragmatica.cluster.topology.QuorumStateNotification;
+import org.pragmatica.consensus.topology.QuorumStateNotification;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Result;
diff --git a/node/src/test/java/org/pragmatica/aether/endpoint/EndpointRegistryTest.java b/node/src/test/java/org/pragmatica/aether/endpoint/EndpointRegistryTest.java
index 2093ae30..baa41d26 100644
--- a/node/src/test/java/org/pragmatica/aether/endpoint/EndpointRegistryTest.java
+++ b/node/src/test/java/org/pragmatica/aether/endpoint/EndpointRegistryTest.java
@@ -8,7 +8,7 @@
 import org.pragmatica.aether.slice.kvstore.AetherKey.EndpointKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.EndpointValue;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValuePut;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification.ValueRemove;
diff --git a/node/src/test/java/org/pragmatica/aether/http/RouteRegistryTest.java b/node/src/test/java/org/pragmatica/aether/http/RouteRegistryTest.java
index a9a49eb7..118f6854 100644
--- a/node/src/test/java/org/pragmatica/aether/http/RouteRegistryTest.java
+++ b/node/src/test/java/org/pragmatica/aether/http/RouteRegistryTest.java
@@ -228,7 +228,7 @@ void ignores_non_route_key_put() {
             1
         );
         var endpointValue = new AetherValue.EndpointValue(
-            org.pragmatica.cluster.net.NodeId.randomNodeId()
+            org.pragmatica.consensus.NodeId.randomNodeId()
         );
 
         registry.onValuePut(new ValuePut<>(
@@ -261,8 +261,8 @@ static class TestClusterNode implements ClusterNode<KVCommand<AetherKey>> {
         List<List<KVCommand<AetherKey>>> appliedCommands = new java.util.ArrayList<>();
 
         @Override
-        public org.pragmatica.cluster.net.NodeId self() {
-            return org.pragmatica.cluster.net.NodeId.randomNodeId();
+        public org.pragmatica.consensus.NodeId self() {
+            return org.pragmatica.consensus.NodeId.randomNodeId();
         }
 
         @Override
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
index 202e1f6b..62294d59 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
@@ -8,12 +8,12 @@
 import org.pragmatica.aether.slice.SliceState;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsEntry;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsPing;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
 
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NetworkMessage;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NetworkMessage;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.messaging.MessageRouter;
@@ -371,12 +371,12 @@ static class TestClusterNetwork implements ClusterNetwork {
         final List<SentMessage> sentMessages = new CopyOnWriteArrayList<>();
 
         @Override
-        public <M extends org.pragmatica.cluster.consensus.ProtocolMessage> void send(NodeId target, M message) {
+        public <M extends org.pragmatica.consensus.ProtocolMessage> void send(NodeId target, M message) {
             sentMessages.add(new SentMessage(target, message));
         }
 
         @Override
-        public <M extends org.pragmatica.cluster.consensus.ProtocolMessage> void broadcast(M message) {
+        public <M extends org.pragmatica.consensus.ProtocolMessage> void broadcast(M message) {
             // Not used in these tests
         }
 
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
index 0b875d77..e16b21ab 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
@@ -4,14 +4,14 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.pragmatica.aether.artifact.Artifact;
-import org.pragmatica.cluster.consensus.ProtocolMessage;
-import org.pragmatica.cluster.leader.LeaderNotification;
+import org.pragmatica.consensus.ProtocolMessage;
+import org.pragmatica.consensus.leader.LeaderNotification;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsPing;
-import org.pragmatica.cluster.net.ClusterNetwork;
-import org.pragmatica.cluster.net.NetworkManagementOperation;
-import org.pragmatica.cluster.net.NetworkMessage;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.topology.TopologyChangeNotification;
+import org.pragmatica.consensus.net.ClusterNetwork;
+import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NetworkMessage;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.topology.TopologyChangeNotification;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsTest.java
index 7a8bb20f..a248d72e 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsTest.java
@@ -4,7 +4,7 @@
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.metrics.deployment.DeploymentMetrics.DeploymentStatus;
 import org.pragmatica.cluster.metrics.DeploymentMetricsMessage.DeploymentMetricsEntry;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
diff --git a/node/src/test/java/org/pragmatica/aether/node/AetherNodeIT.java b/node/src/test/java/org/pragmatica/aether/node/AetherNodeIT.java
index b8f7e162..09e3452b 100644
--- a/node/src/test/java/org/pragmatica/aether/node/AetherNodeIT.java
+++ b/node/src/test/java/org/pragmatica/aether/node/AetherNodeIT.java
@@ -8,8 +8,8 @@
 import org.pragmatica.aether.slice.kvstore.AetherKey.SliceNodeKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue;
 import org.pragmatica.aether.slice.kvstore.AetherValue.SliceNodeValue;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.lang.Option;
 import org.pragmatica.lang.Promise;
@@ -25,9 +25,9 @@
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.pragmatica.aether.artifact.Artifact.artifact;
-import static org.pragmatica.cluster.net.NodeId.nodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.consensus.NodeId.nodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 
 /**
  * Integration test for AetherNode cluster.
diff --git a/node/src/test/java/org/pragmatica/aether/node/ClusterFailoverIT.java b/node/src/test/java/org/pragmatica/aether/node/ClusterFailoverIT.java
index 9da4f0e2..b2bd1e5f 100644
--- a/node/src/test/java/org/pragmatica/aether/node/ClusterFailoverIT.java
+++ b/node/src/test/java/org/pragmatica/aether/node/ClusterFailoverIT.java
@@ -6,8 +6,8 @@
 import org.pragmatica.aether.slice.SliceState;
 import org.pragmatica.aether.slice.kvstore.AetherKey.SliceNodeKey;
 import org.pragmatica.aether.slice.kvstore.AetherValue.SliceNodeValue;
-import org.pragmatica.cluster.net.NodeId;
-import org.pragmatica.cluster.net.NodeInfo;
+import org.pragmatica.consensus.NodeId;
+import org.pragmatica.consensus.net.NodeInfo;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.io.TimeSpan;
@@ -31,9 +31,9 @@
 import static org.awaitility.Awaitility.await;
 import static org.junit.jupiter.api.Assertions.fail;
 import static org.pragmatica.aether.artifact.Artifact.artifact;
-import static org.pragmatica.cluster.net.NodeId.nodeId;
-import static org.pragmatica.cluster.net.NodeInfo.nodeInfo;
-import static org.pragmatica.net.NodeAddress.nodeAddress;
+import static org.pragmatica.consensus.NodeId.nodeId;
+import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
+import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
 
 /**
  * Integration tests for 5-node cluster failover scenarios.
diff --git a/pom.xml b/pom.xml
index eacf72e2..6df4d197 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>org.pragmatica-lite.aether</groupId>
     <artifactId>aether</artifactId>
-    <version>0.6.3</version>
+    <version>0.6.4</version>
     <packaging>pom</packaging>
     <name>Pragmatica Aether Distributed Runtime</name>
     <description>AI-driven distributed runtime environment for Java applications</description>
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
index 2a0be47b..930b9cce 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherKey.java
@@ -3,7 +3,7 @@
 import org.pragmatica.aether.artifact.Artifact;
 import org.pragmatica.aether.slice.MethodName;
 import org.pragmatica.aether.slice.blueprint.BlueprintId;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.state.kvstore.StructuredKey;
 import org.pragmatica.cluster.state.kvstore.StructuredPattern;
 import org.pragmatica.lang.Cause;
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
index a0895bcb..9d9248d9 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/kvstore/AetherValue.java
@@ -4,7 +4,7 @@
 import org.pragmatica.aether.slice.SliceState;
 import org.pragmatica.aether.slice.blueprint.ExpandedBlueprint;
 import org.pragmatica.aether.slice.routing.Binding;
-import org.pragmatica.cluster.net.NodeId;
+import org.pragmatica.consensus.NodeId;
 
 import java.util.List;
 

From 308ac31c8443ceeae3875802e1bf728e85784212 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Wed, 31 Dec 2025 23:00:33 +0100
Subject: [PATCH 19/26] refactor: remove common module, use pragmatica-lite
 modules directly

---
 cluster/pom.xml                               |  10 +-
 .../pragmatica/cluster/net/netty/Decoder.java |   2 +-
 .../pragmatica/cluster/net/netty/Encoder.java |   2 +-
 .../net/netty/NettyClusterNetwork.java        |   8 +-
 .../cluster/node/rabia/RabiaNode.java         |   4 +-
 .../cluster/state/kvstore/KVStore.java        |   4 +-
 .../rabia/infrastructure/TestCluster.java     |   8 +-
 .../org/pragmatica/node/RabiaNodeNettyIT.java |   4 +-
 .../binary/RabiaFurySerializerTest.java       |   4 +-
 .../binary/RabiaKryoSerializerTest.java       |   4 +-
 common/pom.xml                                | 100 -----
 .../java/org/pragmatica/dht/DHTClient.java    |  96 -----
 .../org/pragmatica/dht/LocalDHTClient.java    |  58 ---
 .../org/pragmatica/dht/LocalPartitionMap.java | 106 -----
 .../java/org/pragmatica/dht/PartitionMap.java |  52 ---
 .../pragmatica/http/CommonContentType.java    |  30 --
 .../org/pragmatica/http/ContentCategory.java  |  10 -
 .../java/org/pragmatica/http/ContentType.java |  16 -
 .../java/org/pragmatica/http/Headers.java     |  74 ----
 .../java/org/pragmatica/http/HttpMethod.java  |  32 --
 .../java/org/pragmatica/http/HttpStatus.java  |  56 ---
 .../java/org/pragmatica/http/QueryParams.java |  70 ----
 .../pragmatica/http/server/HttpServer.java    |  33 --
 .../http/server/HttpServerConfig.java         |  82 ----
 .../http/server/HttpServerError.java          |  28 --
 .../http/server/NettyHttpServer.java          | 394 ------------------
 .../http/server/RequestContext.java           |  58 ---
 .../http/server/ResponseWriter.java           | 113 -----
 .../http/websocket/WebSocketEndpoint.java     |  19 -
 .../http/websocket/WebSocketHandler.java      |  16 -
 .../http/websocket/WebSocketMessage.java      |  25 --
 .../http/websocket/WebSocketSession.java      |  30 --
 .../org/pragmatica/net/AsyncCloseable.java    |  11 -
 .../main/java/org/pragmatica/net/Server.java  | 176 --------
 .../java/org/pragmatica/net/ServerConfig.java |  34 --
 .../org/pragmatica/net/SocketOptions.java     |  16 -
 .../org/pragmatica/net/TlsContextFactory.java |  58 ---
 .../java/org/pragmatica/net/TlsError.java     |  30 --
 .../org/pragmatica/net/dns/DnsClient.java     | 199 ---------
 .../org/pragmatica/net/dns/DomainAddress.java |  24 --
 .../org/pragmatica/net/dns/DomainName.java    |   9 -
 .../net/dns/DomainNameResolver.java           | 150 -------
 .../org/pragmatica/net/dns/InetUtils.java     |  27 --
 .../java/org/pragmatica/net/dns/README.md     | 178 --------
 .../pragmatica/net/dns/ResolverErrors.java    |  18 -
 .../net/serialization/Deserializer.java       |  18 -
 .../net/serialization/Serializer.java         |  19 -
 .../binary/ClassRegistrator.java              |   7 -
 .../binary/fury/FuryDeserializer.java         |  32 --
 .../binary/fury/FuryFactory.java              |  25 --
 .../binary/fury/FurySerializer.java           |  30 --
 .../binary/kryo/KryoDeserializer.java         |  37 --
 .../binary/kryo/KryoPoolFactory.java          |  28 --
 .../binary/kryo/KryoSerializer.java           |  35 --
 .../pragmatica/utility/HierarchyScanner.java  |  79 ----
 .../org/pragmatica/utility/RingBuffer.java    | 154 -------
 .../java/org/pragmatica/utility/Sleep.java    |  17 -
 .../pragmatica/net/dns/DomainAddressTest.java |  70 ----
 .../net/dns/DomainNameResolverIT.java         | 154 -------
 .../net/dns/DomainNameResolverTest.java       |  63 ---
 .../pragmatica/net/dns/DomainNameTest.java    |  41 --
 .../org/pragmatica/net/dns/InetUtilsTest.java |  66 ---
 common/src/test/resources/tinylog.properties  |   3 -
 examples/order-demo/pom.xml                   |   5 -
 forge/pom.xml                                 |   4 -
 infra-services/artifact-repo/pom.xml          |   4 +-
 mcp/pom.xml                                   |  19 -
 node/pom.xml                                  |  13 +-
 .../aether/api/ManagementServer.java          |   2 +-
 .../aether/http/BindingResolver.java          |   2 +-
 .../pragmatica/aether/http/HttpRouter.java    |   6 +-
 .../aether/http/ResponseWriter.java           |   2 +-
 .../aether/invoke/SliceInvoker.java           |   4 +-
 .../pragmatica/aether/node/AetherNode.java    |   8 +-
 pom.xml                                       |  34 +-
 slice/pom.xml                                 |   9 +-
 .../aether/slice/SliceBridgeImpl.java         |   4 +-
 .../FurySerializerFactoryProvider.java        |  12 +-
 .../KryoSerializerFactoryProvider.java        |  12 +-
 .../serialization/SerializerFactory.java      |   4 +-
 80 files changed, 96 insertions(+), 3404 deletions(-)
 delete mode 100644 common/pom.xml
 delete mode 100644 common/src/main/java/org/pragmatica/dht/DHTClient.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
 delete mode 100644 common/src/main/java/org/pragmatica/dht/PartitionMap.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/CommonContentType.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/ContentCategory.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/ContentType.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/Headers.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/HttpMethod.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/HttpStatus.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/QueryParams.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServer.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/HttpServerError.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/RequestContext.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
 delete mode 100644 common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/AsyncCloseable.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/Server.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/ServerConfig.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/SocketOptions.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/TlsContextFactory.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/TlsError.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/DnsClient.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainName.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/InetUtils.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/README.md
 delete mode 100644 common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/Serializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
 delete mode 100644 common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
 delete mode 100644 common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
 delete mode 100644 common/src/main/java/org/pragmatica/utility/RingBuffer.java
 delete mode 100644 common/src/main/java/org/pragmatica/utility/Sleep.java
 delete mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
 delete mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
 delete mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
 delete mode 100644 common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
 delete mode 100644 common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java
 delete mode 100644 common/src/test/resources/tinylog.properties
 delete mode 100644 mcp/pom.xml

diff --git a/cluster/pom.xml b/cluster/pom.xml
index d58af777..bfa11a72 100644
--- a/cluster/pom.xml
+++ b/cluster/pom.xml
@@ -34,14 +34,12 @@
             <artifactId>tcp</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.pragmatica-lite.aether</groupId>
-            <artifactId>common</artifactId>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>serialization-fury</artifactId>
         </dependency>
-
-        <!-- Serialization -->
         <dependency>
-            <groupId>com.esotericsoftware</groupId>
-            <artifactId>kryo</artifactId>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>serialization-kryo</artifactId>
         </dependency>
         <dependency>
             <groupId>org.apache.fury</groupId>
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
index 3a3738a0..b79399a6 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Decoder.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.net.netty;
 
 import org.pragmatica.messaging.Message;
-import org.pragmatica.net.serialization.Deserializer;
+import org.pragmatica.serialization.Deserializer;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
index de263c17..cd0273bc 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/Encoder.java
@@ -1,7 +1,7 @@
 package org.pragmatica.cluster.net.netty;
 
 import org.pragmatica.messaging.Message;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Serializer;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 81c5f0ac..152778f2 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -18,10 +18,10 @@
 import org.pragmatica.lang.utils.SharedScheduler;
 import org.pragmatica.messaging.Message;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.Server;
-import org.pragmatica.net.ServerConfig;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.net.tcp.Server;
+import org.pragmatica.net.tcp.ServerConfig;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.ArrayList;
 import java.util.Collections;
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index 3f8b3e12..2ae23734 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -19,8 +19,8 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.List;
 
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index a5318745..42f46a97 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -16,8 +16,8 @@
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.messaging.MessageRouter;
 import org.pragmatica.messaging.MessageRouter.MutableRouter;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.HashMap;
 import java.util.Map;
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
index 00f9b8b9..8fc74c25 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
@@ -11,8 +11,8 @@
 import org.pragmatica.cluster.state.kvstore.*;
 import org.pragmatica.lang.Promise;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -27,8 +27,8 @@
 import static org.pragmatica.consensus.net.NodeInfo.nodeInfo;
 import static org.pragmatica.lang.io.TimeSpan.timeSpan;
 import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
-import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
-import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
+import static org.pragmatica.serialization.fury.FuryDeserializer.furyDeserializer;
+import static org.pragmatica.serialization.fury.FurySerializer.furySerializer;
 
 /// Holds a small Rabia cluster wired over a single LocalNetwork.
 public class TestCluster {
diff --git a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
index cd57048e..45bdb3ad 100644
--- a/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
+++ b/cluster/src/test/java/org/pragmatica/node/RabiaNodeNettyIT.java
@@ -31,8 +31,8 @@
 import static org.pragmatica.cluster.node.rabia.NodeConfig.nodeConfig;
 import static org.pragmatica.cluster.node.rabia.RabiaNode.rabiaNode;
 import static org.pragmatica.net.tcp.NodeAddress.nodeAddress;
-import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
-import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
+import static org.pragmatica.serialization.fury.FuryDeserializer.furyDeserializer;
+import static org.pragmatica.serialization.fury.FurySerializer.furySerializer;
 
 class RabiaNodeNettyIT {
     private static final Logger log = LoggerFactory.getLogger(RabiaNodeNettyIT.class);
diff --git a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
index 6a4fc9b5..2a1005af 100644
--- a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
+++ b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaFurySerializerTest.java
@@ -13,8 +13,8 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.pragmatica.consensus.rabia.infrastructure.TestCluster.StringKey.key;
-import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
-import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
+import static org.pragmatica.serialization.fury.FuryDeserializer.furyDeserializer;
+import static org.pragmatica.serialization.fury.FurySerializer.furySerializer;
 
 class RabiaFurySerializerTest {
     @Test
diff --git a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
index 6753a9d8..ac2bcaae 100644
--- a/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
+++ b/cluster/src/test/java/org/pragmatica/serialization/binary/RabiaKryoSerializerTest.java
@@ -8,8 +8,8 @@
 import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.node.rabia.CustomClasses;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
-import org.pragmatica.net.serialization.binary.kryo.KryoDeserializer;
-import org.pragmatica.net.serialization.binary.kryo.KryoSerializer;
+import org.pragmatica.serialization.kryo.KryoDeserializer;
+import org.pragmatica.serialization.kryo.KryoSerializer;
 
 import java.util.List;
 
diff --git a/common/pom.xml b/common/pom.xml
deleted file mode 100644
index 9b91db67..00000000
--- a/common/pom.xml
+++ /dev/null
@@ -1,100 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.pragmatica-lite.aether</groupId>
-        <artifactId>aether</artifactId>
-        <version>0.6.3</version>
-    </parent>
-
-    <artifactId>common</artifactId>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>core</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>messaging</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>utility</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>dht</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.pragmatica-lite</groupId>
-            <artifactId>tcp</artifactId>
-        </dependency>
-
-        <!-- Networking -->
-        <dependency>
-            <groupId>io.netty</groupId>
-            <artifactId>netty-all</artifactId>
-        </dependency>
-
-        <!-- Serialization -->
-        <dependency>
-            <groupId>com.esotericsoftware</groupId>
-            <artifactId>kryo</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.apache.fury</groupId>
-            <artifactId>fury-core</artifactId>
-        </dependency>
-
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>slf4j-api</artifactId>
-        </dependency>
-
-        <!-- Testing -->
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-api</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter-engine</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.assertj</groupId>
-            <artifactId>assertj-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-core</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.mockito</groupId>
-            <artifactId>mockito-junit-jupiter</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.awaitility</groupId>
-            <artifactId>awaitility</artifactId>
-            <scope>test</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.tinylog</groupId>
-            <artifactId>slf4j-tinylog</artifactId>
-            <scope>test</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.tinylog</groupId>
-            <artifactId>tinylog-impl</artifactId>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>
\ No newline at end of file
diff --git a/common/src/main/java/org/pragmatica/dht/DHTClient.java b/common/src/main/java/org/pragmatica/dht/DHTClient.java
deleted file mode 100644
index 5bbce1d0..00000000
--- a/common/src/main/java/org/pragmatica/dht/DHTClient.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-/**
- * Client interface for distributed DHT operations.
- * Coordinates reads and writes across multiple nodes with quorum semantics.
- *
- * <p>Implementations handle:
- * <ul>
- *   <li>Routing to appropriate nodes based on consistent hashing</li>
- *   <li>Quorum reads and writes</li>
- *   <li>Retry logic for failed nodes</li>
- *   <li>Timeout handling</li>
- * </ul>
- */
-public interface DHTClient {
-    /**
-     * Get a value by key.
-     * Reads from readQuorum nodes and returns the value if found.
-     *
-     * @param key the key to look up
-     * @return the value if found, or empty if not present on any replica
-     */
-    Promise<Option<byte[] >> get(byte[] key);
-
-    /**
-     * Get a value by string key.
-     */
-    default Promise<Option<byte[] >> get(String key) {
-        return get(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
-    }
-
-    /**
-     * Put a value.
-     * Writes to writeQuorum nodes before returning success.
-     *
-     * @param key   the key
-     * @param value the value to store
-     * @return promise that completes when quorum writes succeed
-     */
-    Promise<Unit> put(byte[] key, byte[] value);
-
-    /**
-     * Put a value with string key.
-     */
-    default Promise<Unit> put(String key, byte[] value) {
-        return put(key.getBytes(java.nio.charset.StandardCharsets.UTF_8), value);
-    }
-
-    /**
-     * Remove a value.
-     * Removes from writeQuorum nodes before returning success.
-     *
-     * @param key the key to remove
-     * @return true if the key was found and removed from at least one node
-     */
-    Promise<Boolean> remove(byte[] key);
-
-    /**
-     * Remove a value with string key.
-     */
-    default Promise<Boolean> remove(String key) {
-        return remove(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
-    }
-
-    /**
-     * Check if a key exists.
-     * Checks readQuorum nodes.
-     *
-     * @param key the key to check
-     * @return true if the key exists on any responding node
-     */
-    Promise<Boolean> exists(byte[] key);
-
-    /**
-     * Check if a key exists with string key.
-     */
-    default Promise<Boolean> exists(String key) {
-        return exists(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
-    }
-
-    /**
-     * Get the partition for a key.
-     */
-    Partition partitionFor(byte[] key);
-
-    /**
-     * Get the partition for a string key.
-     */
-    default Partition partitionFor(String key) {
-        return partitionFor(key.getBytes(java.nio.charset.StandardCharsets.UTF_8));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java b/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
deleted file mode 100644
index 80aa4f2e..00000000
--- a/common/src/main/java/org/pragmatica/dht/LocalDHTClient.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-/**
- * Local DHT client implementation that operates on a single node.
- * Suitable for testing and single-node deployments.
- *
- * @param <N> Node identifier type
- */
-public final class LocalDHTClient<N extends Comparable<N>> implements DHTClient {
-    private final DHTNode<N> node;
-
-    private LocalDHTClient(DHTNode<N> node) {
-        this.node = node;
-    }
-
-    /**
-     * Create a local DHT client backed by the given node.
-     */
-    public static <N extends Comparable<N>> LocalDHTClient<N> localDHTClient(DHTNode<N> node) {
-        return new LocalDHTClient<>(node);
-    }
-
-    @Override
-    public Promise<Option<byte[] >> get(byte[] key) {
-        return node.getLocal(key);
-    }
-
-    @Override
-    public Promise<Unit> put(byte[] key, byte[] value) {
-        return node.putLocal(key, value);
-    }
-
-    @Override
-    public Promise<Boolean> remove(byte[] key) {
-        return node.removeLocal(key);
-    }
-
-    @Override
-    public Promise<Boolean> exists(byte[] key) {
-        return node.existsLocal(key);
-    }
-
-    @Override
-    public Partition partitionFor(byte[] key) {
-        return node.partitionFor(key);
-    }
-
-    /**
-     * Get the underlying node.
-     */
-    public DHTNode<N> node() {
-        return node;
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java b/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
deleted file mode 100644
index b439b641..00000000
--- a/common/src/main/java/org/pragmatica/dht/LocalPartitionMap.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Promise;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-/**
- * Local partition map implementation using consistent hashing.
- * Suitable for single-process clusters or testing.
- *
- * @param <N> Node identifier type (must be Comparable for consistent ordering)
- */
-public final class LocalPartitionMap<N extends Comparable<N>> implements PartitionMap<N> {
-    private final ConsistentHashRing<N> ring;
-
-    private LocalPartitionMap(ConsistentHashRing<N> ring) {
-        this.ring = ring;
-    }
-
-    public static <N extends Comparable<N>> LocalPartitionMap<N> localPartitionMap() {
-        return new LocalPartitionMap<>(ConsistentHashRing.<N>consistentHashRing());
-    }
-
-    public static <N extends Comparable<N>> LocalPartitionMap<N> localPartitionMap(int virtualNodesPerPhysical) {
-        return new LocalPartitionMap<>(ConsistentHashRing.<N>consistentHashRing(virtualNodesPerPhysical));
-    }
-
-    @Override
-    public Promise<List<N>> nodesFor(Partition partition, int replicaCount) {
-        // Use partition value as key for consistent node selection
-        String partitionKey = "partition:" + partition.value();
-        List<N> nodes = ring.nodesFor(partitionKey, replicaCount);
-        return Promise.success(nodes);
-    }
-
-    @Override
-    public Promise<Set<Partition>> partitionsFor(N node) {
-        Set<Partition> partitions = new HashSet<>();
-        for (int i = 0; i < Partition.MAX_PARTITIONS; i++ ) {
-            Partition partition = Partition.partitionUnsafe(i);
-            String partitionKey = "partition:" + i;
-            ring.primaryFor(partitionKey)
-                .ifPresent(primary -> {
-                    if (primary.equals(node)) {
-                    partitions.add(partition);
-                }
-                });
-        }
-        return Promise.success(partitions);
-    }
-
-    @Override
-    public Promise<Set<Partition>> allPartitionsFor(N node, int replicaCount) {
-        Set<Partition> partitions = new HashSet<>();
-        for (int i = 0; i < Partition.MAX_PARTITIONS; i++ ) {
-            Partition partition = Partition.partitionUnsafe(i);
-            String partitionKey = "partition:" + i;
-            List<N> nodes = ring.nodesFor(partitionKey, replicaCount);
-            if (nodes.contains(node)) {
-                partitions.add(partition);
-            }
-        }
-        return Promise.success(partitions);
-    }
-
-    @Override
-    public Promise<Void> updateTopology(Set<N> nodes) {
-        synchronized (ring) {
-            // Remove nodes no longer in topology
-            Set<N> currentNodes = new HashSet<>(ring.nodes());
-            for (N node : currentNodes) {
-                if (!nodes.contains(node)) {
-                    ring.removeNode(node);
-                }
-            }
-            // Add new nodes
-            for (N node : nodes) {
-                ring.addNode(node);
-            }
-        }
-        return Promise.success(null);
-    }
-
-    /**
-     * Add a node to the partition map.
-     */
-    public void addNode(N node) {
-        ring.addNode(node);
-    }
-
-    /**
-     * Remove a node from the partition map.
-     */
-    public void removeNode(N node) {
-        ring.removeNode(node);
-    }
-
-    /**
-     * Get all nodes in the map.
-     */
-    public Set<N> nodes() {
-        return ring.nodes();
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/dht/PartitionMap.java b/common/src/main/java/org/pragmatica/dht/PartitionMap.java
deleted file mode 100644
index 06f2fd51..00000000
--- a/common/src/main/java/org/pragmatica/dht/PartitionMap.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package org.pragmatica.dht;
-
-import org.pragmatica.lang.Promise;
-
-import java.util.List;
-import java.util.Set;
-
-/**
- * Maps partitions to nodes.
- * Implementations may use local computation or distributed consensus.
- *
- * @param <N> Node identifier type
- */
-public interface PartitionMap<N> {
-    /**
-     * Get the nodes responsible for a partition.
-     * Returns the primary node first, followed by replicas.
-     *
-     * @param partition the partition to look up
-     * @param replicaCount number of nodes to return (primary + replicas)
-     * @return ordered list of nodes, with primary first
-     */
-    Promise<List<N>> nodesFor(Partition partition, int replicaCount);
-
-    /**
-     * Get the primary node for a partition.
-     */
-    default Promise<N> primaryFor(Partition partition) {
-        return nodesFor(partition, 1)
-               .map(nodes -> nodes.isEmpty()
-                             ? null
-                             : nodes.getFirst());
-    }
-
-    /**
-     * Get all partitions owned by a node (as primary).
-     */
-    Promise<Set<Partition>> partitionsFor(N node);
-
-    /**
-     * Get all partitions where a node is a replica (including primary).
-     */
-    Promise<Set<Partition>> allPartitionsFor(N node, int replicaCount);
-
-    /**
-     * Update partition assignments when topology changes.
-     * Called when nodes join or leave the cluster.
-     *
-     * @param nodes current set of nodes in the cluster
-     */
-    Promise<Void> updateTopology(Set<N> nodes);
-}
diff --git a/common/src/main/java/org/pragmatica/http/CommonContentType.java b/common/src/main/java/org/pragmatica/http/CommonContentType.java
deleted file mode 100644
index 7665d95b..00000000
--- a/common/src/main/java/org/pragmatica/http/CommonContentType.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.pragmatica.http;
-/**
- * Common HTTP content types.
- */
-public enum CommonContentType implements ContentType {
-    TEXT_PLAIN("text/plain; charset=UTF-8", ContentCategory.TEXT),
-    TEXT_HTML("text/html; charset=UTF-8", ContentCategory.TEXT),
-    TEXT_CSS("text/css; charset=UTF-8", ContentCategory.TEXT),
-    TEXT_JAVASCRIPT("text/javascript; charset=UTF-8", ContentCategory.TEXT),
-    APPLICATION_JSON("application/json; charset=UTF-8", ContentCategory.JSON),
-    APPLICATION_XML("application/xml; charset=UTF-8", ContentCategory.XML),
-    APPLICATION_OCTET_STREAM("application/octet-stream", ContentCategory.BINARY),
-    IMAGE_PNG("image/png", ContentCategory.BINARY),
-    IMAGE_JPEG("image/jpeg", ContentCategory.BINARY),
-    IMAGE_SVG("image/svg+xml", ContentCategory.XML);
-    private final String headerText;
-    private final ContentCategory category;
-    CommonContentType(String headerText, ContentCategory category) {
-        this.headerText = headerText;
-        this.category = category;
-    }
-    @Override
-    public String headerText() {
-        return headerText;
-    }
-    @Override
-    public ContentCategory category() {
-        return category;
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/ContentCategory.java b/common/src/main/java/org/pragmatica/http/ContentCategory.java
deleted file mode 100644
index 792cd978..00000000
--- a/common/src/main/java/org/pragmatica/http/ContentCategory.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.pragmatica.http;
-/**
- * Content type categories for HTTP responses.
- */
-public enum ContentCategory {
-    TEXT,
-    JSON,
-    BINARY,
-    XML
-}
diff --git a/common/src/main/java/org/pragmatica/http/ContentType.java b/common/src/main/java/org/pragmatica/http/ContentType.java
deleted file mode 100644
index 54dfd324..00000000
--- a/common/src/main/java/org/pragmatica/http/ContentType.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.pragmatica.http;
-/**
- * HTTP Content-Type abstraction.
- * <p>
- * Use {@link CommonContentType} for standard content types, or create custom ones via factory method.
- */
-public interface ContentType {
-    String headerText();
-
-    ContentCategory category();
-
-    static ContentType contentType(String headerText, ContentCategory category) {
-        record contentType(String headerText, ContentCategory category) implements ContentType {}
-        return new contentType(headerText, category);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/Headers.java b/common/src/main/java/org/pragmatica/http/Headers.java
deleted file mode 100644
index 7d4562a7..00000000
--- a/common/src/main/java/org/pragmatica/http/Headers.java
+++ /dev/null
@@ -1,74 +0,0 @@
-package org.pragmatica.http;
-
-import org.pragmatica.lang.Option;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * HTTP headers with case-insensitive lookup (per HTTP specification).
- */
-public interface Headers {
-    /**
-     * Get the first value for a header (case-insensitive lookup).
-     */
-    Option<String> get(String name);
-
-    /**
-     * Get all values for a header (case-insensitive lookup).
-     */
-    List<String> getAll(String name);
-
-    /**
-     * Get all headers as a map (keys are lowercase).
-     */
-    Map<String, List<String>> asMap();
-
-    /**
-     * Create headers from a raw map (will be normalized to lowercase keys).
-     */
-    static Headers headers(Map<String, List<String>> raw) {
-        record headers(Map<String, List<String>> normalized) implements Headers {
-            @Override
-            public Option<String> get(String name) {
-                var values = normalized.get(name.toLowerCase());
-                return values == null || values.isEmpty()
-                       ? Option.empty()
-                       : Option.some(values.getFirst());
-            }
-
-            @Override
-            public List<String> getAll(String name) {
-                var values = normalized.get(name.toLowerCase());
-                return values == null
-                       ? List.of()
-                       : values;
-            }
-
-            @Override
-            public Map<String, List<String>> asMap() {
-                return normalized;
-            }
-        }
-        var normalized = new HashMap<String, List<String>>();
-        raw.forEach((k, v) -> normalized.put(k.toLowerCase(), List.copyOf(v)));
-        return new headers(Map.copyOf(normalized));
-    }
-
-    /**
-     * Create headers from a single-value map (convenience for simple cases).
-     */
-    static Headers fromSingleValueMap(Map<String, String> raw) {
-        var multi = new HashMap<String, List<String>>();
-        raw.forEach((k, v) -> multi.put(k.toLowerCase(), List.of(v)));
-        return headers(multi);
-    }
-
-    /**
-     * Empty headers.
-     */
-    static Headers empty() {
-        return headers(Map.of());
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/HttpMethod.java b/common/src/main/java/org/pragmatica/http/HttpMethod.java
deleted file mode 100644
index 8c31e76e..00000000
--- a/common/src/main/java/org/pragmatica/http/HttpMethod.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.pragmatica.http;
-/**
- * HTTP request methods.
- */
-public enum HttpMethod {
-    GET,
-    POST,
-    PUT,
-    DELETE,
-    PATCH,
-    HEAD,
-    OPTIONS,
-    TRACE,
-    CONNECT;
-    /**
-     * Parse HTTP method from string.
-     */
-    public static HttpMethod from(String method) {
-        return switch (method.toUpperCase()) {
-            case"GET" -> GET;
-            case"POST" -> POST;
-            case"PUT" -> PUT;
-            case"DELETE" -> DELETE;
-            case"PATCH" -> PATCH;
-            case"HEAD" -> HEAD;
-            case"OPTIONS" -> OPTIONS;
-            case"TRACE" -> TRACE;
-            case"CONNECT" -> CONNECT;
-            default -> throw new IllegalArgumentException("Unknown HTTP method: " + method);
-        };
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/HttpStatus.java b/common/src/main/java/org/pragmatica/http/HttpStatus.java
deleted file mode 100644
index 25b49a10..00000000
--- a/common/src/main/java/org/pragmatica/http/HttpStatus.java
+++ /dev/null
@@ -1,56 +0,0 @@
-package org.pragmatica.http;
-/**
- * HTTP response status codes.
- */
-public enum HttpStatus {
-    // 2xx Success
-    OK(200, "OK"),
-    CREATED(201, "Created"),
-    ACCEPTED(202, "Accepted"),
-    NO_CONTENT(204, "No Content"),
-    // 3xx Redirection
-    MOVED_PERMANENTLY(301, "Moved Permanently"),
-    FOUND(302, "Found"),
-    NOT_MODIFIED(304, "Not Modified"),
-    TEMPORARY_REDIRECT(307, "Temporary Redirect"),
-    PERMANENT_REDIRECT(308, "Permanent Redirect"),
-    // 4xx Client Errors
-    BAD_REQUEST(400, "Bad Request"),
-    UNAUTHORIZED(401, "Unauthorized"),
-    FORBIDDEN(403, "Forbidden"),
-    NOT_FOUND(404, "Not Found"),
-    METHOD_NOT_ALLOWED(405, "Method Not Allowed"),
-    CONFLICT(409, "Conflict"),
-    UNPROCESSABLE_ENTITY(422, "Unprocessable Entity"),
-    TOO_MANY_REQUESTS(429, "Too Many Requests"),
-    // 5xx Server Errors
-    INTERNAL_SERVER_ERROR(500, "Internal Server Error"),
-    NOT_IMPLEMENTED(501, "Not Implemented"),
-    BAD_GATEWAY(502, "Bad Gateway"),
-    SERVICE_UNAVAILABLE(503, "Service Unavailable"),
-    GATEWAY_TIMEOUT(504, "Gateway Timeout");
-    private final int code;
-    private final String reasonPhrase;
-    HttpStatus(int code, String reasonPhrase) {
-        this.code = code;
-        this.reasonPhrase = reasonPhrase;
-    }
-    public int code() {
-        return code;
-    }
-    public String reasonPhrase() {
-        return reasonPhrase;
-    }
-    public boolean isSuccess() {
-        return code >= 200 && code < 300;
-    }
-    public boolean isRedirect() {
-        return code >= 300 && code < 400;
-    }
-    public boolean isClientError() {
-        return code >= 400 && code < 500;
-    }
-    public boolean isServerError() {
-        return code >= 500 && code < 600;
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/QueryParams.java b/common/src/main/java/org/pragmatica/http/QueryParams.java
deleted file mode 100644
index 1c241d34..00000000
--- a/common/src/main/java/org/pragmatica/http/QueryParams.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package org.pragmatica.http;
-
-import org.pragmatica.lang.Option;
-
-import java.util.List;
-import java.util.Map;
-
-/**
- * HTTP query parameters.
- */
-public interface QueryParams {
-    /**
-     * Get the first value for a parameter.
-     */
-    Option<String> get(String name);
-
-    /**
-     * Get all values for a parameter.
-     */
-    List<String> getAll(String name);
-
-    /**
-     * Get all parameters as a map.
-     */
-    Map<String, List<String>> asMap();
-
-    /**
-     * Check if parameter exists.
-     */
-    default boolean has(String name) {
-        return get(name)
-               .isPresent();
-    }
-
-    /**
-     * Create query parameters from a map.
-     */
-    static QueryParams queryParams(Map<String, List<String>> raw) {
-        record queryParams(Map<String, List<String>> params) implements QueryParams {
-            @Override
-            public Option<String> get(String name) {
-                var values = params.get(name);
-                return values == null || values.isEmpty()
-                       ? Option.empty()
-                       : Option.some(values.getFirst());
-            }
-
-            @Override
-            public List<String> getAll(String name) {
-                var values = params.get(name);
-                return values == null
-                       ? List.of()
-                       : values;
-            }
-
-            @Override
-            public Map<String, List<String>> asMap() {
-                return params;
-            }
-        }
-        return new queryParams(Map.copyOf(raw));
-    }
-
-    /**
-     * Empty query parameters.
-     */
-    static QueryParams empty() {
-        return queryParams(Map.of());
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServer.java b/common/src/main/java/org/pragmatica/http/server/HttpServer.java
deleted file mode 100644
index 3809d933..00000000
--- a/common/src/main/java/org/pragmatica/http/server/HttpServer.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-import java.util.function.BiConsumer;
-
-/**
- * HTTP server abstraction.
- */
-public interface HttpServer {
-    /**
-     * Server port.
-     */
-    int port();
-
-    /**
-     * Stop the server.
-     */
-    Promise<Unit> stop();
-
-    /**
-     * Create and start an HTTP server.
-     *
-     * @param config  server configuration
-     * @param handler request handler
-     *
-     * @return promise of the running server
-     */
-    static Promise<HttpServer> httpServer(HttpServerConfig config, BiConsumer<RequestContext, ResponseWriter> handler) {
-        return NettyHttpServer.create(config, handler);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java b/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
deleted file mode 100644
index 66c52ef2..00000000
--- a/common/src/main/java/org/pragmatica/http/server/HttpServerConfig.java
+++ /dev/null
@@ -1,82 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.http.websocket.WebSocketEndpoint;
-import org.pragmatica.lang.Option;
-import org.pragmatica.net.SocketOptions;
-import org.pragmatica.net.tcp.TlsConfig;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Configuration for HTTP server.
- *
- * @param name                 server name for logging
- * @param port                 port to bind to
- * @param tls                  optional TLS configuration
- * @param maxContentLength     maximum content length for requests
- * @param webSocketEndpoints   WebSocket endpoints
- * @param chunkedWriteEnabled  whether to enable chunked transfer encoding
- * @param socketOptions        socket-level options
- */
-public record HttpServerConfig(
- String name,
- int port,
- Option<TlsConfig> tls,
- int maxContentLength,
- List<WebSocketEndpoint> webSocketEndpoints,
- boolean chunkedWriteEnabled,
- SocketOptions socketOptions) {
-    private static final int DEFAULT_MAX_CONTENT_LENGTH = 65536;
-
-    public static HttpServerConfig httpServerConfig(String name, int port) {
-        return new HttpServerConfig(
-        name, port, Option.empty(), DEFAULT_MAX_CONTENT_LENGTH, List.of(), false, SocketOptions.defaults());
-    }
-
-    public HttpServerConfig withTls(TlsConfig tls) {
-        return new HttpServerConfig(name,
-                                    port,
-                                    Option.some(tls),
-                                    maxContentLength,
-                                    webSocketEndpoints,
-                                    chunkedWriteEnabled,
-                                    socketOptions);
-    }
-
-    public HttpServerConfig withMaxContentLength(int maxContentLength) {
-        return new HttpServerConfig(name,
-                                    port,
-                                    tls,
-                                    maxContentLength,
-                                    webSocketEndpoints,
-                                    chunkedWriteEnabled,
-                                    socketOptions);
-    }
-
-    public HttpServerConfig withWebSocket(WebSocketEndpoint endpoint) {
-        var endpoints = new ArrayList<>(webSocketEndpoints);
-        endpoints.add(endpoint);
-        return new HttpServerConfig(name,
-                                    port,
-                                    tls,
-                                    maxContentLength,
-                                    List.copyOf(endpoints),
-                                    chunkedWriteEnabled,
-                                    socketOptions);
-    }
-
-    public HttpServerConfig withChunkedWrite() {
-        return new HttpServerConfig(name, port, tls, maxContentLength, webSocketEndpoints, true, socketOptions);
-    }
-
-    public HttpServerConfig withSocketOptions(SocketOptions socketOptions) {
-        return new HttpServerConfig(name,
-                                    port,
-                                    tls,
-                                    maxContentLength,
-                                    webSocketEndpoints,
-                                    chunkedWriteEnabled,
-                                    socketOptions);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/HttpServerError.java b/common/src/main/java/org/pragmatica/http/server/HttpServerError.java
deleted file mode 100644
index 3a22edbc..00000000
--- a/common/src/main/java/org/pragmatica/http/server/HttpServerError.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.lang.Cause;
-
-/**
- * Error types for HTTP server operations.
- */
-public sealed interface HttpServerError extends Cause {
-    /**
-     * Failed to bind to the specified port.
-     */
-    record BindFailed(int port, Throwable cause) implements HttpServerError {
-        @Override
-        public String message() {
-            return "Failed to bind to port " + port + ": " + cause.getMessage();
-        }
-    }
-
-    /**
-     * Failed to start server.
-     */
-    record StartFailed(String reason) implements HttpServerError {
-        @Override
-        public String message() {
-            return "Failed to start HTTP server: " + reason;
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java b/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
deleted file mode 100644
index 51362ace..00000000
--- a/common/src/main/java/org/pragmatica/http/server/NettyHttpServer.java
+++ /dev/null
@@ -1,394 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.http.Headers;
-import org.pragmatica.http.HttpMethod;
-import org.pragmatica.http.HttpStatus;
-import org.pragmatica.http.QueryParams;
-import org.pragmatica.http.ContentType;
-import org.pragmatica.http.websocket.WebSocketEndpoint;
-import org.pragmatica.http.websocket.WebSocketHandler;
-import org.pragmatica.http.websocket.WebSocketMessage;
-import org.pragmatica.http.websocket.WebSocketSession;
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.net.TlsContextFactory;
-import org.pragmatica.utility.IdGenerator;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.function.BiConsumer;
-
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.*;
-import io.netty.channel.nio.NioIoHandler;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.handler.codec.http.*;
-import io.netty.handler.codec.http.websocketx.*;
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.stream.ChunkedWriteHandler;
-import io.netty.util.AttributeKey;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.lang.Unit.unit;
-
-/**
- * Netty-based HTTP server implementation.
- */
-final class NettyHttpServer implements HttpServer {
-    private static final Logger LOG = LoggerFactory.getLogger(NettyHttpServer.class);
-
-    private final int port;
-    private final EventLoopGroup bossGroup;
-    private final EventLoopGroup workerGroup;
-    private final Channel serverChannel;
-
-    private NettyHttpServer(int port, EventLoopGroup bossGroup, EventLoopGroup workerGroup, Channel serverChannel) {
-        this.port = port;
-        this.bossGroup = bossGroup;
-        this.workerGroup = workerGroup;
-        this.serverChannel = serverChannel;
-    }
-
-    @Override
-    public int port() {
-        return port;
-    }
-
-    @Override
-    public Promise<Unit> stop() {
-        return Promise.promise(promise -> {
-                                   LOG.info("Stopping HTTP server on port {}", port);
-                                   if (serverChannel != null) {
-                                   serverChannel.close()
-                                                .addListener(_ -> {
-                                   cleanup();
-                                   promise.succeed(unit());
-                               });
-                               }else {
-                                   cleanup();
-                                   promise.succeed(unit());
-                               }
-                               });
-    }
-
-    private void cleanup() {
-        if (workerGroup != null) {
-            workerGroup.shutdownGracefully();
-        }
-        if (bossGroup != null) {
-            bossGroup.shutdownGracefully();
-        }
-    }
-
-    static Promise<HttpServer> create(HttpServerConfig config, BiConsumer<RequestContext, ResponseWriter> handler) {
-        // Handle TLS
-        var sslContextResult = config.tls()
-                                     .map(TlsContextFactory::create)
-                                     .fold(() -> null,
-                                           r -> r);
-        if (sslContextResult != null && sslContextResult.isFailure()) {
-            return sslContextResult.<HttpServer> map(_ -> null)
-                   .async();
-        }
-        var sslContext = sslContextResult != null
-                         ? sslContextResult.fold(_ -> null, ctx -> ctx)
-                         : null;
-        var bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
-        var workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
-        var socketOptions = config.socketOptions();
-        var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
-                        .channel(NioServerSocketChannel.class)
-                        .childHandler(new HttpServerInitializer(config, handler, sslContext))
-                        .option(ChannelOption.SO_BACKLOG,
-                                socketOptions.soBacklog())
-                        .childOption(ChannelOption.SO_KEEPALIVE,
-                                     socketOptions.soKeepalive());
-        return Promise.promise(promise -> {
-                                   bootstrap.bind(config.port())
-                                            .addListener((ChannelFutureListener) future -> {
-                                                             if (future.isSuccess()) {
-                                                             var protocol = sslContext != null
-                                                                            ? "HTTPS"
-                                                                            : "HTTP";
-                                                             LOG.info("{} server '{}' started on port {}",
-                                                                      protocol,
-                                                                      config.name(),
-                                                                      config.port());
-                                                             promise.succeed(new NettyHttpServer(config.port(),
-                                                                                                 bossGroup,
-                                                                                                 workerGroup,
-                                                                                                 future.channel()));
-                                                         }else {
-                                                             bossGroup.shutdownGracefully();
-                                                             workerGroup.shutdownGracefully();
-                                                             promise.fail(new HttpServerError.BindFailed(config.port(),
-                                                                                                         future.cause()));
-                                                         }
-                                                         });
-                               });
-    }
-
-    private static class HttpServerInitializer extends ChannelInitializer<SocketChannel> {
-        private final HttpServerConfig config;
-        private final BiConsumer<RequestContext, ResponseWriter> handler;
-        private final SslContext sslContext;
-        private final Map<String, WebSocketEndpoint> wsEndpoints;
-
-        HttpServerInitializer(HttpServerConfig config,
-                              BiConsumer<RequestContext, ResponseWriter> handler,
-                              SslContext sslContext) {
-            this.config = config;
-            this.handler = handler;
-            this.sslContext = sslContext;
-            this.wsEndpoints = new HashMap<>();
-            for (var endpoint : config.webSocketEndpoints()) {
-                wsEndpoints.put(endpoint.path(), endpoint);
-            }
-        }
-
-        @Override
-        protected void initChannel(SocketChannel ch) {
-            var pipeline = ch.pipeline();
-            if (sslContext != null) {
-                pipeline.addLast(sslContext.newHandler(ch.alloc()));
-            }
-            pipeline.addLast(new HttpServerCodec());
-            pipeline.addLast(new HttpObjectAggregator(config.maxContentLength()));
-            if (config.chunkedWriteEnabled()) {
-                pipeline.addLast(new ChunkedWriteHandler());
-            }
-            // Add WebSocket handlers for each endpoint
-            for (var endpoint : config.webSocketEndpoints()) {
-                pipeline.addLast(new WebSocketServerProtocolHandler(endpoint.path(), null, true));
-            }
-            // Create new handler instance per channel (not @Sharable)
-            pipeline.addLast(new HttpRequestHandler(handler, wsEndpoints));
-        }
-    }
-
-    /**
-     * Per-channel HTTP request handler.
-     * NOT @Sharable - each channel gets its own instance to maintain WebSocket state safely.
-     */
-    private static class HttpRequestHandler extends SimpleChannelInboundHandler<Object> {
-        private static final Logger LOG = LoggerFactory.getLogger(HttpRequestHandler.class);
-        private static final AttributeKey<WebSocketState>WS_STATE = AttributeKey.valueOf("wsState");
-
-        private final BiConsumer<RequestContext, ResponseWriter> handler;
-        private final Map<String, WebSocketEndpoint> wsEndpoints;
-
-        HttpRequestHandler(BiConsumer<RequestContext, ResponseWriter> handler,
-                           Map<String, WebSocketEndpoint> wsEndpoints) {
-            this.handler = handler;
-            this.wsEndpoints = wsEndpoints;
-        }
-
-        @Override
-        protected void channelRead0(ChannelHandlerContext ctx, Object msg) {
-            if (msg instanceof FullHttpRequest request) {
-                handleHttpRequest(ctx, request);
-            }else if (msg instanceof WebSocketFrame frame) {
-                handleWebSocketFrame(ctx, frame);
-            }
-        }
-
-        private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest request) {
-            // Check if this is a WebSocket upgrade
-            var path = new QueryStringDecoder(request.uri()).path();
-            var wsEndpoint = wsEndpoints.get(path);
-            if (wsEndpoint != null && isWebSocketUpgrade(request)) {
-                // WebSocket upgrade will be handled by WebSocketServerProtocolHandler
-                // Store handler and session in channel attribute for later use
-                var wsHandler = wsEndpoint.handler()
-                                          .get();
-                var wsSession = new NettyWebSocketSession(ctx.channel());
-                ctx.channel()
-                   .attr(WS_STATE)
-                   .set(new WebSocketState(wsHandler, wsSession));
-                ctx.fireChannelRead(request.retain());
-                return;
-            }
-            // Regular HTTP request - generate request ID
-            var requestId = IdGenerator.generate("req");
-            var requestContext = createRequestContext(requestId, request);
-            var responseWriter = new NettyResponseWriter(ctx, requestId);
-            try{
-                handler.accept(requestContext, responseWriter);
-            } catch (Exception e) {
-                LOG.error("Error handling request {}", requestId, e);
-                responseWriter.error(HttpStatus.INTERNAL_SERVER_ERROR, "Internal Server Error");
-            }
-        }
-
-        private boolean isWebSocketUpgrade(FullHttpRequest request) {
-            return request.headers()
-                          .contains(HttpHeaderNames.UPGRADE, HttpHeaderValues.WEBSOCKET, true);
-        }
-
-        private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
-            var state = ctx.channel()
-                           .attr(WS_STATE)
-                           .get();
-            if (state == null) {
-                return;
-            }
-            if (frame instanceof TextWebSocketFrame textFrame) {
-                state.handler.handle(state.session,
-                                     new WebSocketMessage.Text(textFrame.text()));
-            }else if (frame instanceof BinaryWebSocketFrame binaryFrame) {
-                var bytes = new byte[binaryFrame.content()
-                                                .readableBytes()];
-                binaryFrame.content()
-                           .readBytes(bytes);
-                state.handler.handle(state.session, new WebSocketMessage.Binary(bytes));
-            }else if (frame instanceof CloseWebSocketFrame) {
-                state.handler.handle(state.session, new WebSocketMessage.Close());
-                ctx.channel()
-                   .attr(WS_STATE)
-                   .set(null);
-            }
-        }
-
-        @Override
-        public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
-            if (evt instanceof WebSocketServerProtocolHandler.HandshakeComplete) {
-                var state = ctx.channel()
-                               .attr(WS_STATE)
-                               .get();
-                if (state != null) {
-                    state.handler.handle(state.session, new WebSocketMessage.Open());
-                }
-            }
-            super.userEventTriggered(ctx, evt);
-        }
-
-        @Override
-        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
-            LOG.error("Error in HTTP handler", cause);
-            ctx.close();
-        }
-
-        private RequestContext createRequestContext(String requestId, FullHttpRequest request) {
-            var decoder = new QueryStringDecoder(request.uri());
-            var path = decoder.path();
-            var method = HttpMethod.from(request.method()
-                                                .name());
-            // Parse headers
-            var headerMap = new HashMap<String, List<String>>();
-            for (var entry : request.headers()) {
-                headerMap.computeIfAbsent(entry.getKey()
-                                               .toLowerCase(),
-                                          _ -> new java.util.ArrayList<>())
-                         .add(entry.getValue());
-            }
-            var headers = Headers.headers(headerMap);
-            // Parse query params
-            var queryParams = QueryParams.queryParams(decoder.parameters());
-            // Read body
-            var content = request.content();
-            var body = new byte[content.readableBytes()];
-            content.readBytes(body);
-            return new NettyRequestContext(requestId, method, path, headers, queryParams, body);
-        }
-    }
-
-    /**
-     * WebSocket state stored per channel.
-     */
-    private record WebSocketState(WebSocketHandler handler, NettyWebSocketSession session) {}
-
-    private record NettyRequestContext(
-    String requestId,
-    HttpMethod method,
-    String path,
-    Headers headers,
-    QueryParams queryParams,
-    byte[] body) implements RequestContext {}
-
-    private static class NettyResponseWriter implements ResponseWriter {
-        private final ChannelHandlerContext ctx;
-        private final String requestId;
-        private final io.netty.handler.codec.http.HttpHeaders responseHeaders;
-        private boolean written = false;
-
-        NettyResponseWriter(ChannelHandlerContext ctx, String requestId) {
-            this.ctx = ctx;
-            this.requestId = requestId;
-            this.responseHeaders = new DefaultHttpHeaders();
-        }
-
-        @Override
-        public ResponseWriter header(String name, String value) {
-            responseHeaders.set(name, value);
-            return this;
-        }
-
-        @Override
-        public void write(HttpStatus status, byte[] body, ContentType contentType) {
-            if (written) {
-                return;
-            }
-            written = true;
-            var nettyStatus = HttpResponseStatus.valueOf(status.code());
-            var content = Unpooled.wrappedBuffer(body);
-            var response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, nettyStatus, content);
-            response.headers()
-                    .set(HttpHeaderNames.CONTENT_TYPE,
-                         contentType.headerText());
-            response.headers()
-                    .set(HttpHeaderNames.CONTENT_LENGTH, body.length);
-            response.headers()
-                    .set(X_REQUEST_ID, requestId);
-            response.headers()
-                    .add(responseHeaders);
-            ctx.writeAndFlush(response)
-               .addListener(ChannelFutureListener.CLOSE);
-        }
-    }
-
-    private static class NettyWebSocketSession implements WebSocketSession {
-        private final Channel channel;
-        private final String id;
-
-        NettyWebSocketSession(Channel channel) {
-            this.channel = channel;
-            this.id = IdGenerator.generate("ws");
-        }
-
-        @Override
-        public String id() {
-            return id;
-        }
-
-        @Override
-        public void send(String text) {
-            if (channel.isActive()) {
-                channel.writeAndFlush(new TextWebSocketFrame(text));
-            }
-        }
-
-        @Override
-        public void send(byte[] binary) {
-            if (channel.isActive()) {
-                channel.writeAndFlush(new BinaryWebSocketFrame(Unpooled.wrappedBuffer(binary)));
-            }
-        }
-
-        @Override
-        public void close() {
-            if (channel.isActive()) {
-                channel.writeAndFlush(new CloseWebSocketFrame())
-                       .addListener(ChannelFutureListener.CLOSE);
-            }
-        }
-
-        @Override
-        public boolean isOpen() {
-            return channel.isActive();
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/RequestContext.java b/common/src/main/java/org/pragmatica/http/server/RequestContext.java
deleted file mode 100644
index 1da00187..00000000
--- a/common/src/main/java/org/pragmatica/http/server/RequestContext.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.http.Headers;
-import org.pragmatica.http.HttpMethod;
-import org.pragmatica.http.QueryParams;
-
-/**
- * HTTP request context providing access to request data.
- */
-public interface RequestContext {
-    /**
-     * Unique request ID for tracing and logging.
-     * Format: req_[ulid] (e.g., req_01hq4x2abc...)
-     */
-    String requestId();
-
-    /**
-     * HTTP method.
-     */
-    HttpMethod method();
-
-    /**
-     * Request path (without query string).
-     */
-    String path();
-
-    /**
-     * Request headers.
-     */
-    Headers headers();
-
-    /**
-     * Query parameters.
-     */
-    QueryParams queryParams();
-
-    /**
-     * Request body as bytes.
-     */
-    byte[] body();
-
-    /**
-     * Request body as UTF-8 string.
-     */
-    default String bodyAsString() {
-        var bytes = body();
-        return bytes.length == 0
-               ? ""
-               : new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
-    }
-
-    /**
-     * Check if request has a body.
-     */
-    default boolean hasBody() {
-        return body().length > 0;
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java b/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
deleted file mode 100644
index c0c7034d..00000000
--- a/common/src/main/java/org/pragmatica/http/server/ResponseWriter.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package org.pragmatica.http.server;
-
-import org.pragmatica.http.CommonContentType;
-import org.pragmatica.http.ContentType;
-import org.pragmatica.http.HttpStatus;
-import org.pragmatica.lang.Cause;
-
-import java.nio.charset.StandardCharsets;
-
-/**
- * Response writer for HTTP handlers.
- * <p>
- * Each response method can only be called once per request.
- */
-public interface ResponseWriter {
-    /**
-     * Standard header name for request ID tracing.
-     */
-    String X_REQUEST_ID = "X-Request-Id";
-
-    /**
-     * Write response with status, body, and content type.
-     */
-    void write(HttpStatus status, byte[] body, ContentType contentType);
-
-    /**
-     * Add header to the response. Must be called before write methods.
-     */
-    ResponseWriter header(String name, String value);
-
-    // Convenience methods
-    /**
-     * Write successful JSON response.
-     */
-    default void ok(String json) {
-        write(HttpStatus.OK, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
-    }
-
-    /**
-     * Write successful response with content type.
-     */
-    default void ok(byte[] body, ContentType contentType) {
-        write(HttpStatus.OK, body, contentType);
-    }
-
-    /**
-     * Write successful text response.
-     */
-    default void okText(String text) {
-        write(HttpStatus.OK, text.getBytes(StandardCharsets.UTF_8), CommonContentType.TEXT_PLAIN);
-    }
-
-    /**
-     * Write successful HTML response.
-     */
-    default void okHtml(String html) {
-        write(HttpStatus.OK, html.getBytes(StandardCharsets.UTF_8), CommonContentType.TEXT_HTML);
-    }
-
-    /**
-     * Write 204 No Content response.
-     */
-    default void noContent() {
-        write(HttpStatus.NO_CONTENT, new byte[0], CommonContentType.TEXT_PLAIN);
-    }
-
-    /**
-     * Write 404 Not Found response.
-     */
-    default void notFound() {
-        error(HttpStatus.NOT_FOUND, "Not Found");
-    }
-
-    /**
-     * Write 400 Bad Request response.
-     */
-    default void badRequest(String message) {
-        error(HttpStatus.BAD_REQUEST, message);
-    }
-
-    /**
-     * Write error response.
-     */
-    default void error(HttpStatus status, String message) {
-        var json = "{\"error\":\"" + escapeJson(message) + "\"}";
-        write(status, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
-    }
-
-    /**
-     * Write 500 Internal Server Error response.
-     */
-    default void internalError(Cause cause) {
-        error(HttpStatus.INTERNAL_SERVER_ERROR, cause.message());
-    }
-
-    /**
-     * Write JSON response with status.
-     */
-    default void respond(HttpStatus status, String json) {
-        write(status, json.getBytes(StandardCharsets.UTF_8), CommonContentType.APPLICATION_JSON);
-    }
-
-    private static String escapeJson(String s) {
-        if (s == null) {
-            return "";
-        }
-        return s.replace("\\", "\\\\")
-                .replace("\"", "\\\"")
-                .replace("\n", "\\n")
-                .replace("\r", "\\r")
-                .replace("\t", "\\t");
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
deleted file mode 100644
index f6ab4cd3..00000000
--- a/common/src/main/java/org/pragmatica/http/websocket/WebSocketEndpoint.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.pragmatica.http.websocket;
-
-import java.util.function.Supplier;
-
-/**
- * WebSocket endpoint configuration.
- *
- * @param path    the WebSocket path (e.g., "/ws/events")
- * @param handler supplier for WebSocket handler (called for each new connection)
- */
-public record WebSocketEndpoint(String path, Supplier<WebSocketHandler> handler) {
-    public static WebSocketEndpoint webSocketEndpoint(String path, Supplier<WebSocketHandler> handler) {
-        return new WebSocketEndpoint(path, handler);
-    }
-
-    public static WebSocketEndpoint webSocketEndpoint(String path, WebSocketHandler handler) {
-        return new WebSocketEndpoint(path, () -> handler);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
deleted file mode 100644
index d7b89ae6..00000000
--- a/common/src/main/java/org/pragmatica/http/websocket/WebSocketHandler.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.pragmatica.http.websocket;
-/**
- * Handler for WebSocket messages.
- * <p>
- * All message types (Open, Text, Binary, Close) are delivered through the single
- * {@link #handle(WebSocketSession, WebSocketMessage)} method.
- */
-public interface WebSocketHandler {
-    /**
-     * Handle a WebSocket message.
-     *
-     * @param session the session that received the message
-     * @param message the message (Open, Text, Binary, or Close)
-     */
-    void handle(WebSocketSession session, WebSocketMessage message);
-}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
deleted file mode 100644
index ff780d7b..00000000
--- a/common/src/main/java/org/pragmatica/http/websocket/WebSocketMessage.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.pragmatica.http.websocket;
-/**
- * WebSocket message types.
- */
-public sealed interface WebSocketMessage {
-    /**
-     * Connection opened.
-     */
-    record Open() implements WebSocketMessage {}
-
-    /**
-     * Text message received.
-     */
-    record Text(String content) implements WebSocketMessage {}
-
-    /**
-     * Binary message received.
-     */
-    record Binary(byte[] content) implements WebSocketMessage {}
-
-    /**
-     * Connection closed.
-     */
-    record Close() implements WebSocketMessage {}
-}
diff --git a/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java b/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java
deleted file mode 100644
index 22dba104..00000000
--- a/common/src/main/java/org/pragmatica/http/websocket/WebSocketSession.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.pragmatica.http.websocket;
-/**
- * WebSocket session for sending messages and managing connection.
- */
-public interface WebSocketSession {
-    /**
-     * Unique session identifier.
-     */
-    String id();
-
-    /**
-     * Send a text message.
-     */
-    void send(String text);
-
-    /**
-     * Send a binary message.
-     */
-    void send(byte[] binary);
-
-    /**
-     * Close the connection.
-     */
-    void close();
-
-    /**
-     * Check if the session is still open.
-     */
-    boolean isOpen();
-}
diff --git a/common/src/main/java/org/pragmatica/net/AsyncCloseable.java b/common/src/main/java/org/pragmatica/net/AsyncCloseable.java
deleted file mode 100644
index 916c9223..00000000
--- a/common/src/main/java/org/pragmatica/net/AsyncCloseable.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-
-/**
- * Interface for resources that can be closed asynchronously.
- */
-public interface AsyncCloseable {
-    Promise<Unit> close();
-}
diff --git a/common/src/main/java/org/pragmatica/net/Server.java b/common/src/main/java/org/pragmatica/net/Server.java
deleted file mode 100644
index 93128849..00000000
--- a/common/src/main/java/org/pragmatica/net/Server.java
+++ /dev/null
@@ -1,176 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.tcp.NodeAddress;
-
-import java.util.List;
-import java.util.function.Supplier;
-
-import io.netty.bootstrap.Bootstrap;
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.*;
-import io.netty.channel.nio.NioIoHandler;
-import io.netty.channel.socket.SocketChannel;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import io.netty.handler.logging.LogLevel;
-import io.netty.handler.logging.LoggingHandler;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-/**
- * Convenient wrapper for Netty server setup boilerplate.
- * Supports TLS, socket options, and client connections reusing the same channel handlers.
- */
-public interface Server {
-    String name();
-
-    int port();
-
-    Promise<Channel> connectTo(NodeAddress peerLocation);
-
-    /**
-     * Shutdown the server.
-     *
-     * @param intermediateOperation Operation to run between server channel shutdown and event loop groups shutdown.
-     *                              Enables graceful shutdown: stop accepting new connections, finish existing work, then shutdown.
-     */
-    Promise<Unit> stop(Supplier<Promise<Unit>> intermediateOperation);
-
-    /**
-     * Create a server with the given configuration.
-     *
-     * @param config          server configuration
-     * @param channelHandlers supplier for channel handlers (called for each new connection)
-     *
-     * @return promise of the running server
-     */
-    static Promise<Server> server(ServerConfig config, Supplier<List<ChannelHandler>> channelHandlers) {
-        record server(
-        String name,
-        int port,
-        EventLoopGroup bossGroup,
-        EventLoopGroup workerGroup,
-        Channel serverChannel,
-        Supplier<List<ChannelHandler>> channelHandlers) implements Server {
-            private static final Logger log = LoggerFactory.getLogger(Server.class);
-
-            @Override
-            public Promise<Unit> stop(Supplier<Promise<Unit>> intermediate) {
-                var stopPromise = Promise.<Unit>promise();
-                log.trace("Stopping {}: closing server channel", name());
-                serverChannel.close()
-                             .addListener(_ -> intermediate.get()
-                                                           .onResult(_ -> shutdownGroups())
-                                                           .onResult(stopPromise::resolve));
-                return stopPromise;
-            }
-
-            private void shutdownGroups() {
-                log.debug("Stopping {}: shutting down boss group", name());
-                bossGroup.shutdownGracefully();
-                log.debug("Stopping {}: shutting down worker group", name());
-                workerGroup.shutdownGracefully();
-                log.info("Server {} stopped", name());
-            }
-
-            @Override
-            public Promise<Channel> connectTo(NodeAddress address) {
-                var bootstrap = new Bootstrap().group(workerGroup)
-                                .channel(NioSocketChannel.class)
-                                .handler(createChildHandler(channelHandlers, null));
-                var promise = Promise.<Channel>promise();
-                bootstrap.connect(address.host(),
-                                  address.port())
-                         .addListener((ChannelFutureListener) future -> {
-                                          if (future.isSuccess()) {
-                                          promise.succeed(future.channel());
-                                      }else {
-                                          promise.fail(Causes.fromThrowable(future.cause()));
-                                      }
-                                      });
-                return promise;
-            }
-
-            private static ChannelInitializer<SocketChannel> createChildHandler(Supplier<List<ChannelHandler>> channelHandlers,
-                                                                                io.netty.handler.ssl.SslContext sslContext) {
-                return new ChannelInitializer<>() {
-                    @Override
-                    protected void initChannel(SocketChannel ch) {
-                        var pipeline = ch.pipeline();
-                        if (sslContext != null) {
-                            pipeline.addLast(sslContext.newHandler(ch.alloc()));
-                        }
-                        for (var handler : channelHandlers.get()) {
-                            pipeline.addLast(handler);
-                        }
-                    }
-                };
-            }
-        }
-        // Handle TLS configuration
-        var sslContextResult = config.tls()
-                                     .map(TlsContextFactory::create)
-                                     .fold(() -> null,
-                                           result -> result);
-        if (sslContextResult != null && sslContextResult.isFailure()) {
-            return sslContextResult.mapError(cause -> cause)
-                                   .<Server> map(_ -> null)
-                                   .async();
-        }
-        var sslContext = sslContextResult != null
-                         ? sslContextResult.fold(_ -> null, ctx -> ctx)
-                         : null;
-        var bossGroup = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
-        var workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
-        var socketOptions = config.socketOptions();
-        var bootstrap = new ServerBootstrap().group(bossGroup, workerGroup)
-                        .channel(NioServerSocketChannel.class)
-                        .handler(new LoggingHandler(LogLevel.TRACE))
-                        .childHandler(server.createChildHandler(channelHandlers, sslContext))
-                        .option(ChannelOption.SO_BACKLOG,
-                                socketOptions.soBacklog())
-                        .childOption(ChannelOption.SO_KEEPALIVE,
-                                     socketOptions.soKeepalive());
-        var promise = Promise.<Server>promise();
-        bootstrap.bind(config.port())
-                 .addListener((ChannelFutureListener) future -> {
-                                  if (future.isSuccess()) {
-                                  var protocol = sslContext != null
-                                                 ? "TLS"
-                                                 : "TCP";
-                                  server.log.info("Server {} started on port {} ({})",
-                                                  config.name(),
-                                                  config.port(),
-                                                  protocol);
-                                  promise.succeed(new server(
-        config.name(),
-        config.port(),
-        bossGroup,
-        workerGroup,
-        future.channel(),
-        channelHandlers));
-                              }else {
-                                  bossGroup.shutdownGracefully();
-                                  workerGroup.shutdownGracefully();
-                                  promise.fail(Causes.fromThrowable(future.cause()));
-                              }
-                              });
-        return promise;
-    }
-
-    /**
-     * Create a server with simple configuration.
-     *
-     * @param name            server name for logging
-     * @param port            port to bind to
-     * @param channelHandlers supplier for channel handlers
-     *
-     * @return promise of the running server
-     */
-    static Promise<Server> server(String name, int port, Supplier<List<ChannelHandler>> channelHandlers) {
-        return server(ServerConfig.serverConfig(name, port), channelHandlers);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/ServerConfig.java b/common/src/main/java/org/pragmatica/net/ServerConfig.java
deleted file mode 100644
index 64db4bc1..00000000
--- a/common/src/main/java/org/pragmatica/net/ServerConfig.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Option;
-import org.pragmatica.net.tcp.TlsConfig;
-
-/**
- * Configuration for TCP server.
- *
- * @param name          server name for logging
- * @param port          port to bind to
- * @param tls           optional TLS configuration for secure connections
- * @param socketOptions socket-level options
- */
-public record ServerConfig(
- String name,
- int port,
- Option<TlsConfig> tls,
- SocketOptions socketOptions) {
-    public static ServerConfig serverConfig(String name, int port) {
-        return new ServerConfig(name, port, Option.empty(), SocketOptions.defaults());
-    }
-
-    public static ServerConfig serverConfig(String name, int port, TlsConfig tls) {
-        return new ServerConfig(name, port, Option.some(tls), SocketOptions.defaults());
-    }
-
-    public ServerConfig withTls(TlsConfig tls) {
-        return new ServerConfig(name, port, Option.some(tls), socketOptions);
-    }
-
-    public ServerConfig withSocketOptions(SocketOptions socketOptions) {
-        return new ServerConfig(name, port, tls, socketOptions);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/SocketOptions.java b/common/src/main/java/org/pragmatica/net/SocketOptions.java
deleted file mode 100644
index 0027fcf2..00000000
--- a/common/src/main/java/org/pragmatica/net/SocketOptions.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package org.pragmatica.net;
-/**
- * Socket-level options for server configuration.
- *
- * @param soBacklog   maximum queue length for incoming connection requests (SO_BACKLOG)
- * @param soKeepalive whether to enable TCP keepalive probes (SO_KEEPALIVE)
- */
-public record SocketOptions(int soBacklog, boolean soKeepalive) {
-    public static SocketOptions socketOptions(int soBacklog, boolean soKeepalive) {
-        return new SocketOptions(soBacklog, soKeepalive);
-    }
-
-    public static SocketOptions defaults() {
-        return new SocketOptions(128, true);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/TlsContextFactory.java b/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
deleted file mode 100644
index 0d77c3c8..00000000
--- a/common/src/main/java/org/pragmatica/net/TlsContextFactory.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Result;
-import org.pragmatica.net.tcp.TlsConfig;
-
-import io.netty.handler.ssl.SslContext;
-import io.netty.handler.ssl.SslContextBuilder;
-import io.netty.handler.ssl.util.SelfSignedCertificate;
-
-/**
- * Factory for creating Netty SSL contexts from TLS configuration.
- */
-public final class TlsContextFactory {
-    private TlsContextFactory() {}
-
-    /**
-     * Create SSL context from TLS configuration.
-     *
-     * @param config TLS configuration
-     *
-     * @return SSL context or error
-     */
-    public static Result<SslContext> create(TlsConfig config) {
-        return switch (config) {
-            case TlsConfig.SelfSigned() -> createSelfSigned();
-            case TlsConfig.FromFiles fromFiles -> createFromFiles(fromFiles);
-        };
-    }
-
-    private static Result<SslContext> createSelfSigned() {
-        try{
-            var ssc = new SelfSignedCertificate();
-            var sslContext = SslContextBuilder.forServer(ssc.certificate(),
-                                                         ssc.privateKey())
-                                              .build();
-            return Result.success(sslContext);
-        } catch (Exception e) {
-            return new TlsError.SelfSignedGenerationFailed(e).result();
-        }
-    }
-
-    private static Result<SslContext> createFromFiles(TlsConfig.FromFiles config) {
-        try{
-            var password = config.keyPassword()
-                                 .fold(() -> null,
-                                       pwd -> pwd);
-            var builder = SslContextBuilder.forServer(
-            config.certificatePath()
-                  .toFile(),
-            config.privateKeyPath()
-                  .toFile(),
-            password);
-            return Result.success(builder.build());
-        } catch (Exception e) {
-            return new TlsError.CertificateLoadFailed(config.certificatePath(), e).result();
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/TlsError.java b/common/src/main/java/org/pragmatica/net/TlsError.java
deleted file mode 100644
index 6802f1b0..00000000
--- a/common/src/main/java/org/pragmatica/net/TlsError.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.pragmatica.net;
-
-import org.pragmatica.lang.Cause;
-
-import java.nio.file.Path;
-
-/**
- * Error types for TLS operations.
- */
-public sealed interface TlsError extends Cause {
-    /**
-     * Failed to load certificate from file.
-     */
-    record CertificateLoadFailed(Path path, Throwable cause) implements TlsError {
-        @Override
-        public String message() {
-            return "Failed to load certificate from " + path + ": " + cause.getMessage();
-        }
-    }
-
-    /**
-     * Failed to generate self-signed certificate.
-     */
-    record SelfSignedGenerationFailed(Throwable cause) implements TlsError {
-        @Override
-        public String message() {
-            return "Failed to generate self-signed certificate: " + cause.getMessage();
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DnsClient.java b/common/src/main/java/org/pragmatica/net/dns/DnsClient.java
deleted file mode 100644
index 63131e43..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/DnsClient.java
+++ /dev/null
@@ -1,199 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.net.AsyncCloseable;
-import org.pragmatica.net.dns.ResolverErrors.RequestTimeout;
-import org.pragmatica.net.dns.ResolverErrors.ServerError;
-
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import io.netty.bootstrap.Bootstrap;
-import io.netty.buffer.ByteBufUtil;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.SimpleChannelInboundHandler;
-import io.netty.channel.socket.DatagramChannel;
-import io.netty.channel.socket.nio.NioDatagramChannel;
-import io.netty.handler.codec.dns.*;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.lang.Option.option;
-import static org.pragmatica.lang.Unit.unit;
-import static org.pragmatica.lang.io.TimeSpan.timeSpan;
-
-/**
- * Asynchronous DNS client using Netty UDP.
- */
-public interface DnsClient extends AsyncCloseable {
-    Logger log = LoggerFactory.getLogger(DnsClient.class);
-
-    Promise<DomainAddress> resolve(DomainName domainName, InetSocketAddress serverAddress);
-
-    /**
-     * Create DNS client with provided event loop group.
-     * The event loop group will NOT be shut down when the client is closed.
-     */
-    static DnsClient dnsClient(EventLoopGroup eventLoopGroup) {
-        var bootstrap = new Bootstrap().group(eventLoopGroup)
-                        .channel(NioDatagramChannel.class);
-        var client = DnsClientImpl.forBootstrap(bootstrap, false);
-        bootstrap.handler(DnsChannelInitializer.forClient(client));
-        return client;
-    }
-}
-
-class DnsChannelInitializer extends ChannelInitializer<DatagramChannel> {
-    private final DnsClientImpl client;
-
-    private DnsChannelInitializer(DnsClientImpl client) {
-        this.client = client;
-    }
-
-    static DnsChannelInitializer forClient(DnsClientImpl client) {
-        return new DnsChannelInitializer(client);
-    }
-
-    @Override
-    protected void initChannel(DatagramChannel ch) {
-        ch.pipeline()
-          .addLast(new DatagramDnsQueryEncoder())
-          .addLast(new DatagramDnsResponseDecoder())
-          .addLast(new SimpleChannelInboundHandler<DatagramDnsResponse>() {
-            @Override
-            protected void channelRead0(ChannelHandlerContext ctx, DatagramDnsResponse msg) {
-                       try{
-                       client.handleDatagram(msg);
-                   } finally{
-                       ctx.close();
-                   }
-                   }
-        });
-    }
-}
-
-record Request(DomainName domainName, Promise<DomainAddress> promise, int requestId) {}
-
-record DnsClientImpl(Bootstrap bootstrap,
-                     ConcurrentHashMap<Integer, Request> requestMap,
-                     AtomicInteger idCounter,
-                     boolean ownsEventLoop) implements DnsClient {
-    private static final TimeSpan QUERY_TIMEOUT = timeSpan(10)
-                                                 .seconds();
-
-    static DnsClientImpl forBootstrap(Bootstrap bootstrap, boolean ownsEventLoop) {
-        return new DnsClientImpl(bootstrap, new ConcurrentHashMap<>(), new AtomicInteger(1), ownsEventLoop);
-    }
-
-    @Override
-    public Promise<DomainAddress> resolve(DomainName domainName, InetSocketAddress serverAddress) {
-        return Promise.promise(promise -> fireRequest(promise, domainName, serverAddress));
-    }
-
-    @Override
-    public Promise<Unit> close() {
-        if (!ownsEventLoop) {
-            return Promise.success(unit());
-        }
-        return Promise.promise(promise -> bootstrap()
-                                          .config()
-                                          .group()
-                                          .shutdownGracefully()
-                                          .addListener(_ -> promise.succeed(unit())));
-    }
-
-    void handleDatagram(DatagramDnsResponse msg) {
-        var requestId = msg.id();
-        log.debug("Received response for request Id {}", requestId);
-        option(requestMap.get(requestId))
-        .onPresent(request -> handleResponse(request, msg));
-    }
-
-    private void handleResponse(Request request, DatagramDnsResponse msg) {
-        log.debug("Handling response {} for request {}", msg, request);
-        if (!msg.code()
-                .equals(DnsResponseCode.NOERROR)) {
-            var errorMessage = "Server responded with error code " + msg.code();
-            log.warn(errorMessage);
-            request.promise()
-                   .fail(new ServerError(errorMessage));
-            return;
-        }
-        // Take record with minimal TTL
-        // This is less efficient in regard to number of requests, but enables
-        // faster propagation of DNS changes.
-        extractAddresses(request, msg)
-        .stream()
-        .min(Comparator.comparing(DomainAddress::ttl))
-        .ifPresentOrElse(address -> request.promise()
-                                           .succeed(address),
-                         () -> request.promise()
-                                      .fail(new ServerError("No address provided by server")));
-    }
-
-    private static ArrayList<DomainAddress> extractAddresses(Request request, DatagramDnsResponse msg) {
-        var addresses = new ArrayList<DomainAddress>();
-        for (int i = 0, count = msg.count(DnsSection.ANSWER); i < count; i++ ) {
-            var record = msg.recordAt(DnsSection.ANSWER, i);
-            if (record.type() == DnsRecordType.A) {
-                var raw = (DnsRawRecord) record;
-                log.debug("record {}, ttl {}", raw, raw.timeToLive());
-                InetUtils.forBytes(ByteBufUtil.getBytes(raw.content()))
-                         .map(inetAddress -> DomainAddress.domainAddress(request.domainName(),
-                                                                         inetAddress,
-                                                                         Duration.ofSeconds(raw.timeToLive())))
-                         .onSuccess(addresses::add)
-                         .onFailureRun(() -> log.warn("Response for {} contains incorrectly formatted IP address",
-                                                      request.domainName()));
-            }
-        }
-        return addresses;
-    }
-
-    private void fireRequest(Promise<DomainAddress> promise, DomainName domainName, InetSocketAddress serverAddress) {
-        bootstrap()
-        .bind(0)
-        .syncUninterruptibly()
-        .channel()
-        .writeAndFlush(buildQuery(serverAddress, promise, domainName));
-        // Setup guard timeout
-        promise.async(QUERY_TIMEOUT,
-                      pending -> pending.fail(new RequestTimeout("No response from server in 10 seconds")));
-    }
-
-    private DatagramDnsQuery buildQuery(InetSocketAddress serverAddress,
-                                        Promise<DomainAddress> promise,
-                                        DomainName domainName) {
-        var request = computeRequest(promise, domainName);
-        log.debug("Sending request {} to {}", request, serverAddress);
-        return new DatagramDnsQuery(null, serverAddress, request.requestId()).setRecursionDesired(true)
-                                                                .setRecord(DnsSection.QUESTION,
-                                                                           new DefaultDnsQuestion(request.domainName()
-                                                                                                         .name(),
-                                                                                                  DnsRecordType.A));
-    }
-
-    private Request computeRequest(Promise<DomainAddress> promise, DomainName domainName) {
-        for (int attempt = 0; attempt < 0xFFFF; attempt++ ) {
-            var requestId = idCounter()
-                            .getAndIncrement() & 0xFFFF;
-            var request = new Request(domainName, promise, requestId);
-            if (requestMap()
-                .putIfAbsent(requestId, request) == null) {
-                // Ensure slot for this ID is freed regardless of the outcome
-                promise.onResultRun(() -> requestMap()
-                                          .remove(requestId));
-                return request;
-            }
-        }
-        throw new IllegalStateException("Unable to generate request id (too many requests in progress)");
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java b/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
deleted file mode 100644
index f214e646..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/DomainAddress.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package org.pragmatica.net.dns;
-
-import java.net.InetAddress;
-import java.time.Duration;
-
-/**
- * Resolved domain address with TTL.
- */
-public interface DomainAddress {
-    DomainName name();
-
-    InetAddress ip();
-
-    Duration ttl();
-
-    static DomainAddress domainAddress(DomainName name, InetAddress ip, Duration ttl) {
-        record domainAddress(DomainName name, InetAddress ip, Duration ttl) implements DomainAddress {}
-        return new domainAddress(name, ip, ttl);
-    }
-
-    default DomainAddress withDomain(DomainName domainName) {
-        return domainAddress(domainName, ip(), ttl());
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainName.java b/common/src/main/java/org/pragmatica/net/dns/DomainName.java
deleted file mode 100644
index 545e54a0..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/DomainName.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package org.pragmatica.net.dns;
-/**
- * Domain name to resolve.
- */
-public record DomainName(String name) {
-    public static DomainName domainName(String domainName) {
-        return new DomainName(domainName);
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java b/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
deleted file mode 100644
index 24b299be..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/DomainNameResolver.java
+++ /dev/null
@@ -1,150 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.pragmatica.lang.Promise;
-import org.pragmatica.lang.Result;
-import org.pragmatica.lang.Unit;
-import org.pragmatica.lang.io.TimeSpan;
-import org.pragmatica.net.AsyncCloseable;
-import org.pragmatica.net.dns.ResolverErrors.UnknownDomain;
-
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.time.Duration;
-import java.util.List;
-import java.util.concurrent.ConcurrentHashMap;
-
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.MultiThreadIoEventLoopGroup;
-import io.netty.channel.nio.NioIoHandler;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import static org.pragmatica.lang.Option.option;
-import static org.pragmatica.lang.Promise.resolved;
-import static org.pragmatica.lang.Promise.success;
-import static org.pragmatica.lang.io.TimeSpan.timeSpan;
-import static org.pragmatica.net.dns.DomainAddress.domainAddress;
-import static org.pragmatica.net.dns.DomainName.domainName;
-
-/**
- * Asynchronous domain name resolver with TTL-based caching.
- * <p>
- * The cache uses promise mechanics for automatic TTL expiry - no background threads required.
- * Each successful resolution schedules its own eviction via {@code promise.async(ttl, ...)}.
- */
-public interface DomainNameResolver extends AsyncCloseable {
-    int DNS_UDP_PORT = 53;
-    Result<DomainAddress>UNKNOWN_DOMAIN = new UnknownDomain("Unknown domain").result();
-
-    /**
-     * Resolve domain name, using cache if available.
-     */
-    default Promise<DomainAddress> resolve(String name) {
-        return resolve(domainName(name));
-    }
-
-    /**
-     * Resolve domain name, using cache if available.
-     */
-    Promise<DomainAddress> resolve(DomainName name);
-
-    /**
-     * Get cached resolution result without triggering new resolution.
-     */
-    default Promise<DomainAddress> resolveCached(String name) {
-        return resolveCached(domainName(name));
-    }
-
-    /**
-     * Get cached resolution result without triggering new resolution.
-     */
-    Promise<DomainAddress> resolveCached(DomainName name);
-
-    /**
-     * Create resolver with provided DNS servers, using own event loop.
-     * The event loop will be shut down when the resolver is closed.
-     *
-     * @param servers list of DNS server addresses
-     * @return new resolver instance
-     */
-    static DomainNameResolver domainNameResolver(List<InetAddress> servers) {
-        var eventLoop = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
-        return new Resolver(
-        DnsClient.dnsClient(eventLoop), prepareServers(servers), buildDnsCache(), eventLoop, true);
-    }
-
-    /**
-     * Create resolver with provided DNS servers, sharing the given event loop.
-     * The event loop will NOT be shut down when the resolver is closed.
-     *
-     * @param servers    list of DNS server addresses
-     * @param eventLoop  event loop group to use for DNS queries
-     * @return new resolver instance
-     */
-    static DomainNameResolver domainNameResolver(List<InetAddress> servers, EventLoopGroup eventLoop) {
-        return new Resolver(
-        DnsClient.dnsClient(eventLoop), prepareServers(servers), buildDnsCache(), eventLoop, false);
-    }
-
-    private static List<InetSocketAddress> prepareServers(List<InetAddress> serverList) {
-        return serverList.stream()
-                         .map(ip -> new InetSocketAddress(ip, DNS_UDP_PORT))
-                         .toList();
-    }
-
-    private static ConcurrentHashMap<DomainName, Promise<DomainAddress>> buildDnsCache() {
-        var cache = new ConcurrentHashMap<DomainName, Promise<DomainAddress>>();
-        var resolvedLocalHost = domainAddress(
-        domainName("localhost"), InetAddress.getLoopbackAddress(), Duration.ofSeconds(0));
-        cache.put(resolvedLocalHost.name(), success(resolvedLocalHost));
-        return cache;
-    }
-}
-
-record Resolver(
- DnsClient client,
- List<InetSocketAddress> serverList,
- ConcurrentHashMap<DomainName, Promise<DomainAddress>> cache,
- EventLoopGroup eventLoop,
- boolean ownsEventLoop) implements DomainNameResolver {
-    private static final Logger log = LoggerFactory.getLogger(DomainNameResolver.class);
-
-    @Override
-    public Promise<DomainAddress> resolveCached(DomainName name) {
-        return option(cache.get(name))
-               .or(() -> resolved(UNKNOWN_DOMAIN));
-    }
-
-    @Override
-    public Promise<DomainAddress> resolve(DomainName name) {
-        var promise = cache.computeIfAbsent(name, this::fireRequest);
-        // Do not cache failed requests and observe TTL for successful ones
-        return promise.onFailureRun(() -> cache.remove(name))
-                      .onSuccess(domainAddress -> {
-                                     log.debug("TTL for {} is {}",
-                                               domainAddress.name(),
-                                               domainAddress.ttl());
-                                     var ttl = TimeSpan.fromDuration(domainAddress.ttl());
-                                     promise.async(ttl,
-                                                   _ -> log.debug("TTL expired, removing {} from cache",
-                                                                  cache.remove(domainAddress.name())));
-                                 });
-    }
-
-    private Promise<DomainAddress> fireRequest(DomainName domainName) {
-        return Promise.any(UNKNOWN_DOMAIN,
-                           serverList.stream()
-                                     .map(server -> client.resolve(domainName, server))
-                                     .toList());
-    }
-
-    @Override
-    public Promise<Unit> close() {
-        if (!ownsEventLoop) {
-            return client.close();
-        }
-        return client.close()
-                     .flatMap(_ -> Promise.promise(promise -> eventLoop.shutdownGracefully()
-                                                                       .addListener(_ -> promise.succeed(Unit.unit()))));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/InetUtils.java b/common/src/main/java/org/pragmatica/net/dns/InetUtils.java
deleted file mode 100644
index 82d3cba3..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/InetUtils.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.pragmatica.lang.Cause;
-import org.pragmatica.lang.Result;
-import org.pragmatica.net.dns.ResolverErrors.InvalidIpAddress;
-import org.pragmatica.net.dns.ResolverErrors.UnknownError;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-
-/**
- * Utilities for working with InetAddress.
- */
-public final class InetUtils {
-    public static Result<InetAddress> forBytes(byte[] address) {
-        return Result.lift(InetUtils::exceptionMapper, () -> InetAddress.getByAddress(address));
-    }
-
-    static Cause exceptionMapper(Throwable throwable) {
-        if (throwable instanceof UnknownHostException) {
-            return new InvalidIpAddress(throwable.getMessage());
-        }
-        return new UnknownError(throwable.getMessage());
-    }
-
-    private InetUtils() {}
-}
diff --git a/common/src/main/java/org/pragmatica/net/dns/README.md b/common/src/main/java/org/pragmatica/net/dns/README.md
deleted file mode 100644
index 1ec63b63..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/README.md
+++ /dev/null
@@ -1,178 +0,0 @@
-# Asynchronous DNS Resolver
-
-Fully asynchronous DNS resolver with TTL-based caching using Netty UDP.
-
-## Features
-
-- **Fully async**: Returns `Promise<DomainAddress>` - no blocking
-- **TTL caching**: Automatic cache eviction based on DNS TTL
-- **Multi-server failover**: Queries multiple DNS servers, returns first success
-- **Event loop sharing**: Can use own event loop or share with existing server
-- **Zero background threads**: Cache eviction uses promise mechanics
-
-## Quick Start
-
-```java
-import org.pragmatica.net.dns.DomainNameResolver;
-import java.net.InetAddress;
-import java.util.List;
-
-// Create resolver with public DNS servers
-var resolver = DomainNameResolver.domainNameResolver(List.of(
-    InetAddress.getByName("8.8.8.8"),      // Google DNS
-    InetAddress.getByName("1.1.1.1")       // Cloudflare DNS
-));
-
-// Resolve domain
-resolver.resolve("example.com")
-        .onSuccess(address -> {
-            System.out.println("IP: " + address.ip());
-            System.out.println("TTL: " + address.ttl());
-        })
-        .onFailure(cause -> {
-            System.err.println("Resolution failed: " + cause.message());
-        });
-
-// Don't forget to close when done
-resolver.close();
-```
-
-## API
-
-### DomainNameResolver
-
-Main entry point for DNS resolution.
-
-```java
-public interface DomainNameResolver extends AsyncCloseable {
-    // Resolve domain, using cache if available
-    Promise<DomainAddress> resolve(String name);
-    Promise<DomainAddress> resolve(DomainName name);
-
-    // Get cached result without triggering resolution
-    Promise<DomainAddress> resolveCached(String name);
-    Promise<DomainAddress> resolveCached(DomainName name);
-
-    // Factory methods
-    static DomainNameResolver domainNameResolver(List<InetAddress> servers);
-    static DomainNameResolver domainNameResolver(List<InetAddress> servers, EventLoopGroup eventLoop);
-}
-```
-
-### Factory Methods
-
-**Own event loop** (auto-cleanup on close):
-```java
-var resolver = DomainNameResolver.domainNameResolver(List.of(
-    InetAddress.getByName("8.8.8.8")
-));
-// Event loop created internally, shut down when resolver.close() called
-```
-
-**Shared event loop** (no cleanup, caller manages lifecycle):
-```java
-var sharedEventLoop = new MultiThreadIoEventLoopGroup(1, NioIoHandler.newFactory());
-var resolver = DomainNameResolver.domainNameResolver(servers, sharedEventLoop);
-// Event loop NOT shut down when resolver.close() called
-// Useful when sharing with Server or other components
-```
-
-### DomainAddress
-
-Resolved address with metadata.
-
-```java
-public interface DomainAddress {
-    DomainName name();    // Original domain name
-    InetAddress ip();     // Resolved IP address
-    Duration ttl();       // Time-to-live from DNS response
-}
-```
-
-### Error Handling
-
-All errors are typed via `ResolverErrors`:
-
-```java
-public sealed interface ResolverErrors extends Cause {
-    record InvalidIpAddress(String message) implements ResolverErrors {}
-    record ServerError(String message) implements ResolverErrors {}
-    record RequestTimeout(String message) implements ResolverErrors {}
-    record UnknownError(String message) implements ResolverErrors {}
-    record UnknownDomain(String message) implements ResolverErrors {}
-}
-```
-
-## Caching Behavior
-
-The resolver implements intelligent caching:
-
-1. **Successful resolutions** are cached until TTL expires
-2. **Failed resolutions** are NOT cached (allows retry)
-3. **TTL eviction** uses `promise.async(ttl, ...)` - no background threads
-4. **localhost** is pre-cached with infinite TTL
-
-```java
-// First call: DNS query sent
-resolver.resolve("example.com").await();
-
-// Second call: returns cached result (no network)
-resolver.resolve("example.com").await();
-
-// After TTL expires: DNS query sent again
-```
-
-## Multi-Server Failover
-
-When multiple DNS servers are configured:
-
-```java
-var resolver = DomainNameResolver.domainNameResolver(List.of(
-    InetAddress.getByName("8.8.8.8"),      // Primary
-    InetAddress.getByName("8.8.4.4"),      // Secondary
-    InetAddress.getByName("1.1.1.1")       // Tertiary
-));
-```
-
-- Queries are sent to ALL servers in parallel
-- First successful response wins (`Promise.any()`)
-- Response with shortest TTL is preferred (faster DNS change propagation)
-- If all fail, returns `UnknownDomain` error
-
-## Timeout Handling
-
-Each DNS query has a 10-second timeout. If no response is received:
-
-```java
-resolver.resolve("slow-dns.example.com")
-        .onFailure(cause -> {
-            // cause instanceof ResolverErrors.RequestTimeout
-        });
-```
-
-## Thread Safety
-
-- `DomainNameResolver` is fully thread-safe
-- Cache operations use `ConcurrentHashMap`
-- Safe for concurrent resolution from multiple threads
-
-## Dependencies
-
-- Netty (`netty-codec-dns`, `netty-transport`)
-- Pragmatica Lite Core (`Promise`, `Result`, `Cause`, `TimeSpan`)
-- SLF4J for logging
-
-## Integration with Server
-
-Share event loop between DNS resolver and TCP server:
-
-```java
-// Server creates event loops
-var server = Server.server(config, channelHandlers).await().unsafe();
-
-// DNS shares the worker group (access via reflection or expose getter)
-// Or create shared event loop externally:
-var sharedLoop = new MultiThreadIoEventLoopGroup(4, NioIoHandler.newFactory());
-var server = Server.serverWithEventLoop(config, channelHandlers, sharedLoop);
-var resolver = DomainNameResolver.domainNameResolver(dnsServers, sharedLoop);
-```
diff --git a/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java b/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
deleted file mode 100644
index 198e2c41..00000000
--- a/common/src/main/java/org/pragmatica/net/dns/ResolverErrors.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.pragmatica.lang.Cause;
-
-/**
- * DNS resolution errors.
- */
-public sealed interface ResolverErrors extends Cause {
-    record InvalidIpAddress(String message) implements ResolverErrors {}
-
-    record ServerError(String message) implements ResolverErrors {}
-
-    record RequestTimeout(String message) implements ResolverErrors {}
-
-    record UnknownError(String message) implements ResolverErrors {}
-
-    record UnknownDomain(String message) implements ResolverErrors {}
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java b/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
deleted file mode 100644
index a4d24a39..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/Deserializer.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package org.pragmatica.net.serialization;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-
-/// Basic deserialization interface
-public interface Deserializer {
-    default <T> T decode(byte[] bytes) {
-        var byteBuf = Unpooled.wrappedBuffer(bytes);
-        try{
-            return read(byteBuf);
-        } finally{
-            byteBuf.release();
-        }
-    }
-
-    <T> T read(ByteBuf byteBuf);
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/Serializer.java b/common/src/main/java/org/pragmatica/net/serialization/Serializer.java
deleted file mode 100644
index 17a48af7..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/Serializer.java
+++ /dev/null
@@ -1,19 +0,0 @@
-package org.pragmatica.net.serialization;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-
-/// Basic serialization interface
-public interface Serializer {
-    default <T> byte[] encode(T object) {
-        var byteBuf = Unpooled.buffer();
-        try{
-            write(byteBuf, object);
-            return byteBuf.array();
-        } finally{
-            byteBuf.release();
-        }
-    }
-
-    <T> void write(ByteBuf byteBuf, T object);
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java b/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
deleted file mode 100644
index 728119b3..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/ClassRegistrator.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package org.pragmatica.net.serialization.binary;
-
-import java.util.function.Consumer;
-
-public interface ClassRegistrator {
-    void registerClasses(Consumer<Class< ? >> consumer);
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
deleted file mode 100644
index 063e0d60..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryDeserializer.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package org.pragmatica.net.serialization.binary.fury;
-
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufInputStream;
-import org.apache.fury.ThreadSafeFury;
-import org.apache.fury.io.FuryInputStream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public interface FuryDeserializer extends Deserializer {
-    static FuryDeserializer furyDeserializer(ClassRegistrator... registrators) {
-        record furyDeserializer(ThreadSafeFury fury) implements FuryDeserializer {
-            private static final Logger log = LoggerFactory.getLogger(FuryDeserializer.class);
-
-            @SuppressWarnings("unchecked")
-            @Override
-            public <T> T read(ByteBuf byteBuf) {
-                try (var stream = new FuryInputStream(new ByteBufInputStream(byteBuf))) {
-                    return (T) fury()
-                              .deserialize(stream);
-                } catch (Exception e) {
-                    log.error("Error deserializing object", e);
-                    throw new RuntimeException(e);
-                }
-            }
-        }
-        return new furyDeserializer(FuryFactory.fury(registrators));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
deleted file mode 100644
index 5f8a26ea..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FuryFactory.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package org.pragmatica.net.serialization.binary.fury;
-
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import java.util.stream.Stream;
-
-import org.apache.fury.Fury;
-import org.apache.fury.ThreadSafeFury;
-import org.apache.fury.config.Language;
-
-public sealed interface FuryFactory {
-    static ThreadSafeFury fury(ClassRegistrator... registrators) {
-        int coreCount = Runtime.getRuntime()
-                               .availableProcessors();
-        var fury = Fury.builder()
-                       .withLanguage(Language.JAVA)
-                       .buildThreadSafeFuryPool(coreCount * 2, coreCount * 4);
-        Stream.of(registrators)
-              .forEach(registrator -> registrator.registerClasses(fury::register));
-        return fury;
-    }
-
-    @SuppressWarnings("unused")
-    record unused() implements FuryFactory {}
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
deleted file mode 100644
index 4329cc8c..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/fury/FurySerializer.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package org.pragmatica.net.serialization.binary.fury;
-
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufOutputStream;
-import org.apache.fury.ThreadSafeFury;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public interface FurySerializer extends Serializer {
-    static FurySerializer furySerializer(ClassRegistrator... registrators) {
-        record furySerializer(ThreadSafeFury fury) implements FurySerializer {
-            private static final Logger log = LoggerFactory.getLogger(FurySerializer.class);
-
-            @Override
-            public <T> void write(ByteBuf byteBuf, T object) {
-                try (var outputStream = new ByteBufOutputStream(byteBuf)) {
-                    fury()
-                    .serialize(outputStream, object);
-                } catch (Exception e) {
-                    log.error("Error serializing object", e);
-                    throw new RuntimeException(e);
-                }
-            }
-        }
-        return new furySerializer(FuryFactory.fury(registrators));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
deleted file mode 100644
index 982275c8..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoDeserializer.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package org.pragmatica.net.serialization.binary.kryo;
-
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.io.Input;
-import com.esotericsoftware.kryo.util.Pool;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufInputStream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public interface KryoDeserializer extends Deserializer {
-    static KryoDeserializer kryoDeserializer(ClassRegistrator... registrators) {
-        record kryoDeserializer(Pool<Kryo> pool) implements KryoDeserializer {
-            private static final Logger log = LoggerFactory.getLogger(KryoDeserializer.class);
-
-            @SuppressWarnings("unchecked")
-            @Override
-            public <T> T read(ByteBuf byteBuf) {
-                var kryo = pool.obtain();
-                try (var byteBufInputStream = new ByteBufInputStream(byteBuf);
-                var input = new Input(byteBufInputStream)) {
-                    return (T) kryo.readClassAndObject(input);
-                } catch (Exception e) {
-                    log.error("Error deserializing object", e);
-                    throw new RuntimeException(e);
-                } finally{
-                    pool()
-                    .free(kryo);
-                }
-            }
-        }
-        return new kryoDeserializer(KryoPoolFactory.kryoPool(registrators));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
deleted file mode 100644
index 272b57a4..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoPoolFactory.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package org.pragmatica.net.serialization.binary.kryo;
-
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import java.util.stream.Stream;
-
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.util.Pool;
-
-public sealed interface KryoPoolFactory {
-    static Pool<Kryo> kryoPool(ClassRegistrator... registrators) {
-        return new Pool<>(true,
-                          false,
-                          Runtime.getRuntime()
-                                 .availableProcessors() * 2) {
-            @Override
-            protected Kryo create() {
-                var kryo = new Kryo();
-                Stream.of(registrators)
-                      .forEach(registrator -> registrator.registerClasses(kryo::register));
-                return kryo;
-            }
-        };
-    }
-
-    @SuppressWarnings("unused")
-    record unused() implements KryoPoolFactory {}
-}
diff --git a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java b/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
deleted file mode 100644
index dc14daa7..00000000
--- a/common/src/main/java/org/pragmatica/net/serialization/binary/kryo/KryoSerializer.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package org.pragmatica.net.serialization.binary.kryo;
-
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-
-import com.esotericsoftware.kryo.Kryo;
-import com.esotericsoftware.kryo.io.Output;
-import com.esotericsoftware.kryo.util.Pool;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufOutputStream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-public interface KryoSerializer extends Serializer {
-    static KryoSerializer kryoSerializer(ClassRegistrator... registrators) {
-        record kryoSerializer(Pool<Kryo> pool) implements KryoSerializer {
-            private static final Logger log = LoggerFactory.getLogger(KryoSerializer.class);
-
-            @Override
-            public <T> void write(ByteBuf byteBuf, T object) {
-                var kryo = pool.obtain();
-                try (var byteBufOutputStream = new ByteBufOutputStream(byteBuf);
-                var output = new Output(byteBufOutputStream)) {
-                    kryo.writeClassAndObject(output, object);
-                } catch (Exception e) {
-                    log.error("Error serializing object", e);
-                    throw new RuntimeException(e);
-                } finally{
-                    pool.free(kryo);
-                }
-            }
-        }
-        return new kryoSerializer(KryoPoolFactory.kryoPool(registrators));
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java b/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
deleted file mode 100644
index a97e28b1..00000000
--- a/common/src/main/java/org/pragmatica/utility/HierarchyScanner.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package org.pragmatica.utility;
-
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.stream.Stream;
-
-public sealed interface HierarchyScanner {
-    @SuppressWarnings("unchecked")
-    static <T> Set<Class< ? extends T>> concreteSubtypes(Class<T> type) {
-        var result = new HashSet<Class< ? extends T>>();
-        if (!type.isInterface()) {
-            result.add(type);
-            return result;
-        }
-        var queue = new LinkedBlockingQueue<Class< ? >>();
-        queue.offer(type);
-        while (!queue.isEmpty()) {
-            var currentInterface = queue.poll();
-            if (!currentInterface.isSealed()) {
-                continue;
-            }
-            for (var clazz : currentInterface.getPermittedSubclasses()) {
-                if (clazz.isInterface()) {
-                    queue.offer(clazz);
-                }else {
-                    result.add((Class< ? extends T>) clazz);
-                }
-            }
-        }
-        return result;
-    }
-
-    static <T> Set<Class< ? extends T>> walkUpTheTree(Collection<Class< ? extends T>> classes) {
-        var interfaces = new HashSet<Class< ? >>();
-        var collected = new HashSet<Class< ? extends T>>();
-        for (var clazz : classes) {
-            scanSingle(clazz, collected, interfaces);
-        }
-        return collected;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <T> void scanSingle(Class< ? extends T> clazz,
-                                       Set<Class< ? extends T>> result,
-                                       Set<Class< ? >> interfaces) {
-        var queue = new LinkedBlockingQueue<Class< ? >>();
-        if (clazz.isInterface()) {
-            if (interfaces.add(clazz)) {
-                queue.offer(clazz);
-            }
-        }else {
-            result.add(clazz);
-            Stream.of(clazz.getInterfaces())
-                  .forEach(e -> {
-                      if (interfaces.add(e)) {
-                      queue.offer(e);
-                  }
-                  });
-        }
-        while (!queue.isEmpty()) {
-            Class< ? > type = queue.poll();
-            Stream.of(clazz.getInterfaces())
-                  .forEach(e -> {
-                      if (interfaces.add(e)) {
-                      queue.offer(e);
-                  }
-                  });
-            concreteSubtypes(type)
-            .stream()
-            .map(cls -> (Class< ? extends T>) cls)
-            .forEach(result::add);
-        }
-    }
-
-    @SuppressWarnings("unused")
-    record unused() implements HierarchyScanner {}
-}
diff --git a/common/src/main/java/org/pragmatica/utility/RingBuffer.java b/common/src/main/java/org/pragmatica/utility/RingBuffer.java
deleted file mode 100644
index 4defefdb..00000000
--- a/common/src/main/java/org/pragmatica/utility/RingBuffer.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package org.pragmatica.utility;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Predicate;
-
-/**
- * Thread-safe ring buffer with fixed capacity.
- *
- * <p>Provides O(1) add operations and fixed memory footprint.
- * When the buffer is full, oldest elements are overwritten.
- *
- * @param <T> element type
- */
-public final class RingBuffer<T> {
-    private final Object[] buffer;
-    private final int capacity;
-    private final ReentrantLock lock = new ReentrantLock();
-    private int head;
-
-    // Next write position
-    private int size;
-
-    // Current number of elements
-    private RingBuffer(int capacity) {
-        if (capacity <= 0) {
-            throw new IllegalArgumentException("Capacity must be positive");
-        }
-        this.capacity = capacity;
-        this.buffer = new Object[capacity];
-        this.head = 0;
-        this.size = 0;
-    }
-
-    /**
-     * Create a new ring buffer with the specified capacity.
-     */
-    public static <T> RingBuffer<T> ringBuffer(int capacity) {
-        return new RingBuffer<>(capacity);
-    }
-
-    /**
-     * Add an element to the buffer. If full, overwrites the oldest element.
-     */
-    public void add(T element) {
-        lock.lock();
-        try{
-            buffer[head] = element;
-            head = (head + 1) % capacity;
-            if (size < capacity) {
-                size++ ;
-            }
-        } finally{
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Get all elements in order from oldest to newest.
-     */
-    public List<T> toList() {
-        lock.lock();
-        try{
-            var result = new ArrayList<T>(size);
-            if (size == 0) {
-                return result;
-            }
-            // Start from the oldest element
-            int start = (size < capacity)
-                        ? 0
-                        : head;
-            for (int i = 0; i < size; i++ ) {
-                int idx = (start + i) % capacity;
-                @SuppressWarnings("unchecked")
-                T element = (T) buffer[idx];
-                result.add(element);
-            }
-            return result;
-        } finally{
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Get all elements that match the predicate, in order from oldest to newest.
-     */
-    public List<T> filter(Predicate<T> predicate) {
-        lock.lock();
-        try{
-            var result = new ArrayList<T>();
-            if (size == 0) {
-                return result;
-            }
-            // Start from the oldest element
-            int start = (size < capacity)
-                        ? 0
-                        : head;
-            for (int i = 0; i < size; i++ ) {
-                int idx = (start + i) % capacity;
-                @SuppressWarnings("unchecked")
-                T element = (T) buffer[idx];
-                if (predicate.test(element)) {
-                    result.add(element);
-                }
-            }
-            return result;
-        } finally{
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Get the current number of elements.
-     */
-    public int size() {
-        lock.lock();
-        try{
-            return size;
-        } finally{
-            lock.unlock();
-        }
-    }
-
-    /**
-     * Check if the buffer is empty.
-     */
-    public boolean isEmpty() {
-        return size() == 0;
-    }
-
-    /**
-     * Get the maximum capacity.
-     */
-    public int capacity() {
-        return capacity;
-    }
-
-    /**
-     * Clear all elements.
-     */
-    public void clear() {
-        lock.lock();
-        try{
-            for (int i = 0; i < capacity; i++ ) {
-                buffer[i] = null;
-            }
-            head = 0;
-            size = 0;
-        } finally{
-            lock.unlock();
-        }
-    }
-}
diff --git a/common/src/main/java/org/pragmatica/utility/Sleep.java b/common/src/main/java/org/pragmatica/utility/Sleep.java
deleted file mode 100644
index 79cde753..00000000
--- a/common/src/main/java/org/pragmatica/utility/Sleep.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package org.pragmatica.utility;
-
-import org.pragmatica.lang.io.TimeSpan;
-
-public sealed interface Sleep {
-    static void sleep(TimeSpan span) {
-        try{
-            Thread.sleep(span.millis());
-        } catch (InterruptedException e) {
-            Thread.currentThread()
-                  .interrupt();
-        }
-    }
-
-    @SuppressWarnings("unused")
-    record unused() implements Sleep {}
-}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
deleted file mode 100644
index e6e9a183..00000000
--- a/common/src/test/java/org/pragmatica/net/dns/DomainAddressTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.junit.jupiter.api.Test;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.time.Duration;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.pragmatica.net.dns.DomainAddress.domainAddress;
-import static org.pragmatica.net.dns.DomainName.domainName;
-
-class DomainAddressTest {
-
-    @Test
-    void domainAddress_creates_instance_with_all_fields() throws UnknownHostException {
-        var name = domainName("example.com");
-        var ip = InetAddress.getByName("93.184.216.34");
-        var ttl = Duration.ofSeconds(300);
-
-        var address = domainAddress(name, ip, ttl);
-
-        assertThat(address.name()).isEqualTo(name);
-        assertThat(address.ip()).isEqualTo(ip);
-        assertThat(address.ttl()).isEqualTo(ttl);
-    }
-
-    @Test
-    void domainAddress_withDomain_creates_new_instance_with_different_name() throws UnknownHostException {
-        var originalName = domainName("example.com");
-        var newName = domainName("alias.example.com");
-        var ip = InetAddress.getByName("93.184.216.34");
-        var ttl = Duration.ofSeconds(300);
-
-        var original = domainAddress(originalName, ip, ttl);
-        var withNewDomain = original.withDomain(newName);
-
-        assertThat(withNewDomain.name()).isEqualTo(newName);
-        assertThat(withNewDomain.ip()).isEqualTo(ip);
-        assertThat(withNewDomain.ttl()).isEqualTo(ttl);
-        assertThat(original.name()).isEqualTo(originalName); // original unchanged
-    }
-
-    @Test
-    void domainAddress_supports_ipv4() throws UnknownHostException {
-        var ip = InetAddress.getByName("192.168.1.1");
-        var address = domainAddress(domainName("local"), ip, Duration.ofSeconds(60));
-
-        assertThat(address.ip().getHostAddress()).isEqualTo("192.168.1.1");
-    }
-
-    @Test
-    void domainAddress_supports_ipv6() throws UnknownHostException {
-        var ip = InetAddress.getByName("::1");
-        var address = domainAddress(domainName("localhost"), ip, Duration.ofSeconds(0));
-
-        assertThat(address.ip().getHostAddress()).isEqualTo("0:0:0:0:0:0:0:1");
-    }
-
-    @Test
-    void domainAddress_supports_zero_ttl() throws UnknownHostException {
-        var address = domainAddress(
-            domainName("no-cache.example.com"),
-            InetAddress.getByName("1.2.3.4"),
-            Duration.ZERO
-        );
-
-        assertThat(address.ttl()).isEqualTo(Duration.ZERO);
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
deleted file mode 100644
index df26c084..00000000
--- a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverIT.java
+++ /dev/null
@@ -1,154 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.time.Duration;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.pragmatica.net.dns.DomainNameResolver.domainNameResolver;
-
-/**
- * Integration tests for DNS resolution using real DNS servers.
- * <p>
- * These tests require network access and may be flaky if DNS servers are unreachable.
- * Enable by setting environment variable: DNS_INTEGRATION_TESTS=true
- */
-@EnabledIfEnvironmentVariable(named = "DNS_INTEGRATION_TESTS", matches = "true")
-class DomainNameResolverIT {
-
-    private DomainNameResolver resolver;
-
-    @BeforeEach
-    void setUp() throws UnknownHostException {
-        // Use well-known public DNS servers
-        resolver = domainNameResolver(List.of(
-            InetAddress.getByName("8.8.8.8"),      // Google
-            InetAddress.getByName("1.1.1.1")       // Cloudflare
-        ));
-    }
-
-    @AfterEach
-    void tearDown() {
-        if (resolver != null) {
-            resolver.close().await();
-        }
-    }
-
-    @Test
-    void resolves_well_known_domain() {
-        resolver.resolve("google.com")
-                .await()
-                .onFailureRun(Assertions::fail)
-                .onSuccess(address -> {
-                    assertThat(address.name().name()).isEqualTo("google.com");
-                    assertThat(address.ip()).isNotNull();
-                    assertThat(address.ttl()).isNotNull();
-                    System.out.println("Resolved google.com to " + address.ip() + " (TTL: " + address.ttl() + ")");
-                });
-    }
-
-    @Test
-    void resolves_domain_with_short_ttl() {
-        // ibm.com typically has shorter TTL for load balancing
-        resolver.resolve("ibm.com")
-                .await()
-                .onFailureRun(Assertions::fail)
-                .onSuccess(address -> {
-                    assertThat(address.name().name()).isEqualTo("ibm.com");
-                    assertThat(address.ip()).isNotNull();
-                    System.out.println("Resolved ibm.com to " + address.ip() + " (TTL: " + address.ttl() + ")");
-
-                    // IBM typically has TTL under 5 minutes
-                    assertThat(address.ttl()).isLessThan(Duration.ofMinutes(10));
-                });
-    }
-
-    @Test
-    void caches_resolution_and_respects_ttl() throws InterruptedException {
-        // First resolution
-        var firstResult = resolver.resolve("example.com").await();
-
-        firstResult.onFailureRun(Assertions::fail)
-                   .onSuccess(first -> {
-                       System.out.println("First resolution: " + first.ip() + " (TTL: " + first.ttl() + ")");
-
-                       // Cached resolution should return same result
-                       resolver.resolveCached("example.com")
-                               .await()
-                               .onFailureRun(Assertions::fail)
-                               .onSuccess(cached -> {
-                                   assertThat(cached.ip()).isEqualTo(first.ip());
-                               });
-                   });
-    }
-
-    @Test
-    void fails_for_nonexistent_domain() {
-        resolver.resolve("this-domain-definitely-does-not-exist-12345.invalid")
-                .await()
-                .onSuccessRun(() -> Assertions.fail("Should have failed for non-existent domain"))
-                .onFailure(cause -> {
-                    System.out.println("Expected failure for non-existent domain: " + cause.message());
-                    assertThat(cause).isNotNull();
-                });
-    }
-
-    @Test
-    void handles_multiple_concurrent_resolutions() {
-        var domains = List.of("google.com", "microsoft.com", "apple.com", "amazon.com");
-
-        var promises = domains.stream()
-                              .map(resolver::resolve)
-                              .toList();
-
-        for (int i = 0; i < promises.size(); i++) {
-            var domain = domains.get(i);
-            promises.get(i)
-                    .await()
-                    .onSuccess(address -> {
-                        System.out.println("Resolved " + domain + " to " + address.ip());
-                        assertThat(address.name().name()).isEqualTo(domain);
-                    })
-                    .onFailure(cause -> {
-                        System.out.println("Failed to resolve " + domain + ": " + cause.message());
-                    });
-        }
-    }
-
-    @Test
-    void ttl_cache_eviction_works() throws InterruptedException {
-        // Resolve a domain with short TTL
-        var result = resolver.resolve("ibm.com").await();
-
-        result.onSuccess(address -> {
-            var ttlSeconds = address.ttl().toSeconds();
-            System.out.println("ibm.com TTL: " + ttlSeconds + " seconds");
-
-            if (ttlSeconds > 0 && ttlSeconds < 30) {
-                // Wait for TTL to expire plus small buffer
-                try {
-                    System.out.println("Waiting " + (ttlSeconds + 2) + " seconds for TTL expiry...");
-                    Thread.sleep((ttlSeconds + 2) * 1000);
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    return;
-                }
-
-                // Cache should be evicted, resolveCached should fail
-                resolver.resolveCached("ibm.com")
-                        .await()
-                        .onSuccess(cached -> System.out.println("Still cached (may have been re-resolved): " + cached.ip()))
-                        .onFailure(cause -> System.out.println("Cache evicted as expected: " + cause.message()));
-            } else {
-                System.out.println("TTL too long for practical test, skipping eviction verification");
-            }
-        });
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
deleted file mode 100644
index 43eb2b50..00000000
--- a/common/src/test/java/org/pragmatica/net/dns/DomainNameResolverTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
-import java.net.InetAddress;
-import java.net.UnknownHostException;
-import java.time.Duration;
-import java.util.List;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.pragmatica.net.dns.DomainAddress.domainAddress;
-import static org.pragmatica.net.dns.DomainName.domainName;
-import static org.pragmatica.net.dns.DomainNameResolver.domainNameResolver;
-
-class DomainNameResolverTest {
-
-    @Test
-    void resolver_returns_localhost_from_cache() {
-        var resolver = domainNameResolver(List.of());
-
-        resolver.resolve("localhost")
-                .await()
-                .onFailureRun(Assertions::fail)
-                .onSuccess(address -> {
-                    assertThat(address.name().name()).isEqualTo("localhost");
-                    assertThat(address.ip().isLoopbackAddress()).isTrue();
-                });
-    }
-
-    @Test
-    void resolveCached_returns_unknown_for_uncached_domain() {
-        var resolver = domainNameResolver(List.of());
-
-        resolver.resolveCached("not-in-cache.example.com")
-                .await()
-                .onSuccessRun(Assertions::fail)
-                .onFailure(cause -> {
-                    assertThat(cause).isInstanceOf(ResolverErrors.UnknownDomain.class);
-                });
-    }
-
-    @Test
-    void resolver_caches_successful_resolution() throws UnknownHostException {
-        // Use a mock-like approach: create resolver, manually populate cache via resolve
-        var googleDns = InetAddress.getByName("8.8.8.8");
-        var resolver = domainNameResolver(List.of(googleDns));
-
-        // First resolution (will go to real DNS)
-        var firstResult = resolver.resolve("example.com").await();
-
-        if (firstResult.isSuccess()) {
-            // Second call should return cached result
-            resolver.resolveCached("example.com")
-                    .await()
-                    .onFailureRun(Assertions::fail)
-                    .onSuccess(cached -> {
-                        assertThat(cached.name().name()).isEqualTo("example.com");
-                    });
-        }
-        // If first resolution failed (no network), test is inconclusive but passes
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java b/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
deleted file mode 100644
index f00d350b..00000000
--- a/common/src/test/java/org/pragmatica/net/dns/DomainNameTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.pragmatica.net.dns.DomainName.domainName;
-
-class DomainNameTest {
-
-    @Test
-    void domainName_creates_instance_with_provided_name() {
-        var domain = domainName("example.com");
-
-        assertThat(domain.name()).isEqualTo("example.com");
-    }
-
-    @Test
-    void domainName_preserves_case() {
-        var domain = domainName("Example.COM");
-
-        assertThat(domain.name()).isEqualTo("Example.COM");
-    }
-
-    @Test
-    void domainName_equality_based_on_name() {
-        var domain1 = domainName("example.com");
-        var domain2 = domainName("example.com");
-        var domain3 = domainName("other.com");
-
-        assertThat(domain1).isEqualTo(domain2);
-        assertThat(domain1).isNotEqualTo(domain3);
-    }
-
-    @Test
-    void domainName_hashCode_consistent_with_equality() {
-        var domain1 = domainName("example.com");
-        var domain2 = domainName("example.com");
-
-        assertThat(domain1.hashCode()).isEqualTo(domain2.hashCode());
-    }
-}
diff --git a/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java b/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java
deleted file mode 100644
index 52c3c94b..00000000
--- a/common/src/test/java/org/pragmatica/net/dns/InetUtilsTest.java
+++ /dev/null
@@ -1,66 +0,0 @@
-package org.pragmatica.net.dns;
-
-import org.junit.jupiter.api.Assertions;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class InetUtilsTest {
-
-    @Test
-    void forBytes_parses_valid_ipv4_address() {
-        var bytes = new byte[]{(byte) 192, (byte) 168, 1, 1};
-
-        InetUtils.forBytes(bytes)
-                 .onFailureRun(Assertions::fail)
-                 .onSuccess(address -> {
-                     assertThat(address.getHostAddress()).isEqualTo("192.168.1.1");
-                 });
-    }
-
-    @Test
-    void forBytes_parses_valid_ipv6_address() {
-        // ::1 in bytes (16 bytes, all zeros except last byte)
-        var bytes = new byte[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
-
-        InetUtils.forBytes(bytes)
-                 .onFailureRun(Assertions::fail)
-                 .onSuccess(address -> {
-                     assertThat(address.getHostAddress()).isEqualTo("0:0:0:0:0:0:0:1");
-                 });
-    }
-
-    @Test
-    void forBytes_fails_for_invalid_length() {
-        // Neither 4 (IPv4) nor 16 (IPv6) bytes
-        var bytes = new byte[]{1, 2, 3};
-
-        InetUtils.forBytes(bytes)
-                 .onSuccessRun(Assertions::fail)
-                 .onFailure(cause -> {
-                     assertThat(cause).isInstanceOf(ResolverErrors.InvalidIpAddress.class);
-                 });
-    }
-
-    @Test
-    void forBytes_handles_all_zeros_ipv4() {
-        var bytes = new byte[]{0, 0, 0, 0};
-
-        InetUtils.forBytes(bytes)
-                 .onFailureRun(Assertions::fail)
-                 .onSuccess(address -> {
-                     assertThat(address.getHostAddress()).isEqualTo("0.0.0.0");
-                 });
-    }
-
-    @Test
-    void forBytes_handles_broadcast_address() {
-        var bytes = new byte[]{(byte) 255, (byte) 255, (byte) 255, (byte) 255};
-
-        InetUtils.forBytes(bytes)
-                 .onFailureRun(Assertions::fail)
-                 .onSuccess(address -> {
-                     assertThat(address.getHostAddress()).isEqualTo("255.255.255.255");
-                 });
-    }
-}
diff --git a/common/src/test/resources/tinylog.properties b/common/src/test/resources/tinylog.properties
deleted file mode 100644
index 9b7b424a..00000000
--- a/common/src/test/resources/tinylog.properties
+++ /dev/null
@@ -1,3 +0,0 @@
-writer=console
-writer.level=info
-writer.format={level} {date: HH:mm:ss.SSS} {class-name}::{method}:{line}: {message}.
\ No newline at end of file
diff --git a/examples/order-demo/pom.xml b/examples/order-demo/pom.xml
index 60d2823d..949b8c79 100644
--- a/examples/order-demo/pom.xml
+++ b/examples/order-demo/pom.xml
@@ -70,11 +70,6 @@
                 <artifactId>cluster</artifactId>
                 <version>${aether.version}</version>
             </dependency>
-            <dependency>
-                <groupId>org.pragmatica-lite.aether</groupId>
-                <artifactId>common</artifactId>
-                <version>${aether.version}</version>
-            </dependency>
             <dependency>
                 <groupId>org.pragmatica-lite.aether</groupId>
                 <artifactId>artifact-repo</artifactId>
diff --git a/forge/pom.xml b/forge/pom.xml
index df1ffe2f..10ccf1ba 100644
--- a/forge/pom.xml
+++ b/forge/pom.xml
@@ -24,10 +24,6 @@
             <groupId>org.pragmatica-lite.aether</groupId>
             <artifactId>cluster</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.pragmatica-lite.aether</groupId>
-            <artifactId>common</artifactId>
-        </dependency>
 
         <!-- Pragmatica -->
         <dependency>
diff --git a/infra-services/artifact-repo/pom.xml b/infra-services/artifact-repo/pom.xml
index d1628e63..8b584230 100644
--- a/infra-services/artifact-repo/pom.xml
+++ b/infra-services/artifact-repo/pom.xml
@@ -18,8 +18,8 @@
             <artifactId>core</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.pragmatica-lite.aether</groupId>
-            <artifactId>common</artifactId>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>dht</artifactId>
         </dependency>
         <dependency>
             <groupId>org.pragmatica-lite.aether</groupId>
diff --git a/mcp/pom.xml b/mcp/pom.xml
deleted file mode 100644
index 6bad65ad..00000000
--- a/mcp/pom.xml
+++ /dev/null
@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <parent>
-        <groupId>org.pragmatica-lite.aether</groupId>
-        <artifactId>aether</artifactId>
-        <version>0.6.1</version>
-    </parent>
-
-    <artifactId>mcp</artifactId>
-    <name>Aether MCP</name>
-    <description>Model Context Protocol integration for Aether</description>
-
-    <dependencies>
-        <!-- MCP dependencies will be added here -->
-    </dependencies>
-</project>
\ No newline at end of file
diff --git a/node/pom.xml b/node/pom.xml
index 5326e2be..2faa1e4d 100644
--- a/node/pom.xml
+++ b/node/pom.xml
@@ -18,10 +18,17 @@
             <artifactId>core</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.pragmatica-lite.aether</groupId>
-            <artifactId>common</artifactId>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>dht</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>utility</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>http-server</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.pragmatica-lite.aether</groupId>
             <artifactId>cluster</artifactId>
diff --git a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
index 0794512e..61a1e3cb 100644
--- a/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
+++ b/node/src/main/java/org/pragmatica/aether/api/ManagementServer.java
@@ -12,7 +12,7 @@
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.net.tcp.TlsConfig;
-import org.pragmatica.net.TlsContextFactory;
+import org.pragmatica.net.tcp.TlsContextFactory;
 
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
diff --git a/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java b/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
index 14bf3a75..9cfb88f8 100644
--- a/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
+++ b/node/src/main/java/org/pragmatica/aether/http/BindingResolver.java
@@ -3,7 +3,7 @@
 import org.pragmatica.aether.slice.routing.Binding;
 import org.pragmatica.aether.slice.routing.BindingSource;
 import org.pragmatica.lang.Result;
-import org.pragmatica.net.serialization.Deserializer;
+import org.pragmatica.serialization.Deserializer;
 
 import java.util.HashMap;
 import java.util.List;
diff --git a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
index f0695dee..c78f5663 100644
--- a/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
+++ b/node/src/main/java/org/pragmatica/aether/http/HttpRouter.java
@@ -5,9 +5,9 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.TlsContextFactory;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.net.tcp.TlsContextFactory;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.HashMap;
 
diff --git a/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java b/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
index d1255d4e..ea010694 100644
--- a/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
+++ b/node/src/main/java/org/pragmatica/aether/http/ResponseWriter.java
@@ -1,7 +1,7 @@
 package org.pragmatica.aether.http;
 
 import org.pragmatica.lang.Cause;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Serializer;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
diff --git a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
index 25cc430a..77a16186 100644
--- a/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
+++ b/node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java
@@ -16,8 +16,8 @@
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.messaging.MessageReceiver;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 import org.pragmatica.utility.KSUID;
 
 import java.util.concurrent.ConcurrentHashMap;
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index d9e8fa3b..c88bb438 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -49,16 +49,16 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.Unit;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.List;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import static org.pragmatica.net.serialization.binary.fury.FuryDeserializer.furyDeserializer;
-import static org.pragmatica.net.serialization.binary.fury.FurySerializer.furySerializer;
+import static org.pragmatica.serialization.fury.FuryDeserializer.furyDeserializer;
+import static org.pragmatica.serialization.fury.FurySerializer.furySerializer;
 
 /**
  * Main entry point for an Aether cluster node.
diff --git a/pom.xml b/pom.xml
index 6df4d197..40eab13a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 
     <groupId>org.pragmatica-lite.aether</groupId>
     <artifactId>aether</artifactId>
-    <version>0.6.4</version>
+    <version>0.6.3</version>
     <packaging>pom</packaging>
     <name>Pragmatica Aether Distributed Runtime</name>
     <description>AI-driven distributed runtime environment for Java applications</description>
@@ -25,7 +25,6 @@
         <module>slice</module>
         <module>example-slice</module>
         <module>cluster</module>
-        <module>common</module>
         <module>cli</module>
         <module>examples/order-demo</module>
         <module>forge</module>
@@ -87,6 +86,31 @@
                 <artifactId>tcp</artifactId>
                 <version>${pragmatica.version}</version>
             </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>http-server</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>dns</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>serialization-api</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>serialization-kryo</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
+            <dependency>
+                <groupId>org.pragmatica-lite</groupId>
+                <artifactId>serialization-fury</artifactId>
+                <version>${pragmatica.version}</version>
+            </dependency>
 
             <!-- Internal -->
             <dependency>
@@ -113,12 +137,6 @@
                 <version>${project.version}</version>
             </dependency>
 
-            <dependency>
-                <groupId>org.pragmatica-lite.aether</groupId>
-                <artifactId>common</artifactId>
-                <version>${project.version}</version>
-            </dependency>
-
             <dependency>
                 <groupId>org.pragmatica-lite.aether</groupId>
                 <artifactId>cluster</artifactId>
diff --git a/slice/pom.xml b/slice/pom.xml
index 16866919..24508b00 100644
--- a/slice/pom.xml
+++ b/slice/pom.xml
@@ -21,10 +21,13 @@
             <artifactId>toml</artifactId>
         </dependency>
         <dependency>
-            <groupId>org.pragmatica-lite.aether</groupId>
-            <artifactId>common</artifactId>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>serialization-kryo</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.pragmatica-lite</groupId>
+            <artifactId>serialization-fury</artifactId>
         </dependency>
-
         <dependency>
             <groupId>org.pragmatica-lite.aether</groupId>
             <artifactId>cluster</artifactId>
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java b/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
index 92be896c..e01c410d 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/SliceBridgeImpl.java
@@ -9,8 +9,8 @@
 import org.pragmatica.lang.Unit;
 import org.pragmatica.lang.type.TypeToken;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 import java.util.List;
 import java.util.Map;
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
index 7aa6bb18..62c032c1 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/FurySerializerFactoryProvider.java
@@ -2,12 +2,12 @@
 
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.type.TypeToken;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-import org.pragmatica.net.serialization.binary.fury.FuryDeserializer;
-import org.pragmatica.net.serialization.binary.fury.FuryFactory;
-import org.pragmatica.net.serialization.binary.fury.FurySerializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
+import org.pragmatica.serialization.ClassRegistrator;
+import org.pragmatica.serialization.fury.FuryDeserializer;
+import org.pragmatica.serialization.fury.FuryFactory;
+import org.pragmatica.serialization.fury.FurySerializer;
 
 import java.util.List;
 
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
index ec8f650a..9e400169 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/KryoSerializerFactoryProvider.java
@@ -3,12 +3,12 @@
 import org.pragmatica.lang.Promise;
 import org.pragmatica.lang.type.TypeToken;
 import org.pragmatica.lang.utils.Causes;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
-import org.pragmatica.net.serialization.binary.ClassRegistrator;
-import org.pragmatica.net.serialization.binary.kryo.KryoDeserializer;
-import org.pragmatica.net.serialization.binary.kryo.KryoPoolFactory;
-import org.pragmatica.net.serialization.binary.kryo.KryoSerializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
+import org.pragmatica.serialization.ClassRegistrator;
+import org.pragmatica.serialization.kryo.KryoDeserializer;
+import org.pragmatica.serialization.kryo.KryoPoolFactory;
+import org.pragmatica.serialization.kryo.KryoSerializer;
 
 import java.util.List;
 import java.util.concurrent.ArrayBlockingQueue;
diff --git a/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactory.java b/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactory.java
index 2a267f15..a9fa3403 100644
--- a/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactory.java
+++ b/slice/src/main/java/org/pragmatica/aether/slice/serialization/SerializerFactory.java
@@ -1,8 +1,8 @@
 package org.pragmatica.aether.slice.serialization;
 
 import org.pragmatica.lang.Promise;
-import org.pragmatica.net.serialization.Deserializer;
-import org.pragmatica.net.serialization.Serializer;
+import org.pragmatica.serialization.Deserializer;
+import org.pragmatica.serialization.Serializer;
 
 /**
  * Factory for obtaining serializer and deserializer instances for slice method invocations.

From 074de613ddc6a0a56f8b0ee6f4217950ac1b8510 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 01:06:30 +0100
Subject: [PATCH 20/26] fix: adapt to pragmatica-lite 0.9.2 API changes

---
 .../cluster/consensus/rabia/infrastructure/TestCluster.java  | 1 -
 .../java/org/pragmatica/cluster/net/local/LocalNetwork.java  | 5 -----
 2 files changed, 6 deletions(-)

diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
index 8fc74c25..9c2aa1ce 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
@@ -105,7 +105,6 @@ public void addNewNode(NodeId id) {
         var engine = new RabiaEngine<>(topologyManager, network, store, ProtocolConfig.testConfig());
 
         store.configure(router);
-        engine.configure(router);
 
         network.addNode(id, createHandler(engine));
         stores.put(id, store);
diff --git a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
index 362110f8..ecf256c6 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/net/local/LocalNetwork.java
@@ -252,9 +252,4 @@ public void clearAllFaults() {
             messageDelay = TimeSpan.timeSpan(0).millis();
         }
     }
-
-    @Override
-    public void configure(MessageRouter.MutableRouter router) {
-        // No configuration needed for test network
-    }
 }

From 39aee6bec1f33dc7a6cc6501fba7aad7f534b510 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 07:53:37 +0100
Subject: [PATCH 21/26] fix: remove @Override from configure() methods

---
 .../org/pragmatica/cluster/net/netty/NettyClusterNetwork.java    | 1 -
 .../main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java   | 1 -
 .../main/java/org/pragmatica/cluster/state/kvstore/KVStore.java  | 1 -
 3 files changed, 3 deletions(-)

diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index 152778f2..e2d3d2ac 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -91,7 +91,6 @@ public NettyClusterNetwork(TopologyManager topologyManager,
         schedulePing();
     }
 
-    @Override
     public void configure(MessageRouter.MutableRouter router) {
         router.addRoute(ConnectNode.class, this::connect);
         router.addRoute(DisconnectNode.class, this::disconnect);
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index 2ae23734..8f7a4364 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -88,7 +88,6 @@ public <R> Promise<List<R>> apply(List<C> commands) {
         router.addRoute(NodeDown.class, leaderManager::nodeDown);
         router.addRoute(QuorumStateNotification.class, leaderManager::watchQuorumState);
         network.configure(router);
-        consensus.configure(router);
         return new rabiaNode <>(config, router, stateMachine, network, topologyManager, consensus, leaderManager);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index 42f46a97..03f4c9cb 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -35,7 +35,6 @@ public KVStore(MessageRouter router, Serializer serializer, Deserializer deseria
         this.deserializer = deserializer;
     }
 
-    @Override
     public void configure(MutableRouter router) {
         router.addRoute(Find.class, this::find);
     }

From 411fd0c6d73944d93eac83514492094b32f3c36c Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 07:55:44 +0100
Subject: [PATCH 22/26] fix: remove @Override from test configure() methods

---
 .../metrics/deployment/DeploymentMetricsCollectorTest.java       | 1 -
 .../metrics/deployment/DeploymentMetricsSchedulerTest.java       | 1 -
 2 files changed, 2 deletions(-)

diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
index 62294d59..3e7908b6 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsCollectorTest.java
@@ -405,7 +405,6 @@ public Promise<Unit> stop() {
             return Promise.success(Unit.unit());
         }
 
-        @Override
         public void configure(MessageRouter.MutableRouter router) {}
     }
 }
diff --git a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
index e16b21ab..890397c7 100644
--- a/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
+++ b/node/src/test/java/org/pragmatica/aether/metrics/deployment/DeploymentMetricsSchedulerTest.java
@@ -256,7 +256,6 @@ public Promise<Unit> stop() {
             return Promise.success(Unit.unit());
         }
 
-        @Override
         public void configure(MessageRouter.MutableRouter router) {}
     }
 

From 42f5019c394ac2bdb968de0344a1f6b6b4ef0acf Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 07:58:10 +0100
Subject: [PATCH 23/26] fix: update order-demo versions to 0.6.3 and 0.9.2

---
 examples/order-demo/pom.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/order-demo/pom.xml b/examples/order-demo/pom.xml
index 949b8c79..dc694b21 100644
--- a/examples/order-demo/pom.xml
+++ b/examples/order-demo/pom.xml
@@ -27,7 +27,7 @@
     </modules>
 
     <properties>
-        <aether.version>0.6.2</aether.version>
+        <aether.version>0.6.3</aether.version>
     </properties>
 
     <dependencyManagement>
@@ -80,7 +80,7 @@
             <dependency>
                 <groupId>org.pragmatica-lite</groupId>
                 <artifactId>core</artifactId>
-                <version>0.8.4</version>
+                <version>0.9.2</version>
             </dependency>
         </dependencies>
     </dependencyManagement>

From 0f26ac98804ed6f0f23ceb4085c1e2256284c98e Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 08:01:08 +0100
Subject: [PATCH 24/26] fix: update order-demo to new Verify API

---
 .../org/pragmatica/aether/demo/order/domain/CustomerId.java     | 2 +-
 .../java/org/pragmatica/aether/demo/order/domain/OrderId.java   | 2 +-
 .../java/org/pragmatica/aether/demo/order/domain/ProductId.java | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
index 4fde7ecd..af239369 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/CustomerId.java
@@ -15,7 +15,7 @@ public record CustomerId(String value) {
 
     public static Result<CustomerId> customerId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
-                     .flatMap(Verify.ensureFn(INVALID_CUSTOMER_ID, Verify.Is::matches, CUSTOMER_ID_PATTERN))
+                     .flatMap(v -> Verify.ensure(v, Verify.Is::matches, CUSTOMER_ID_PATTERN, INVALID_CUSTOMER_ID))
                      .map(CustomerId::new);
     }
 }
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
index e651e5ef..f178bff4 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/OrderId.java
@@ -16,7 +16,7 @@ public record OrderId(String value) {
 
     public static Result<OrderId> orderId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
-                     .flatMap(Verify.ensureFn(INVALID_ORDER_ID, Verify.Is::matches, ORDER_ID_PATTERN))
+                     .flatMap(v -> Verify.ensure(v, Verify.Is::matches, ORDER_ID_PATTERN, INVALID_ORDER_ID))
                      .map(OrderId::new);
     }
 
diff --git a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
index ae6aeec6..979eccda 100644
--- a/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
+++ b/examples/order-demo/order-domain/src/main/java/org/pragmatica/aether/demo/order/domain/ProductId.java
@@ -15,7 +15,7 @@ public record ProductId(String value) {
 
     public static Result<ProductId> productId(String raw) {
         return Verify.ensure(raw, Verify.Is::notBlank)
-                     .flatMap(Verify.ensureFn(INVALID_PRODUCT_ID, Verify.Is::matches, PRODUCT_ID_PATTERN))
+                     .flatMap(v -> Verify.ensure(v, Verify.Is::matches, PRODUCT_ID_PATTERN, INVALID_PRODUCT_ID))
                      .map(ProductId::new);
     }
 }

From 8223199101bf1818de15e82e21cbee3b7d5d6bad Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 09:01:31 +0100
Subject: [PATCH 25/26] refactor: centralize route registration, remove
 configure() methods

---
 .../cluster/net/netty/NettyClusterNetwork.java       |  8 --------
 .../org/pragmatica/cluster/node/rabia/RabiaNode.java | 12 +++++++++++-
 .../pragmatica/cluster/state/kvstore/KVStore.java    |  5 -----
 .../consensus/rabia/infrastructure/TestCluster.java  |  2 +-
 .../java/org/pragmatica/aether/node/AetherNode.java  |  3 ++-
 5 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
index e2d3d2ac..e9b98c9b 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/net/netty/NettyClusterNetwork.java
@@ -91,14 +91,6 @@ public NettyClusterNetwork(TopologyManager topologyManager,
         schedulePing();
     }
 
-    public void configure(MessageRouter.MutableRouter router) {
-        router.addRoute(ConnectNode.class, this::connect);
-        router.addRoute(DisconnectNode.class, this::disconnect);
-        router.addRoute(ListConnectedNodes.class, this::listNodes);
-        router.addRoute(Ping.class, this::handlePing);
-        router.addRoute(Pong.class, this::handlePong);
-    }
-
     private void schedulePing() {
         SharedScheduler.schedule(this::pingNodes,
                                  topologyManager.pingInterval()
diff --git a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
index 8f7a4364..c73b74ef 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/node/rabia/RabiaNode.java
@@ -4,6 +4,11 @@
 import org.pragmatica.consensus.leader.LeaderManager;
 import org.pragmatica.consensus.net.ClusterNetwork;
 import org.pragmatica.consensus.net.NetworkManagementOperation;
+import org.pragmatica.consensus.net.NetworkManagementOperation.ConnectNode;
+import org.pragmatica.consensus.net.NetworkManagementOperation.DisconnectNode;
+import org.pragmatica.consensus.net.NetworkManagementOperation.ListConnectedNodes;
+import org.pragmatica.consensus.net.NetworkMessage.Ping;
+import org.pragmatica.consensus.net.NetworkMessage.Pong;
 import org.pragmatica.consensus.NodeId;
 import org.pragmatica.cluster.net.netty.NettyClusterNetwork;
 import org.pragmatica.cluster.node.ClusterNode;
@@ -87,7 +92,12 @@ public <R> Promise<List<R>> apply(List<C> commands) {
         router.addRoute(NodeRemoved.class, leaderManager::nodeRemoved);
         router.addRoute(NodeDown.class, leaderManager::nodeDown);
         router.addRoute(QuorumStateNotification.class, leaderManager::watchQuorumState);
-        network.configure(router);
+        // NetworkManagementOperation routes
+        router.addRoute(ConnectNode.class, network::connect);
+        router.addRoute(DisconnectNode.class, network::disconnect);
+        router.addRoute(ListConnectedNodes.class, network::listNodes);
+        router.addRoute(Ping.class, network::handlePing);
+        router.addRoute(Pong.class, network::handlePong);
         return new rabiaNode <>(config, router, stateMachine, network, topologyManager, consensus, leaderManager);
     }
 }
diff --git a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
index 03f4c9cb..b401e0c2 100644
--- a/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
+++ b/cluster/src/main/java/org/pragmatica/cluster/state/kvstore/KVStore.java
@@ -15,7 +15,6 @@
 import org.pragmatica.lang.utils.Causes;
 import org.pragmatica.messaging.MessageReceiver;
 import org.pragmatica.messaging.MessageRouter;
-import org.pragmatica.messaging.MessageRouter.MutableRouter;
 import org.pragmatica.serialization.Deserializer;
 import org.pragmatica.serialization.Serializer;
 
@@ -35,10 +34,6 @@ public KVStore(MessageRouter router, Serializer serializer, Deserializer deseria
         this.deserializer = deserializer;
     }
 
-    public void configure(MutableRouter router) {
-        router.addRoute(Find.class, this::find);
-    }
-
     @SuppressWarnings({"unchecked", "rawtypes"})
     @Override
     public Option<V> process(KVCommand command) {
diff --git a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
index 9c2aa1ce..4ff198f5 100644
--- a/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
+++ b/cluster/src/test/java/org/pragmatica/cluster/consensus/rabia/infrastructure/TestCluster.java
@@ -104,7 +104,7 @@ public void addNewNode(NodeId id) {
         var topologyManager = new TestTopologyManager(size, nodeInfo(id, nodeAddress("localhost", 8090)));
         var engine = new RabiaEngine<>(topologyManager, network, store, ProtocolConfig.testConfig());
 
-        store.configure(router);
+        router.addRoute(KVStoreLocalIO.Request.Find.class, store::find);
 
         network.addNode(id, createHandler(engine));
         stores.put(id, store);
diff --git a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
index c88bb438..d7d8ed76 100644
--- a/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
+++ b/node/src/main/java/org/pragmatica/aether/node/AetherNode.java
@@ -38,6 +38,7 @@
 import org.pragmatica.cluster.node.rabia.RabiaNode;
 import org.pragmatica.cluster.state.kvstore.KVCommand;
 import org.pragmatica.cluster.state.kvstore.KVStore;
+import org.pragmatica.cluster.state.kvstore.KVStoreLocalIO;
 import org.pragmatica.cluster.state.kvstore.KVStoreNotification;
 import org.pragmatica.consensus.topology.QuorumStateNotification;
 import org.pragmatica.consensus.topology.TopologyChangeNotification;
@@ -366,7 +367,7 @@ private static void configureRoutes(MessageRouter.MutableRouter router,
         router.addRoute(InvocationMessage.InvokeRequest.class, invocationHandler::onInvokeRequest);
         router.addRoute(InvocationMessage.InvokeResponse.class, sliceInvoker::onInvokeResponse);
         // KVStore local operations
-        kvStore.configure(router);
+        router.addRoute(KVStoreLocalIO.Request.Find.class, kvStore::find);
     }
 
     /**

From f294aad3464b64983644fa49df81eb5946277317 Mon Sep 17 00:00:00 2001
From: Sergiy Yevtushenko <sergiy.yevtushenko@gmail.com>
Date: Thu, 1 Jan 2026 09:46:58 +0100
Subject: [PATCH 26/26] docs: update documentation for 0.6.3 release

---
 CHANGELOG.md                  | 30 ++++++++++++++----------------
 CLAUDE.md                     | 10 ++++------
 docs/architecture-overview.md |  2 +-
 3 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 67d082e0..5dca41a2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,22 +5,7 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.6.4] - 2025-12-31
-
-### Changed
-- **Consensus module** - Migrated to use pragmatica-lite consensus module instead of local implementation
-- **Package reorganization** - All consensus-related imports moved from `org.pragmatica.cluster.*` to `org.pragmatica.consensus.*`
-- **TlsConfig/NodeAddress** - Now use pragmatica-lite `org.pragmatica.net.tcp` package
-- **ID generation** - Switched from ULID to KSUID for correlation IDs (pragmatica-lite alignment)
-
-### Removed
-- **Duplicate consensus files** - Removed 30+ files now provided by pragmatica-lite consensus module
-- **Duplicate network types** - Removed local TlsConfig and NodeAddress (use pragmatica-lite versions)
-
-### Fixed
-- **LeaderManagerTest** - Updated to use deterministic node IDs for reliable test ordering
-
-## [0.6.3] - 2025-12-29
+## [0.6.3] - 2026-01-01
 
 ### Added
 - **Production dashboard** - Real-time cluster monitoring at `/dashboard` with Alpine.js and Chart.js
@@ -34,6 +19,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Operational runbooks** - Added docs/runbooks/ with incident-response, scaling, troubleshooting, deployment guides
 
 ### Changed
+- **pragmatica-lite 0.9.2** - Updated to latest version with breaking API changes
+- **Consensus module** - Migrated to pragmatica-lite consensus module (removed 30+ duplicate files)
+- **Package reorganization** - All consensus-related imports moved from `org.pragmatica.cluster.*` to `org.pragmatica.consensus.*`
+- **TlsConfig/NodeAddress** - Now use pragmatica-lite `org.pragmatica.net.tcp` package
+- **ID generation** - Switched from ULID to KSUID for correlation IDs (pragmatica-lite alignment)
+- **Route registration** - Centralized in node assembly, removed `configure()` methods from components
+- **Verify API** - Updated to new `Verify.ensure(value, predicate, pattern, cause)` signature
 - **MetricsCollector** - Use RingBuffer instead of CopyOnWriteArrayList for historical metrics (7200 capacity)
 - **HttpMethod.fromString()** - Returns `Option<HttpMethod>` instead of throwing
 - **PathPattern.compile()** - Returns `Result<PathPattern>` instead of throwing
@@ -42,7 +34,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **DHTNode.create()** - Renamed to `DHTNode.dhtNode()` (JBCT naming convention)
 - **SliceRegistry.create()** - Renamed to `SliceRegistry.sliceRegistry()` (JBCT naming convention)
 
+### Removed
+- **common module** - Replaced by pragmatica-lite modules (messaging, dht, consensus, utility, net)
+- **Duplicate consensus files** - Now provided by pragmatica-lite consensus module
+- **Duplicate network types** - Now use pragmatica-lite versions
+
 ### Fixed
+- **LeaderManagerTest** - Updated to use deterministic node IDs for reliable test ordering
 
 ## [0.6.2] - 2025-12-29
 
diff --git a/CLAUDE.md b/CLAUDE.md
index 0e47ff53..cc60e468 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -24,13 +24,11 @@ intelligent orchestration, and seamless multi-cloud deployment without requiring
 - **slice-api/** - Slice interface definitions (`Slice`, `SliceMethod`, `SliceRoute`)
 - **slice/** - Slice management (`SliceStore`, `SliceState`, `Artifact` types, KV schema)
 - **node/** - Runtime node implementation (`NodeDeploymentManager`, `ManagementServer`, metrics, controller)
-- **cluster/** - Consensus layer (Rabia protocol, `KVStore`, `LeaderManager`)
-- **common/** - Shared utilities and types
+- **cluster/** - Cluster networking and KVStore (`NettyClusterNetwork`, `KVStore`)
 - **example-slice/** - Reference implementation (`StringProcessorSlice`)
 - **forge/** - Aether Forge: Standalone simulator CLI with visual dashboard for load/chaos testing
 - **examples/order-demo/** - Complete order domain demo (5 slices)
 - **cli/** - Command-line interface for cluster management
-- **mcp/** - (deprecated) Model Context Protocol - replaced by direct agent API
 
 ### Module Dependencies
 
@@ -97,7 +95,7 @@ Maven-style coordinates for slices:
 
 ```java
 // Format: groupId:artifactId:version[-qualifier]
-Artifact.artifact("org.pragmatica-lite.aether:example-slice:0.6.2")
+Artifact.artifact("org.pragmatica-lite.aether:example-slice:0.6.3")
 ```
 
 **Components**:
@@ -305,7 +303,7 @@ public record Email(String value) {
         return Verify.ensure(raw, Verify.Is::notNull)
             .map(String::trim)
             .map(String::toLowerCase)
-            .flatMap(Verify.ensureFn(INVALID_EMAIL, Verify.Is::matches, EMAIL_PATTERN))
+            .flatMap(v -> Verify.ensure(v, Verify.Is::matches, EMAIL_PATTERN, INVALID_EMAIL))
             .map(Email::new);
     }
 }
@@ -796,7 +794,7 @@ cd example-slice && mvn test
 - **SliceInvoker**: `node/src/main/java/org/pragmatica/aether/invoke/SliceInvoker.java`
 - **ManagementServer**: `node/src/main/java/org/pragmatica/aether/api/ManagementServer.java`
 - **AetherCli**: `cli/src/main/java/org/pragmatica/aether/cli/AetherCli.java`
-- **Rabia Consensus**: `cluster/src/main/java/org/pragmatica/cluster/consensus/rabia/`
+- **Rabia Consensus**: pragmatica-lite `consensus` module (`org.pragmatica.consensus.rabia`)
 - **KVStore**: `cluster/src/main/java/org/pragmatica/cluster/state/kvstore/`
 - **ForgeServer**: `forge/src/main/java/org/pragmatica/aether/forge/ForgeServer.java` - Aether Forge main entry
 - **ForgeCluster**: `forge/src/main/java/org/pragmatica/aether/forge/ForgeCluster.java` - Forge cluster management
diff --git a/docs/architecture-overview.md b/docs/architecture-overview.md
index d1a55ade..4eb22cc6 100644
--- a/docs/architecture-overview.md
+++ b/docs/architecture-overview.md
@@ -129,7 +129,7 @@ Responds to MetricsPing with MetricsPong every 1 second via MessageRouter.
 ### ClusterEventBus
 
 **Status**: ⚡ Integrated (via MessageRouter)
-**Location**: Events flow through `common/` MessageRouter
+**Location**: Events flow through pragmatica-lite MessageRouter
 **Runs On**: All nodes
 
 Distributes cluster events to interested components: