@topgunbuild/server 0.6.0 → 0.7.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ import { createServer as createHttpServer } from "http";
 import { createServer as createHttpsServer } from "https";
 import { readFileSync as readFileSync2 } from "fs";
 import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket3 } from "ws";
-import { HLC as HLC2, LWWMap as LWWMap3, ORMap as ORMap2, serialize as serialize4, deserialize, MessageSchema, WriteConcern as WriteConcern2, ConsistencyLevel as ConsistencyLevel2, DEFAULT_REPLICATION_CONFIG as DEFAULT_REPLICATION_CONFIG2, IndexedLWWMap as IndexedLWWMap2, IndexedORMap as IndexedORMap2 } from "@topgunbuild/core";
+import { HLC as HLC2, LWWMap as LWWMap3, ORMap as ORMap2, serialize as serialize4, deserialize, MessageSchema, WriteConcern as WriteConcern2, ConsistencyLevel as ConsistencyLevel3, DEFAULT_REPLICATION_CONFIG as DEFAULT_REPLICATION_CONFIG2, IndexedLWWMap as IndexedLWWMap2, IndexedORMap as IndexedORMap2 } from "@topgunbuild/core";
 import * as jwt from "jsonwebtoken";
 import * as crypto from "crypto";
 
@@ -1126,6 +1126,47 @@ var ClusterManager = class extends EventEmitter2 {
   handleHeartbeat(senderId, _payload) {
     this.failureDetector.recordHeartbeat(senderId);
   }
+  /**
+   * Send current member list to a specific node (gossip protocol).
+   * Called when a new node joins to propagate cluster topology.
+   */
+  sendMemberList(targetNodeId) {
+    const members = [];
+    for (const [nodeId, member] of this.members) {
+      members.push({
+        nodeId,
+        host: member.host,
+        port: member.port
+      });
+    }
+    this.send(targetNodeId, "MEMBER_LIST", { members });
+    logger.debug({ targetNodeId, memberCount: members.length }, "Sent member list");
+  }
+  /**
+   * Broadcast member list to all connected nodes.
+   * Called when cluster membership changes.
+   */
+  broadcastMemberList() {
+    for (const [nodeId, member] of this.members) {
+      if (member.isSelf) continue;
+      if (member.socket && member.socket.readyState === WebSocket.OPEN) {
+        this.sendMemberList(nodeId);
+      }
+    }
+  }
+  /**
+   * Handle incoming member list from a peer (gossip protocol).
+   * Attempts to connect to unknown members.
+   */
+  handleMemberList(payload) {
+    for (const memberInfo of payload.members) {
+      if (memberInfo.nodeId === this.config.nodeId) continue;
+      if (this.members.has(memberInfo.nodeId)) continue;
+      const peerAddress = `${memberInfo.host}:${memberInfo.port}`;
+      logger.info({ nodeId: memberInfo.nodeId, peerAddress }, "Discovered new member via gossip");
+      this.connectToPeer(peerAddress);
+    }
+  }
   /**
    * Handle confirmed node failure.
    */
@@ -1264,6 +1305,9 @@ var ClusterManager = class extends EventEmitter2 {
           this.failureDetector.startMonitoring(remoteNodeId);
           this.startHeartbeat();
           this.emit("memberJoined", remoteNodeId);
+          this.broadcastMemberList();
+        } else if (msg.type === "MEMBER_LIST") {
+          this.handleMemberList(msg.payload);
         } else if (msg.type === "HEARTBEAT") {
           if (remoteNodeId) {
             this.handleHeartbeat(remoteNodeId, msg.payload);
@@ -6565,236 +6609,1436 @@ var ReplicationPipeline = class extends EventEmitter8 {
   }
 };
 
-// src/handlers/CounterHandler.ts
-import { PNCounterImpl } from "@topgunbuild/core";
-var CounterHandler = class {
-  // counterName -> Set<clientId>
-  constructor(nodeId = "server") {
-    this.nodeId = nodeId;
-    this.counters = /* @__PURE__ */ new Map();
-    this.subscriptions = /* @__PURE__ */ new Map();
+// src/cluster/PartitionReassigner.ts
+import { EventEmitter as EventEmitter9 } from "events";
+import { DEFAULT_BACKUP_COUNT as DEFAULT_BACKUP_COUNT2 } from "@topgunbuild/core";
+var DEFAULT_REASSIGNER_CONFIG = {
+  reassignmentDelayMs: 1e3,
+  maxConcurrentTransfers: 10,
+  autoPromoteBackups: true,
+  autoAssignNewBackups: true
+};
+var PartitionReassigner = class extends EventEmitter9 {
+  constructor(clusterManager, partitionService, config = {}) {
+    super();
+    this.failoverInProgress = false;
+    this.partitionsReassigned = 0;
+    this.pendingReassignments = /* @__PURE__ */ new Set();
+    this.clusterManager = clusterManager;
+    this.partitionService = partitionService;
+    this.config = { ...DEFAULT_REASSIGNER_CONFIG, ...config };
+    this.setupEventHandlers();
+  }
+  setupEventHandlers() {
+    this.clusterManager.on("nodeConfirmedFailed", (nodeId) => {
+      logger.warn({ nodeId }, "Node failure confirmed, initiating partition reassignment");
+      this.handleNodeFailure(nodeId);
+    });
+    this.clusterManager.on("memberLeft", (nodeId) => {
+      if (this.currentFailedNode !== nodeId) {
+        logger.info({ nodeId }, "Member left cluster, checking partition reassignment");
+        this.handleNodeDeparture(nodeId);
+      }
+    });
   }
   /**
-   * Get or create a counter by name.
+   * Handle a node failure - initiates failover process
    */
-  getOrCreateCounter(name) {
-    let counter = this.counters.get(name);
-    if (!counter) {
-      counter = new PNCounterImpl({ nodeId: this.nodeId });
-      this.counters.set(name, counter);
-      logger.debug({ name }, "Created new counter");
+  handleNodeFailure(failedNodeId) {
+    if (this.failoverInProgress && this.currentFailedNode === failedNodeId) {
+      logger.debug({ failedNodeId }, "Failover already in progress for this node");
+      return;
     }
-    return counter;
+    if (this.reassignmentTimer) {
+      clearTimeout(this.reassignmentTimer);
+    }
+    this.reassignmentTimer = setTimeout(() => {
+      this.executeFailover(failedNodeId);
+    }, this.config.reassignmentDelayMs);
   }
   /**
-   * Handle COUNTER_REQUEST - client wants initial state.
-   * @returns Response message to send back to client
+   * Handle a graceful node departure
    */
-  handleCounterRequest(clientId, name) {
-    const counter = this.getOrCreateCounter(name);
-    this.subscribe(clientId, name);
-    const state = counter.getState();
-    logger.debug({ clientId, name, value: counter.get() }, "Counter request handled");
-    return {
-      type: "COUNTER_RESPONSE",
-      payload: {
-        name,
-        state: this.stateToObject(state)
-      }
-    };
+  handleNodeDeparture(nodeId) {
+    const orphanedPartitions = this.findOrphanedPartitions(nodeId);
+    if (orphanedPartitions.length > 0) {
+      logger.warn({ nodeId, count: orphanedPartitions.length }, "Found orphaned partitions after departure");
+      this.executeFailover(nodeId);
+    }
   }
   /**
-   * Handle COUNTER_SYNC - client sends their state to merge.
-   * @returns Merged state and list of clients to broadcast to
+   * Execute the failover process for a failed node
    */
-  handleCounterSync(clientId, name, stateObj) {
-    const counter = this.getOrCreateCounter(name);
-    const incomingState = this.objectToState(stateObj);
-    counter.merge(incomingState);
-    const mergedState = counter.getState();
-    const mergedStateObj = this.stateToObject(mergedState);
-    logger.debug(
-      { clientId, name, value: counter.get() },
-      "Counter sync handled"
-    );
-    this.subscribe(clientId, name);
-    const subscribers = this.subscriptions.get(name) || /* @__PURE__ */ new Set();
-    const broadcastTo = Array.from(subscribers).filter((id) => id !== clientId);
-    return {
-      // Response to the sending client
-      response: {
-        type: "COUNTER_UPDATE",
-        payload: {
-          name,
-          state: mergedStateObj
-        }
-      },
-      // Broadcast to other clients
-      broadcastTo,
-      broadcastMessage: {
-        type: "COUNTER_UPDATE",
-        payload: {
-          name,
-          state: mergedStateObj
-        }
+  async executeFailover(failedNodeId) {
+    this.failoverInProgress = true;
+    this.currentFailedNode = failedNodeId;
+    this.reassignmentStartTime = Date.now();
+    this.partitionsReassigned = 0;
+    this.pendingReassignments.clear();
+    logger.info({ failedNodeId }, "Starting partition failover");
+    try {
+      const orphanedPartitions = this.findOrphanedPartitions(failedNodeId);
+      if (orphanedPartitions.length === 0) {
+        logger.info({ failedNodeId }, "No partitions to reassign");
+        this.completeFailover();
+        return;
       }
-    };
+      logger.info({
+        failedNodeId,
+        partitionCount: orphanedPartitions.length
+      }, "Reassigning partitions from failed node");
+      for (const partitionId of orphanedPartitions) {
+        this.pendingReassignments.add(partitionId);
+      }
+      const changes = [];
+      for (const partitionId of orphanedPartitions) {
+        const change = await this.reassignPartition(partitionId, failedNodeId);
+        if (change) {
+          changes.push(change);
+          this.partitionsReassigned++;
+        }
+        this.pendingReassignments.delete(partitionId);
+      }
+      if (changes.length > 0) {
+        this.emit("partitionsReassigned", {
+          failedNodeId,
+          changes,
+          partitionMap: this.partitionService.getPartitionMap()
+        });
+      }
+      this.completeFailover();
+    } catch (error) {
+      logger.error({ failedNodeId, error }, "Failover failed");
+      this.emit("failoverError", { failedNodeId, error });
+      this.completeFailover();
+    }
   }
   /**
-   * Subscribe a client to counter updates.
+   * Find all partitions that need reassignment
    */
-  subscribe(clientId, counterName) {
-    if (!this.subscriptions.has(counterName)) {
-      this.subscriptions.set(counterName, /* @__PURE__ */ new Set());
+  findOrphanedPartitions(failedNodeId) {
+    const orphaned = [];
+    const partitionMap = this.partitionService.getPartitionMap();
+    for (const partition of partitionMap.partitions) {
+      if (partition.ownerNodeId === failedNodeId) {
+        orphaned.push(partition.partitionId);
+      }
     }
-    this.subscriptions.get(counterName).add(clientId);
-    logger.debug({ clientId, counterName }, "Client subscribed to counter");
+    return orphaned;
   }
   /**
-   * Unsubscribe a client from counter updates.
+   * Reassign a single partition
    */
-  unsubscribe(clientId, counterName) {
-    const subs = this.subscriptions.get(counterName);
-    if (subs) {
-      subs.delete(clientId);
-      if (subs.size === 0) {
-        this.subscriptions.delete(counterName);
+  async reassignPartition(partitionId, failedNodeId) {
+    const currentBackups = this.partitionService.getBackups(partitionId);
+    const aliveMembers = this.clusterManager.getMembers().filter((m) => m !== failedNodeId);
+    if (aliveMembers.length === 0) {
+      logger.error({ partitionId }, "No alive members to reassign partition to");
+      return null;
+    }
+    let newOwner = null;
+    if (this.config.autoPromoteBackups) {
+      for (const backup of currentBackups) {
+        if (aliveMembers.includes(backup)) {
+          newOwner = backup;
+          break;
+        }
       }
     }
+    if (!newOwner) {
+      const ownerIndex = partitionId % aliveMembers.length;
+      newOwner = aliveMembers.sort()[ownerIndex];
+    }
+    this.partitionService.setOwner(partitionId, newOwner);
+    logger.info({
+      partitionId,
+      previousOwner: failedNodeId,
+      newOwner
+    }, "Partition owner promoted");
+    this.emit("reassignment", {
+      type: "backup-promoted",
+      partitionId,
+      previousOwner: failedNodeId,
+      newOwner
+    });
+    if (this.config.autoAssignNewBackups) {
+      const newBackups = this.selectBackups(partitionId, newOwner, aliveMembers);
+    }
+    return {
+      partitionId,
+      previousOwner: failedNodeId,
+      newOwner,
+      reason: "FAILOVER"
+    };
   }
   /**
-   * Unsubscribe a client from all counters (e.g., on disconnect).
+   * Select backup nodes for a partition
    */
-  unsubscribeAll(clientId) {
-    for (const [counterName, subs] of this.subscriptions) {
-      subs.delete(clientId);
-      if (subs.size === 0) {
-        this.subscriptions.delete(counterName);
-      }
+  selectBackups(partitionId, owner, aliveMembers) {
+    const backups = [];
+    const sortedMembers = aliveMembers.filter((m) => m !== owner).sort();
+    const startIndex = partitionId % sortedMembers.length;
+    for (let i = 0; i < Math.min(DEFAULT_BACKUP_COUNT2, sortedMembers.length); i++) {
+      const backupIndex = (startIndex + i) % sortedMembers.length;
+      backups.push(sortedMembers[backupIndex]);
     }
-    logger.debug({ clientId }, "Client unsubscribed from all counters");
+    return backups;
   }
   /**
-   * Get current counter value (for monitoring/debugging).
+   * Complete the failover process
    */
-  getCounterValue(name) {
-    const counter = this.counters.get(name);
-    return counter ? counter.get() : 0;
+  completeFailover() {
+    const duration = this.reassignmentStartTime ? Date.now() - this.reassignmentStartTime : 0;
+    logger.info({
+      failedNodeId: this.currentFailedNode,
+      partitionsReassigned: this.partitionsReassigned,
+      durationMs: duration
+    }, "Failover completed");
+    this.emit("failoverComplete", {
+      failedNodeId: this.currentFailedNode,
+      partitionsReassigned: this.partitionsReassigned,
+      durationMs: duration
+    });
+    this.failoverInProgress = false;
+    this.currentFailedNode = void 0;
+    this.reassignmentStartTime = void 0;
+    this.pendingReassignments.clear();
   }
   /**
-   * Get all counter names.
+   * Get current failover status
    */
-  getCounterNames() {
-    return Array.from(this.counters.keys());
+  getStatus() {
+    return {
+      inProgress: this.failoverInProgress,
+      failedNodeId: this.currentFailedNode,
+      partitionsReassigned: this.partitionsReassigned,
+      partitionsPending: this.pendingReassignments.size,
+      startedAt: this.reassignmentStartTime,
+      completedAt: this.failoverInProgress ? void 0 : Date.now()
+    };
   }
   /**
-   * Get number of subscribers for a counter.
+   * Check if failover is in progress
    */
-  getSubscriberCount(name) {
-    return this.subscriptions.get(name)?.size || 0;
+  isFailoverInProgress() {
+    return this.failoverInProgress;
   }
   /**
-   * Convert Map-based state to plain object for serialization.
+   * Force immediate reassignment (for testing/manual intervention)
    */
-  stateToObject(state) {
-    return {
-      p: Object.fromEntries(state.positive),
-      n: Object.fromEntries(state.negative)
-    };
+  forceReassignment(failedNodeId) {
+    if (this.reassignmentTimer) {
+      clearTimeout(this.reassignmentTimer);
+    }
+    this.executeFailover(failedNodeId);
   }
   /**
-   * Convert plain object to Map-based state.
+   * Stop any pending reassignment
    */
-  objectToState(obj) {
-    return {
-      positive: new Map(Object.entries(obj.p || {})),
-      negative: new Map(Object.entries(obj.n || {}))
-    };
+  stop() {
+    if (this.reassignmentTimer) {
+      clearTimeout(this.reassignmentTimer);
+      this.reassignmentTimer = void 0;
+    }
+    this.failoverInProgress = false;
+    this.pendingReassignments.clear();
   }
 };
 
-// src/handlers/EntryProcessorHandler.ts
-import {
-  EntryProcessorDefSchema
-} from "@topgunbuild/core";
-
-// src/ProcessorSandbox.ts
-import {
-  validateProcessorCode
-} from "@topgunbuild/core";
-var ivm = null;
-try {
-  ivm = __require("isolated-vm");
-} catch {
-  const isProduction = process.env.NODE_ENV === "production";
-  if (isProduction) {
-    logger.error(
-      "SECURITY WARNING: isolated-vm not available in production! Entry processors will run in less secure fallback mode. Install isolated-vm for production environments: pnpm add isolated-vm"
-    );
-  } else {
-    logger.warn("isolated-vm not available, falling back to less secure VM");
-  }
-}
-var DEFAULT_SANDBOX_CONFIG = {
-  memoryLimitMb: 8,
-  timeoutMs: 100,
-  maxCachedIsolates: 100,
-  strictValidation: true
+// src/cluster/ReadReplicaHandler.ts
+import { EventEmitter as EventEmitter10 } from "events";
+import { ConsistencyLevel as ConsistencyLevel2 } from "@topgunbuild/core";
+var DEFAULT_READ_REPLICA_CONFIG = {
+  defaultConsistency: ConsistencyLevel2.STRONG,
+  maxStalenessMs: 5e3,
+  preferLocalReplica: true,
+  loadBalancing: "latency-based"
 };
-var ProcessorSandbox = class {
-  constructor(config = {}) {
-    this.isolateCache = /* @__PURE__ */ new Map();
-    this.scriptCache = /* @__PURE__ */ new Map();
-    this.fallbackScriptCache = /* @__PURE__ */ new Map();
-    this.disposed = false;
-    this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
+var ReadReplicaHandler = class extends EventEmitter10 {
+  constructor(partitionService, clusterManager, nodeId, lagTracker, config = {}) {
+    super();
+    // Round-robin counters for load balancing
+    this.roundRobinCounters = /* @__PURE__ */ new Map();
+    this.partitionService = partitionService;
+    this.clusterManager = clusterManager;
+    this.nodeId = nodeId;
+    this.lagTracker = lagTracker;
+    this.config = { ...DEFAULT_READ_REPLICA_CONFIG, ...config };
   }
   /**
-   * Execute an entry processor in the sandbox.
-   *
-   * @param processor The processor definition (name, code, args)
-   * @param value The current value for the key (or undefined)
-   * @param key The key being processed
-   * @returns Result containing success status, result, and new value
+   * Determine if a read request can be served locally
    */
-  async execute(processor, value, key) {
-    if (this.disposed) {
-      return {
-        success: false,
-        error: "Sandbox has been disposed"
-      };
+  canServeLocally(request) {
+    const consistency = request.options?.consistency ?? this.config.defaultConsistency;
+    if (consistency === ConsistencyLevel2.STRONG) {
+      return this.partitionService.isLocalOwner(request.key);
     }
-    if (this.config.strictValidation) {
-      const validation = validateProcessorCode(processor.code);
-      if (!validation.valid) {
-        return {
-          success: false,
-          error: validation.error
-        };
+    return this.partitionService.isRelated(request.key);
+  }
+  /**
+   * Determine which node should handle the read
+   */
+  selectReadNode(request) {
+    const key = request.key;
+    const consistency = request.options?.consistency ?? this.config.defaultConsistency;
+    const partitionId = this.partitionService.getPartitionId(key);
+    const distribution = this.partitionService.getDistribution(key);
+    if (consistency === ConsistencyLevel2.STRONG) {
+      if (!this.isNodeAlive(distribution.owner)) {
+        if (request.options?.allowStale) {
+          return this.selectAliveBackup(distribution.backups);
+        }
+        return null;
       }
+      return distribution.owner;
     }
-    if (ivm) {
-      return this.executeInIsolate(processor, value, key);
-    } else {
-      return this.executeInFallback(processor, value, key);
+    const allReplicas = [distribution.owner, ...distribution.backups];
+    const aliveReplicas = allReplicas.filter((n) => this.isNodeAlive(n));
+    if (aliveReplicas.length === 0) {
+      return null;
+    }
+    if (request.options?.maxStaleness) {
+      const withinStaleness = aliveReplicas.filter(
+        (n) => this.getNodeStaleness(n) <= (request.options?.maxStaleness ?? Infinity)
+      );
+      if (withinStaleness.length > 0) {
+        return this.selectByStrategy(withinStaleness, partitionId);
+      }
+      if (this.isNodeAlive(distribution.owner)) {
+        return distribution.owner;
+      }
     }
+    if (this.config.preferLocalReplica && aliveReplicas.includes(this.nodeId)) {
+      return this.nodeId;
+    }
+    return this.selectByStrategy(aliveReplicas, partitionId);
   }
   /**
-   * Execute processor in isolated-vm (secure production mode).
+   * Select replica using configured load balancing strategy
    */
-  async executeInIsolate(processor, value, key) {
-    if (!ivm) {
-      return { success: false, error: "isolated-vm not available" };
+  selectByStrategy(replicas, partitionId) {
+    if (replicas.length === 0) {
+      throw new Error("No replicas available");
     }
-    const isolate = this.getOrCreateIsolate(processor.name);
-    try {
-      const context = await isolate.createContext();
-      const jail = context.global;
-      await jail.set("global", jail.derefInto());
-      await context.eval(`
-        var value = ${JSON.stringify(value)};
-        var key = ${JSON.stringify(key)};
-        var args = ${JSON.stringify(processor.args)};
+    if (replicas.length === 1) {
+      return replicas[0];
+    }
+    switch (this.config.loadBalancing) {
+      case "round-robin":
+        return this.selectRoundRobin(replicas, partitionId);
+      case "latency-based":
+        return this.selectByLatency(replicas);
+      case "least-connections":
+        return this.selectRoundRobin(replicas, partitionId);
+      default:
+        return replicas[0];
+    }
+  }
+  /**
+   * Round-robin selection
+   */
+  selectRoundRobin(replicas, partitionId) {
+    const counter = this.roundRobinCounters.get(partitionId) ?? 0;
+    const selected = replicas[counter % replicas.length];
+    this.roundRobinCounters.set(partitionId, counter + 1);
+    return selected;
+  }
+  /**
+   * Latency-based selection using lag tracker
+   */
+  selectByLatency(replicas) {
+    if (!this.lagTracker) {
+      return replicas[0];
+    }
+    let bestNode = replicas[0];
+    let bestLatency = Infinity;
+    for (const nodeId of replicas) {
+      const lag = this.lagTracker.getLag(nodeId);
+      if (lag && lag.current < bestLatency) {
+        bestLatency = lag.current;
+        bestNode = nodeId;
+      }
+    }
+    return bestNode;
+  }
+  /**
+   * Get estimated staleness for a node in ms
+   */
+  getNodeStaleness(nodeId) {
+    if (nodeId === this.partitionService.getOwner("")) {
+      return 0;
+    }
+    if (this.lagTracker) {
+      const lag = this.lagTracker.getLag(nodeId);
+      return lag?.current ?? 0;
+    }
+    return 0;
+  }
+  /**
+   * Check if a node is alive in the cluster
+   */
+  isNodeAlive(nodeId) {
+    const members = this.clusterManager.getMembers();
+    return members.includes(nodeId);
+  }
+  /**
+   * Select first alive backup from list
+   */
+  selectAliveBackup(backups) {
+    for (const backup of backups) {
+      if (this.isNodeAlive(backup)) {
+        return backup;
+      }
+    }
+    return null;
+  }
+  /**
+   * Create read response metadata
+   */
+  createReadMetadata(key, options) {
+    const consistency = options?.consistency ?? this.config.defaultConsistency;
+    const isOwner = this.partitionService.isLocalOwner(key);
+    return {
+      source: this.nodeId,
+      isOwner,
+      consistency
+    };
+  }
+  /**
+   * Check if local node should forward read to owner
+   */
+  shouldForwardRead(request) {
+    const consistency = request.options?.consistency ?? this.config.defaultConsistency;
+    if (consistency === ConsistencyLevel2.STRONG) {
+      return !this.partitionService.isLocalOwner(request.key);
+    }
+    if (!this.partitionService.isRelated(request.key)) {
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get metrics for monitoring
+   */
+  getMetrics() {
+    return {
+      defaultConsistency: this.config.defaultConsistency,
+      preferLocalReplica: this.config.preferLocalReplica,
+      loadBalancing: this.config.loadBalancing,
+      roundRobinPartitions: this.roundRobinCounters.size
+    };
+  }
+};
+
+// src/cluster/MerkleTreeManager.ts
+import { EventEmitter as EventEmitter11 } from "events";
+import { MerkleTree, hashString as hashString2 } from "@topgunbuild/core";
+var DEFAULT_MERKLE_TREE_CONFIG = {
+  treeDepth: 3,
+  autoUpdate: true,
+  lazyInit: true
+};
+var MerkleTreeManager = class extends EventEmitter11 {
+  constructor(nodeId, config = {}) {
+    super();
+    this.trees = /* @__PURE__ */ new Map();
+    this.keyCounts = /* @__PURE__ */ new Map();
+    this.lastUpdated = /* @__PURE__ */ new Map();
+    this.nodeId = nodeId;
+    this.config = { ...DEFAULT_MERKLE_TREE_CONFIG, ...config };
+  }
+  /**
+   * Get or create a Merkle tree for a partition
+   */
+  getTree(partitionId) {
+    let tree = this.trees.get(partitionId);
+    if (!tree) {
+      tree = new MerkleTree(/* @__PURE__ */ new Map(), this.config.treeDepth);
+      this.trees.set(partitionId, tree);
+      this.keyCounts.set(partitionId, 0);
+      this.lastUpdated.set(partitionId, Date.now());
+    }
+    return tree;
+  }
+  /**
+   * Build tree for a partition from existing data
+   */
+  buildTree(partitionId, records) {
+    const tree = new MerkleTree(records, this.config.treeDepth);
+    this.trees.set(partitionId, tree);
+    this.keyCounts.set(partitionId, records.size);
+    this.lastUpdated.set(partitionId, Date.now());
+    logger.debug({
+      partitionId,
+      keyCount: records.size,
+      rootHash: tree.getRootHash()
+    }, "Built Merkle tree for partition");
+  }
+  /**
+   * Incrementally update tree when a record changes
+   */
+  updateRecord(partitionId, key, record) {
+    if (!this.config.autoUpdate) return;
+    const tree = this.getTree(partitionId);
+    const previousKeyCount = this.keyCounts.get(partitionId) ?? 0;
+    const existingBuckets = tree.getBuckets("");
+    const wasNewKey = Object.keys(existingBuckets).length === 0 || !tree.getKeysInBucket(this.getKeyPath(key)).includes(key);
+    tree.update(key, record);
+    if (wasNewKey) {
+      this.keyCounts.set(partitionId, previousKeyCount + 1);
+    }
+    this.lastUpdated.set(partitionId, Date.now());
+    this.emit("treeUpdated", {
+      partitionId,
+      key,
+      rootHash: tree.getRootHash()
+    });
+  }
+  /**
+   * Remove a key from the tree (e.g., after GC)
+   */
+  removeRecord(partitionId, key) {
+    const tree = this.trees.get(partitionId);
+    if (!tree) return;
+    tree.remove(key);
+    const currentCount = this.keyCounts.get(partitionId) ?? 0;
+    if (currentCount > 0) {
+      this.keyCounts.set(partitionId, currentCount - 1);
+    }
+    this.lastUpdated.set(partitionId, Date.now());
+    this.emit("treeUpdated", {
+      partitionId,
+      key,
+      rootHash: tree.getRootHash()
+    });
+  }
+  /**
+   * Get the path prefix for a key in the Merkle tree
+   */
+  getKeyPath(key) {
+    const hash = hashString2(key).toString(16).padStart(8, "0");
+    return hash.slice(0, this.config.treeDepth);
+  }
+  /**
+   * Get root hash for a partition
+   */
+  getRootHash(partitionId) {
+    const tree = this.trees.get(partitionId);
+    return tree?.getRootHash() ?? 0;
+  }
+  /**
+   * Compare local tree with remote root hash
+   */
+  compareWithRemote(partitionId, remoteRoot) {
+    const tree = this.getTree(partitionId);
+    const localRoot = tree.getRootHash();
+    return {
+      partitionId,
+      localRoot,
+      remoteRoot,
+      needsSync: localRoot !== remoteRoot,
+      differingBuckets: localRoot !== remoteRoot ? this.findDifferingBuckets(tree, remoteRoot) : []
+    };
+  }
+  /**
+   * Find buckets that differ between local and remote tree
+   * Note: This is a simplified version - full implementation would
+   * need to exchange bucket hashes with the remote node
+   */
+  findDifferingBuckets(tree, _remoteRoot) {
+    const buckets = [];
+    this.collectLeafBuckets(tree, "", buckets);
+    return buckets;
+  }
+  /**
+   * Recursively collect all leaf bucket paths
+   */
+  collectLeafBuckets(tree, path, result) {
+    if (path.length >= this.config.treeDepth) {
+      const keys = tree.getKeysInBucket(path);
+      if (keys.length > 0) {
+        result.push(path);
+      }
+      return;
+    }
+    const buckets = tree.getBuckets(path);
+    for (const char of Object.keys(buckets)) {
+      this.collectLeafBuckets(tree, path + char, result);
+    }
+  }
+  /**
+   * Get bucket hashes for a partition at a given path
+   */
+  getBuckets(partitionId, path) {
+    const tree = this.trees.get(partitionId);
+    return tree?.getBuckets(path) ?? {};
+  }
+  /**
+   * Get keys in a specific bucket
+   */
+  getKeysInBucket(partitionId, path) {
+    const tree = this.trees.get(partitionId);
+    return tree?.getKeysInBucket(path) ?? [];
+  }
+  /**
+   * Get all keys across all buckets for a partition
+   */
+  getAllKeys(partitionId) {
+    const tree = this.trees.get(partitionId);
+    if (!tree) return [];
+    const keys = [];
+    this.collectAllKeys(tree, "", keys);
+    return keys;
+  }
+  /**
+   * Recursively collect all keys from the tree
+   */
+  collectAllKeys(tree, path, result) {
+    if (path.length >= this.config.treeDepth) {
+      const keys = tree.getKeysInBucket(path);
+      result.push(...keys);
+      return;
+    }
+    const buckets = tree.getBuckets(path);
+    for (const char of Object.keys(buckets)) {
+      this.collectAllKeys(tree, path + char, result);
+    }
+  }
+  /**
+   * Get info about all managed partitions
+   */
+  getPartitionInfos() {
+    const infos = [];
+    for (const [partitionId, tree] of this.trees) {
+      infos.push({
+        partitionId,
+        rootHash: tree.getRootHash(),
+        keyCount: this.keyCounts.get(partitionId) ?? 0,
+        lastUpdated: this.lastUpdated.get(partitionId) ?? 0
+      });
+    }
+    return infos;
+  }
+  /**
+   * Get info for a specific partition
+   */
+  getPartitionInfo(partitionId) {
+    const tree = this.trees.get(partitionId);
+    if (!tree) return null;
+    return {
+      partitionId,
+      rootHash: tree.getRootHash(),
+      keyCount: this.keyCounts.get(partitionId) ?? 0,
+      lastUpdated: this.lastUpdated.get(partitionId) ?? 0
+    };
+  }
+  /**
+   * Clear tree for a partition (e.g., after migration)
+   */
+  clearPartition(partitionId) {
+    this.trees.delete(partitionId);
+    this.keyCounts.delete(partitionId);
+    this.lastUpdated.delete(partitionId);
+  }
+  /**
+   * Clear all trees
+   */
+  clearAll() {
+    this.trees.clear();
+    this.keyCounts.clear();
+    this.lastUpdated.clear();
+  }
+  /**
+   * Get metrics for monitoring
+   */
+  getMetrics() {
+    let totalKeys = 0;
+    for (const count of this.keyCounts.values()) {
+      totalKeys += count;
+    }
+    return {
+      totalPartitions: this.trees.size,
+      totalKeys,
+      averageKeysPerPartition: this.trees.size > 0 ? totalKeys / this.trees.size : 0
+    };
+  }
+  /**
+   * Serialize tree state for network transfer
+   */
+  serializeTree(partitionId) {
+    const tree = this.trees.get(partitionId);
+    if (!tree) return null;
+    const buckets = {};
+    for (let depth = 0; depth < this.config.treeDepth; depth++) {
+      this.collectBucketsAtDepth(tree, "", depth, buckets);
+    }
+    return {
+      rootHash: tree.getRootHash(),
+      buckets
+    };
+  }
+  collectBucketsAtDepth(tree, path, targetDepth, result) {
+    if (path.length === targetDepth) {
+      const buckets2 = tree.getBuckets(path);
+      if (Object.keys(buckets2).length > 0) {
+        result[path] = buckets2;
+      }
+      return;
+    }
+    if (path.length > targetDepth) return;
+    const buckets = tree.getBuckets(path);
+    for (const char of Object.keys(buckets)) {
+      this.collectBucketsAtDepth(tree, path + char, targetDepth, result);
+    }
+  }
+};
+
+// src/cluster/RepairScheduler.ts
+import { EventEmitter as EventEmitter12 } from "events";
+import { PARTITION_COUNT as PARTITION_COUNT4 } from "@topgunbuild/core";
+var DEFAULT_REPAIR_CONFIG = {
+  enabled: true,
+  scanIntervalMs: 36e5,
+  // 1 hour
+  repairBatchSize: 1e3,
+  maxConcurrentRepairs: 2,
+  throttleMs: 100,
+  prioritizeRecent: true,
+  requestTimeoutMs: 5e3
+};
+var RepairScheduler = class extends EventEmitter12 {
+  constructor(merkleManager, clusterManager, partitionService, nodeId, config = {}) {
+    super();
+    this.repairQueue = [];
+    this.activeRepairs = /* @__PURE__ */ new Set();
+    this.started = false;
+    // Pending network requests
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    // Metrics
+    this.metrics = {
+      scansCompleted: 0,
+      repairsExecuted: 0,
+      keysRepaired: 0,
+      errorsEncountered: 0,
+      averageRepairDurationMs: 0
+    };
+    this.merkleManager = merkleManager;
+    this.clusterManager = clusterManager;
+    this.partitionService = partitionService;
+    this.nodeId = nodeId;
+    this.config = { ...DEFAULT_REPAIR_CONFIG, ...config };
+    this.setupNetworkHandlers();
+  }
+  /**
+   * Set data access callbacks
+   */
+  setDataAccessors(getRecord, setRecord) {
+    this.getRecord = getRecord;
+    this.setRecord = setRecord;
+  }
+  /**
+   * Setup network message handlers
+   */
+  setupNetworkHandlers() {
+    this.clusterManager.on("message", (msg) => {
+      this.handleClusterMessage(msg);
+    });
+  }
+  /**
+   * Handle incoming cluster messages
+   */
+  handleClusterMessage(msg) {
+    switch (msg.type) {
+      case "CLUSTER_MERKLE_ROOT_REQ":
+        this.handleMerkleRootReq(msg);
+        break;
+      case "CLUSTER_MERKLE_ROOT_RESP":
+        this.handleResponse(msg);
+        break;
+      case "CLUSTER_MERKLE_BUCKETS_REQ":
+        this.handleMerkleBucketsReq(msg);
+        break;
+      case "CLUSTER_MERKLE_BUCKETS_RESP":
+        this.handleResponse(msg);
+        break;
+      case "CLUSTER_MERKLE_KEYS_REQ":
+        this.handleMerkleKeysReq(msg);
+        break;
+      case "CLUSTER_MERKLE_KEYS_RESP":
+        this.handleResponse(msg);
+        break;
+      case "CLUSTER_REPAIR_DATA_REQ":
+        this.handleRepairDataReq(msg);
+        break;
+      case "CLUSTER_REPAIR_DATA_RESP":
+        this.handleResponse(msg);
+        break;
+    }
+  }
+  // === Request Handlers (Passive) ===
+  handleMerkleRootReq(msg) {
+    const { requestId, partitionId } = msg.payload;
+    const rootHash = this.merkleManager.getRootHash(partitionId);
+    this.clusterManager.send(msg.senderId, "CLUSTER_MERKLE_ROOT_RESP", {
+      requestId,
+      partitionId,
+      rootHash
+    });
+  }
+  handleMerkleBucketsReq(msg) {
+    const { requestId, partitionId } = msg.payload;
+    const tree = this.merkleManager.serializeTree(partitionId);
+    this.clusterManager.send(msg.senderId, "CLUSTER_MERKLE_BUCKETS_RESP", {
+      requestId,
+      partitionId,
+      buckets: tree?.buckets || {}
+    });
+  }
+  handleMerkleKeysReq(msg) {
+    const { requestId, partitionId, path } = msg.payload;
+    const keys = this.merkleManager.getKeysInBucket(partitionId, path);
+    this.clusterManager.send(msg.senderId, "CLUSTER_MERKLE_KEYS_RESP", {
+      requestId,
+      partitionId,
+      path,
+      keys
+    });
+  }
+  handleRepairDataReq(msg) {
+    const { requestId, key } = msg.payload;
+    if (!this.getRecord) return;
+    const record = this.getRecord(key);
+    this.clusterManager.send(msg.senderId, "CLUSTER_REPAIR_DATA_RESP", {
+      requestId,
+      key,
+      record
+    });
+  }
+  handleResponse(msg) {
+    const { requestId } = msg.payload;
+    const pending = this.pendingRequests.get(requestId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pendingRequests.delete(requestId);
+      pending.resolve(msg.payload);
+    }
+  }
+  // === Lifecycle Methods ===
+  /**
+   * Start the repair scheduler
+   */
+  start() {
+    if (this.started || !this.config.enabled) return;
+    this.started = true;
+    logger.info({ config: this.config }, "Starting RepairScheduler");
+    this.scanTimer = setInterval(() => {
+      this.scheduleFullScan();
+    }, this.config.scanIntervalMs);
+    this.processTimer = setInterval(() => {
+      this.processRepairQueue();
+    }, 1e3);
+    setTimeout(() => {
+      this.scheduleFullScan();
+    }, 6e4);
+  }
+  /**
+   * Stop the repair scheduler
+   */
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.scanTimer) {
+      clearInterval(this.scanTimer);
+      this.scanTimer = void 0;
+    }
+    if (this.processTimer) {
+      clearInterval(this.processTimer);
+      this.processTimer = void 0;
+    }
+    this.repairQueue = [];
+    this.activeRepairs.clear();
+    for (const [id, req] of this.pendingRequests) {
+      clearTimeout(req.timer);
+      req.reject(new Error("Scheduler stopped"));
+    }
+    this.pendingRequests.clear();
+    logger.info("RepairScheduler stopped");
+  }
+  /**
+   * Schedule a full scan of all owned partitions
+   */
+  scheduleFullScan() {
+    const ownedPartitions = this.getOwnedPartitions();
+    const replicas = this.getReplicaPartitions();
+    const allPartitions = [.../* @__PURE__ */ new Set([...ownedPartitions, ...replicas])];
+    logger.info({
+      ownedCount: ownedPartitions.length,
+      replicaCount: replicas.length,
+      totalPartitions: allPartitions.length
+    }, "Scheduling full anti-entropy scan");
+    for (const partitionId of allPartitions) {
+      this.schedulePartitionRepair(partitionId);
+    }
+    this.metrics.scansCompleted++;
+    this.metrics.lastScanTime = Date.now();
+  }
+  /**
+   * Schedule repair for a specific partition
+   */
+  schedulePartitionRepair(partitionId, priority = "normal") {
+    const backups = this.partitionService.getBackups(partitionId);
+    const owner = this.partitionService.getPartitionOwner(partitionId);
+    const replicas = this.nodeId === owner ? backups : owner ? [owner] : [];
+    for (const replicaNodeId of replicas) {
+      const exists = this.repairQueue.some(
+        (t) => t.partitionId === partitionId && t.replicaNodeId === replicaNodeId
+      );
+      if (exists) continue;
+      this.repairQueue.push({
+        partitionId,
+        replicaNodeId,
+        priority,
+        scheduledAt: Date.now()
+      });
+    }
+    this.sortRepairQueue();
+  }
+  /**
+   * Sort repair queue by priority
+   */
+  sortRepairQueue() {
+    const priorityOrder = { high: 0, normal: 1, low: 2 };
+    this.repairQueue.sort((a, b) => {
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority];
+      if (priorityDiff !== 0) return priorityDiff;
+      if (this.config.prioritizeRecent) {
+        const infoA = this.merkleManager.getPartitionInfo(a.partitionId);
+        const infoB = this.merkleManager.getPartitionInfo(b.partitionId);
+        if (infoA && infoB) {
+          return infoB.lastUpdated - infoA.lastUpdated;
+        }
+      }
+      return a.scheduledAt - b.scheduledAt;
+    });
+  }
+  /**
+   * Process the repair queue
+   */
+  async processRepairQueue() {
+    if (this.activeRepairs.size >= this.config.maxConcurrentRepairs) {
+      return;
+    }
+    const task = this.repairQueue.shift();
+    if (!task) return;
+    if (this.activeRepairs.has(task.partitionId)) {
+      return;
+    }
+    if (!this.clusterManager.getMembers().includes(task.replicaNodeId)) {
+      logger.debug({ task }, "Skipping repair - replica not available");
+      return;
+    }
+    this.activeRepairs.add(task.partitionId);
+    try {
+      const result = await this.executeRepair(task);
+      this.emit("repairComplete", result);
+      if (result.success) {
+        this.metrics.repairsExecuted++;
+        this.metrics.keysRepaired += result.keysRepaired;
+        this.updateAverageRepairDuration(result.durationMs);
+      } else {
+        this.metrics.errorsEncountered++;
+      }
+    } catch (error) {
+      logger.error({ task, error }, "Repair failed");
+      this.metrics.errorsEncountered++;
+    } finally {
+      this.activeRepairs.delete(task.partitionId);
+    }
+  }
+  /**
+   * Execute repair for a partition-replica pair
+   */
+  async executeRepair(task) {
+    const startTime = Date.now();
+    let keysScanned = 0;
+    let keysRepaired = 0;
+    try {
+      const localRoot = this.merkleManager.getRootHash(task.partitionId);
+      const remoteRoot = await this.requestRemoteMerkleRoot(task.replicaNodeId, task.partitionId);
+      if (localRoot === remoteRoot) {
+        logger.debug({
+          partitionId: task.partitionId,
+          replicaNodeId: task.replicaNodeId
+        }, "Partition in sync");
+        return {
+          partitionId: task.partitionId,
+          replicaNodeId: task.replicaNodeId,
+          keysScanned: 0,
+          keysRepaired: 0,
+          durationMs: Date.now() - startTime,
+          success: true
+        };
+      }
+      const differences = await this.findDifferences(task.partitionId, task.replicaNodeId);
+      keysScanned = differences.length;
+      for (const key of differences) {
+        const repaired = await this.repairKey(task.partitionId, task.replicaNodeId, key);
+        if (repaired) {
+          keysRepaired++;
+        }
+        if (keysRepaired % this.config.repairBatchSize === 0) {
+          await this.sleep(this.config.throttleMs);
+        }
+      }
+      logger.info({
+        partitionId: task.partitionId,
+        replicaNodeId: task.replicaNodeId,
+        keysScanned,
+        keysRepaired,
+        durationMs: Date.now() - startTime
+      }, "Partition repair completed");
+      return {
+        partitionId: task.partitionId,
+        replicaNodeId: task.replicaNodeId,
+        keysScanned,
+        keysRepaired,
+        durationMs: Date.now() - startTime,
+        success: true
+      };
+    } catch (error) {
+      return {
+        partitionId: task.partitionId,
+        replicaNodeId: task.replicaNodeId,
+        keysScanned,
+        keysRepaired,
+        durationMs: Date.now() - startTime,
+        success: false,
+        error: String(error)
+      };
+    }
+  }
+  /**
+   * Send a request and wait for response
+   */
+  sendRequest(nodeId, type, payload) {
+    return new Promise((resolve, reject) => {
+      const requestId = Math.random().toString(36).substring(7);
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(new Error(`Request timeout: ${type} to ${nodeId}`));
+      }, this.config.requestTimeoutMs);
+      this.pendingRequests.set(requestId, { resolve, reject, timer });
+      this.clusterManager.send(nodeId, type, { ...payload, requestId });
+    });
+  }
+  /**
+   * Request Merkle root from remote node
+   */
+  async requestRemoteMerkleRoot(nodeId, partitionId) {
+    const response = await this.sendRequest(
+      nodeId,
+      "CLUSTER_MERKLE_ROOT_REQ",
+      { partitionId }
+    );
+    return response.rootHash;
+  }
+  /**
+   * Find keys that differ between local and remote using bucket exchange
+   */
+  async findDifferences(partitionId, replicaNodeId) {
+    const response = await this.sendRequest(
+      replicaNodeId,
+      "CLUSTER_MERKLE_BUCKETS_REQ",
+      { partitionId }
+    );
+    const remoteBuckets = response.buckets;
+    const localTree = this.merkleManager.getTree(partitionId);
+    if (!localTree) return [];
+    const differingKeys = /* @__PURE__ */ new Set();
+    const queue = [""];
+    const maxDepth = 3;
+    while (queue.length > 0) {
+      const path = queue.shift();
+      const localChildren = localTree.getBuckets(path);
+      const remoteChildren = remoteBuckets[path] || {};
+      const allChars = /* @__PURE__ */ new Set([...Object.keys(localChildren), ...Object.keys(remoteChildren)]);
+      for (const char of allChars) {
+        const localHash = localChildren[char] || 0;
+        const remoteHash = remoteChildren[char] || 0;
+        if (localHash !== remoteHash) {
+          const nextPath = path + char;
+          if (nextPath.length >= maxDepth) {
+            const bucketKeysResp = await this.sendRequest(
+              replicaNodeId,
+              "CLUSTER_MERKLE_KEYS_REQ",
+              { partitionId, path: nextPath }
+            );
+            const localBucketKeys = localTree.getKeysInBucket(nextPath);
+            const remoteBucketKeys = bucketKeysResp.keys;
+            for (const k of localBucketKeys) differingKeys.add(k);
+            for (const k of remoteBucketKeys) differingKeys.add(k);
+          } else {
+            queue.push(nextPath);
+          }
+        }
+      }
+    }
+    return Array.from(differingKeys);
+  }
+  /**
+   * Repair a single key
+   */
+  async repairKey(partitionId, replicaNodeId, key) {
+    if (!this.getRecord || !this.setRecord) {
+      return false;
+    }
+    const localRecord = this.getRecord(key);
+    let remoteRecord;
+    try {
+      const response = await this.sendRequest(
+        replicaNodeId,
+        "CLUSTER_REPAIR_DATA_REQ",
+        { key }
+      );
+      remoteRecord = response.record;
+    } catch (e) {
+      logger.warn({ key, replicaNodeId, err: e }, "Failed to fetch remote record for repair");
+      return false;
+    }
+    const resolved = this.resolveConflict(localRecord, remoteRecord);
+    if (!resolved) return false;
+    if (JSON.stringify(resolved) !== JSON.stringify(localRecord)) {
+      this.setRecord(key, resolved);
+      if (JSON.stringify(resolved) !== JSON.stringify(remoteRecord)) {
+        this.clusterManager.send(replicaNodeId, "CLUSTER_REPAIR_DATA_RESP", {
+          // In future: Use dedicated WRITE/REPAIR message
+          // For now we rely on the fact that repair will eventually run on other node too
+        });
+      }
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Resolve conflict between two records using LWW
+   */
+  resolveConflict(a, b) {
+    if (!a && !b) return null;
+    if (!a) return b;
+    if (!b) return a;
+    if (this.compareTimestamps(a.timestamp, b.timestamp) > 0) {
+      return a;
+    }
+    if (this.compareTimestamps(b.timestamp, a.timestamp) > 0) {
+      return b;
+    }
+    if (a.timestamp.nodeId > b.timestamp.nodeId) {
+      return a;
+    }
+    return b;
+  }
+  /**
+   * Compare two timestamps
+   */
+  compareTimestamps(a, b) {
+    if (a.millis !== b.millis) {
+      return a.millis - b.millis;
+    }
+    return a.counter - b.counter;
+  }
+  /**
+   * Get partitions owned by this node
+   */
+  getOwnedPartitions() {
+    const owned = [];
+    for (let i = 0; i < PARTITION_COUNT4; i++) {
+      if (this.partitionService.getPartitionOwner(i) === this.nodeId) {
+        owned.push(i);
+      }
+    }
+    return owned;
+  }
+  /**
+   * Get partitions where this node is a backup
+   */
+  getReplicaPartitions() {
+    const replicas = [];
+    for (let i = 0; i < PARTITION_COUNT4; i++) {
+      const backups = this.partitionService.getBackups(i);
+      if (backups.includes(this.nodeId)) {
+        replicas.push(i);
+      }
+    }
+    return replicas;
+  }
+  /**
+   * Update average repair duration
+   */
+  updateAverageRepairDuration(durationMs) {
+    const count = this.metrics.repairsExecuted;
+    const currentAvg = this.metrics.averageRepairDurationMs;
+    this.metrics.averageRepairDurationMs = (currentAvg * (count - 1) + durationMs) / count;
+  }
+  /**
+   * Get repair metrics
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Get repair queue status
+   */
+  getQueueStatus() {
+    return {
+      queueLength: this.repairQueue.length,
+      activeRepairs: this.activeRepairs.size,
+      maxConcurrent: this.config.maxConcurrentRepairs
+    };
+  }
+  /**
+   * Force immediate repair for a partition
+   */
+  forceRepair(partitionId) {
+    this.schedulePartitionRepair(partitionId, "high");
+  }
+  /**
+   * Sleep utility
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+
+// src/handlers/CounterHandler.ts
+import { PNCounterImpl } from "@topgunbuild/core";
+var CounterHandler = class {
+  // counterName -> Set<clientId>
+  constructor(nodeId = "server") {
+    this.nodeId = nodeId;
+    this.counters = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get or create a counter by name.
+   */
+  getOrCreateCounter(name) {
+    let counter = this.counters.get(name);
+    if (!counter) {
+      counter = new PNCounterImpl({ nodeId: this.nodeId });
+      this.counters.set(name, counter);
+      logger.debug({ name }, "Created new counter");
+    }
+    return counter;
+  }
+  /**
+   * Handle COUNTER_REQUEST - client wants initial state.
+   * @returns Response message to send back to client
+   */
+  handleCounterRequest(clientId, name) {
+    const counter = this.getOrCreateCounter(name);
+    this.subscribe(clientId, name);
+    const state = counter.getState();
+    logger.debug({ clientId, name, value: counter.get() }, "Counter request handled");
+    return {
+      type: "COUNTER_RESPONSE",
+      payload: {
+        name,
+        state: this.stateToObject(state)
+      }
+    };
+  }
+  /**
+   * Handle COUNTER_SYNC - client sends their state to merge.
+   * @returns Merged state and list of clients to broadcast to
+   */
+  handleCounterSync(clientId, name, stateObj) {
+    const counter = this.getOrCreateCounter(name);
+    const incomingState = this.objectToState(stateObj);
+    counter.merge(incomingState);
+    const mergedState = counter.getState();
+    const mergedStateObj = this.stateToObject(mergedState);
+    logger.debug(
+      { clientId, name, value: counter.get() },
+      "Counter sync handled"
+    );
+    this.subscribe(clientId, name);
+    const subscribers = this.subscriptions.get(name) || /* @__PURE__ */ new Set();
+    const broadcastTo = Array.from(subscribers).filter((id) => id !== clientId);
+    return {
+      // Response to the sending client
+      response: {
+        type: "COUNTER_UPDATE",
+        payload: {
+          name,
+          state: mergedStateObj
+        }
+      },
+      // Broadcast to other clients
+      broadcastTo,
+      broadcastMessage: {
+        type: "COUNTER_UPDATE",
+        payload: {
+          name,
+          state: mergedStateObj
+        }
+      }
+    };
+  }
+  /**
+   * Subscribe a client to counter updates.
+   */
+  subscribe(clientId, counterName) {
+    if (!this.subscriptions.has(counterName)) {
+      this.subscriptions.set(counterName, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(counterName).add(clientId);
+    logger.debug({ clientId, counterName }, "Client subscribed to counter");
+  }
+  /**
+   * Unsubscribe a client from counter updates.
+   */
+  unsubscribe(clientId, counterName) {
+    const subs = this.subscriptions.get(counterName);
+    if (subs) {
+      subs.delete(clientId);
+      if (subs.size === 0) {
+        this.subscriptions.delete(counterName);
+      }
+    }
+  }
+  /**
+   * Unsubscribe a client from all counters (e.g., on disconnect).
+   */
+  unsubscribeAll(clientId) {
+    for (const [counterName, subs] of this.subscriptions) {
+      subs.delete(clientId);
+      if (subs.size === 0) {
+        this.subscriptions.delete(counterName);
+      }
+    }
+    logger.debug({ clientId }, "Client unsubscribed from all counters");
+  }
+  /**
+   * Get current counter value (for monitoring/debugging).
+   */
+  getCounterValue(name) {
+    const counter = this.counters.get(name);
+    return counter ? counter.get() : 0;
+  }
+  /**
+   * Get all counter names.
+   */
+  getCounterNames() {
+    return Array.from(this.counters.keys());
+  }
+  /**
+   * Get number of subscribers for a counter.
+   */
+  getSubscriberCount(name) {
+    return this.subscriptions.get(name)?.size || 0;
+  }
+  /**
+   * Convert Map-based state to plain object for serialization.
+   */
+  stateToObject(state) {
+    return {
+      p: Object.fromEntries(state.positive),
+      n: Object.fromEntries(state.negative)
+    };
+  }
+  /**
+   * Convert plain object to Map-based state.
+   */
+  objectToState(obj) {
+    return {
+      positive: new Map(Object.entries(obj.p || {})),
+      negative: new Map(Object.entries(obj.n || {}))
+    };
+  }
+};
+
+// src/handlers/EntryProcessorHandler.ts
+import {
+  EntryProcessorDefSchema
+} from "@topgunbuild/core";
+
+// src/ProcessorSandbox.ts
+import {
+  validateProcessorCode
+} from "@topgunbuild/core";
+var ivm = null;
+try {
+  ivm = __require("isolated-vm");
+} catch {
+  const isProduction = process.env.NODE_ENV === "production";
+  if (isProduction) {
+    logger.error(
+      "SECURITY WARNING: isolated-vm not available in production! Entry processors will run in less secure fallback mode. Install isolated-vm for production environments: pnpm add isolated-vm"
+    );
+  } else {
+    logger.warn("isolated-vm not available, falling back to less secure VM");
+  }
+}
+var DEFAULT_SANDBOX_CONFIG = {
+  memoryLimitMb: 8,
+  timeoutMs: 100,
+  maxCachedIsolates: 100,
+  strictValidation: true
+};
+var ProcessorSandbox = class {
+  constructor(config = {}) {
+    this.isolateCache = /* @__PURE__ */ new Map();
+    this.scriptCache = /* @__PURE__ */ new Map();
+    this.fallbackScriptCache = /* @__PURE__ */ new Map();
+    this.disposed = false;
+    this.config = { ...DEFAULT_SANDBOX_CONFIG, ...config };
+  }
+  /**
+   * Execute an entry processor in the sandbox.
+   *
+   * @param processor The processor definition (name, code, args)
+   * @param value The current value for the key (or undefined)
+   * @param key The key being processed
+   * @returns Result containing success status, result, and new value
+   */
+  async execute(processor, value, key) {
+    if (this.disposed) {
+      return {
+        success: false,
+        error: "Sandbox has been disposed"
+      };
+    }
+    if (this.config.strictValidation) {
+      const validation = validateProcessorCode(processor.code);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: validation.error
+        };
+      }
+    }
+    if (ivm) {
+      return this.executeInIsolate(processor, value, key);
+    } else {
+      return this.executeInFallback(processor, value, key);
+    }
+  }
+  /**
+   * Execute processor in isolated-vm (secure production mode).
+   */
+  async executeInIsolate(processor, value, key) {
+    if (!ivm) {
+      return { success: false, error: "isolated-vm not available" };
+    }
+    const isolate = this.getOrCreateIsolate(processor.name);
+    try {
+      const context = await isolate.createContext();
+      const jail = context.global;
+      await jail.set("global", jail.derefInto());
+      await context.eval(`
+        var value = ${JSON.stringify(value)};
+        var key = ${JSON.stringify(key)};
+        var args = ${JSON.stringify(processor.args)};
       `);
       const wrappedCode = `
         (function() {
@@ -8112,7 +9356,7 @@ var ServerCoordinator = class {
           this.partitionService,
           {
             ...DEFAULT_REPLICATION_CONFIG2,
-            defaultConsistency: config.defaultConsistency ?? ConsistencyLevel2.EVENTUAL,
+            defaultConsistency: config.defaultConsistency ?? ConsistencyLevel3.EVENTUAL,
             ...config.replicationConfig
           }
         );
@@ -8154,6 +9398,52 @@ var ServerCoordinator = class {
           logger.error({ err }, "Failed to initialize EventJournalService");
         });
       }
+      this.partitionReassigner = new PartitionReassigner(
+        this.cluster,
+        this.partitionService,
+        { reassignmentDelayMs: 1e3 }
+      );
+      this.partitionReassigner.on("failoverComplete", (event) => {
+        logger.info({
+          failedNodeId: event.failedNodeId,
+          partitionsReassigned: event.partitionsReassigned,
+          durationMs: event.durationMs
+        }, "Partition failover completed");
+        this.broadcastPartitionMap(this.partitionService.getPartitionMap());
+      });
+      logger.info("PartitionReassigner initialized");
+      this.readReplicaHandler = new ReadReplicaHandler(
+        this.partitionService,
+        this.cluster,
+        this._nodeId,
+        void 0,
+        // LagTracker - can be added later
+        {
+          defaultConsistency: config.defaultConsistency ?? ConsistencyLevel3.STRONG,
+          preferLocalReplica: true,
+          loadBalancing: "latency-based"
+        }
+      );
+      logger.info("ReadReplicaHandler initialized");
+      this.merkleTreeManager = new MerkleTreeManager(this._nodeId);
+      this.repairScheduler = new RepairScheduler(
+        this.merkleTreeManager,
+        this.cluster,
+        this.partitionService,
+        this._nodeId,
+        {
+          enabled: true,
+          scanIntervalMs: 3e5,
+          // 5 minutes
+          maxConcurrentRepairs: 2
+        }
+      );
+      this.repairScheduler.setDataAccessors(
+        (key) => this.getLocalRecord(key) ?? void 0,
+        (key, record) => this.applyRepairRecord(key, record)
+      );
+      this.repairScheduler.start();
+      logger.info("MerkleTreeManager and RepairScheduler initialized");
       this.systemManager = new SystemManager(
         this.cluster,
         this.metricsService,
@@ -8250,8 +9540,84 @@ var ServerCoordinator = class {
   getTaskletScheduler() {
     return this.taskletScheduler;
   }
+  /**
+   * Phase 10.02: Graceful cluster departure
+   *
+   * Notifies the cluster that this node is leaving and allows time for:
+   * 1. Pending replication to complete
+   * 2. Other nodes to detect departure
+   * 3. Partition reassignment to begin
+   */
+  async gracefulClusterDeparture() {
+    if (!this.cluster || this.cluster.getMembers().length <= 1) {
+      return;
+    }
+    const nodeId = this._nodeId;
+    const ownedPartitions = this.partitionService ? this.getOwnedPartitions() : [];
+    logger.info({
+      nodeId,
+      ownedPartitions: ownedPartitions.length,
+      clusterMembers: this.cluster.getMembers().length
+    }, "Initiating graceful cluster departure");
+    const departureMessage = {
+      type: "NODE_LEAVING",
+      nodeId,
+      partitions: ownedPartitions,
+      timestamp: Date.now()
+    };
+    for (const memberId of this.cluster.getMembers()) {
+      if (memberId !== nodeId) {
+        try {
+          this.cluster.send(memberId, "CLUSTER_EVENT", departureMessage);
+        } catch (e) {
+          logger.warn({ memberId, err: e }, "Failed to notify peer of departure");
+        }
+      }
+    }
+    if (this.replicationPipeline) {
+      logger.info("Waiting for pending replication to complete...");
+      try {
+        await this.waitForReplicationFlush(3e3);
+        logger.info("Replication flush complete");
+      } catch (e) {
+        logger.warn({ err: e }, "Replication flush timeout - some data may not be replicated");
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    logger.info({ nodeId }, "Graceful cluster departure complete");
+  }
+  /**
+   * Get list of partition IDs owned by this node
+   */
+  getOwnedPartitions() {
+    if (!this.partitionService) return [];
+    const partitionMap = this.partitionService.getPartitionMap();
+    const owned = [];
+    for (const partition of partitionMap.partitions) {
+      if (partition.ownerNodeId === this._nodeId) {
+        owned.push(partition.partitionId);
+      }
+    }
+    return owned;
+  }
+  /**
+   * Wait for replication pipeline to flush pending operations
+   */
+  async waitForReplicationFlush(timeoutMs) {
+    if (!this.replicationPipeline) return;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+      const pendingOps = this.replicationPipeline.getTotalPending();
+      if (pendingOps === 0) {
+        return;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error("Replication flush timeout");
+  }
   async shutdown() {
     logger.info("Shutting down Server Coordinator...");
+    await this.gracefulClusterDeparture();
     this.httpServer.close();
     if (this.metricsServer) {
       this.metricsServer.close();
@@ -8284,6 +9650,14 @@ var ServerCoordinator = class {
     if (this.replicationPipeline) {
       this.replicationPipeline.close();
     }
+    if (this.repairScheduler) {
+      this.repairScheduler.stop();
+      logger.info("RepairScheduler stopped");
+    }
+    if (this.partitionReassigner) {
+      this.partitionReassigner.stop();
+      logger.info("PartitionReassigner stopped");
+    }
     if (this.cluster) {
       this.cluster.stop();
     }
@@ -8499,7 +9873,32 @@ var ServerCoordinator = class {
         logger.info({ clientId: client.id, mapName, query }, "Client subscribed");
         this.metricsService.incOp("SUBSCRIBE", mapName);
         const allMembers = this.cluster.getMembers();
-        const remoteMembers = allMembers.filter((id) => !this.cluster.isLocal(id));
+        let remoteMembers = allMembers.filter((id) => !this.cluster.isLocal(id));
+        const queryKey = query._id || query.where?._id;
+        if (queryKey && typeof queryKey === "string" && this.readReplicaHandler) {
+          try {
+            const targetNode = this.readReplicaHandler.selectReadNode({
+              mapName,
+              key: queryKey,
+              options: {
+                // Default to EVENTUAL for read scaling unless specified otherwise
+                // In future, we could extract consistency from query options if available
+                consistency: ConsistencyLevel3.EVENTUAL
+              }
+            });
+            if (targetNode) {
+              if (this.cluster.isLocal(targetNode)) {
+                remoteMembers = [];
+                logger.debug({ clientId: client.id, mapName, key: queryKey }, "Read optimization: Serving locally");
+              } else if (remoteMembers.includes(targetNode)) {
+                remoteMembers = [targetNode];
+                logger.debug({ clientId: client.id, mapName, key: queryKey, targetNode }, "Read optimization: Routing to replica");
+              }
+            }
+          } catch (e) {
+            logger.warn({ err: e }, "Error in ReadReplicaHandler selection");
+          }
+        }
         const requestId = crypto.randomUUID();
         const pending = {
           requestId,
@@ -9377,7 +10776,7 @@ var ServerCoordinator = class {
     };
     let broadcastCount = 0;
     for (const client of this.clients.values()) {
-      if (client.isAuthenticated && client.socket.readyState === WebSocket3.OPEN) {
+      if (client.isAuthenticated && client.socket.readyState === WebSocket3.OPEN && client.writer) {
         client.writer.write(message);
         broadcastCount++;
       }
@@ -9644,7 +11043,14 @@ var ServerCoordinator = class {
     this.cluster.on("message", (msg) => {
       switch (msg.type) {
         case "OP_FORWARD":
+          if (msg.payload._replication || msg.payload._migration) {
+            break;
+          }
           logger.info({ senderId: msg.senderId }, "Received forwarded op");
+          if (!msg.payload.key) {
+            logger.warn({ senderId: msg.senderId }, "OP_FORWARD missing key, dropping");
+            break;
+          }
           if (this.partitionService.isLocalOwner(msg.payload.key)) {
             this.processLocalOp(msg.payload, true, msg.senderId).catch((err) => {
               logger.error({ err, senderId: msg.senderId }, "Forwarded op failed");
@@ -9751,6 +11157,51 @@ var ServerCoordinator = class {
           this.topicManager.publish(topic, data, originalSenderId, true);
           break;
         }
+        // Phase 10.04: Anti-entropy repair messages
+        case "CLUSTER_MERKLE_ROOT_REQ": {
+          const { partitionId, requestId } = msg.payload;
+          const rootHash = this.merkleTreeManager?.getRootHash(partitionId) ?? 0;
+          this.cluster.send(msg.senderId, "CLUSTER_MERKLE_ROOT_RESP", {
+            requestId,
+            partitionId,
+            rootHash
+          });
+          break;
+        }
+        case "CLUSTER_MERKLE_ROOT_RESP": {
+          if (this.repairScheduler) {
+            this.repairScheduler.emit("merkleRootResponse", {
+              nodeId: msg.senderId,
+              ...msg.payload
+            });
+          }
+          break;
+        }
+        case "CLUSTER_REPAIR_DATA_REQ": {
+          const { partitionId, keys, requestId } = msg.payload;
+          const records = {};
+          for (const key of keys) {
+            const record = this.getLocalRecord(key);
+            if (record) {
+              records[key] = record;
+            }
+          }
+          this.cluster.send(msg.senderId, "CLUSTER_REPAIR_DATA_RESP", {
+            requestId,
+            partitionId,
+            records
+          });
+          break;
+        }
+        case "CLUSTER_REPAIR_DATA_RESP": {
+          if (this.repairScheduler) {
+            this.repairScheduler.emit("repairDataResponse", {
+              nodeId: msg.senderId,
+              ...msg.payload
+            });
+          }
+          break;
+        }
       }
     });
   }
@@ -10020,6 +11471,10 @@ var ServerCoordinator = class {
         nodeId: this._nodeId
       });
     }
+    if (this.merkleTreeManager && recordToStore && op.key) {
+      const partitionId = this.partitionService.getPartitionId(op.key);
+      this.merkleTreeManager.updateRecord(partitionId, op.key, recordToStore);
+    }
     return { eventPayload, oldRecord };
   }
   /**
@@ -10147,7 +11602,7 @@ var ServerCoordinator = class {
     if (rejected || !eventPayload) {
       return;
     }
-    if (this.replicationPipeline && !fromCluster) {
+    if (this.replicationPipeline) {
       const opId = op.id || `${op.mapName}:${op.key}:${Date.now()}`;
       this.replicationPipeline.replicate(op, opId, op.key).catch((err) => {
         logger.warn({ opId, key: op.key, err }, "Replication failed (non-fatal)");
@@ -10290,6 +11745,10 @@ var ServerCoordinator = class {
   }
   handleClusterEvent(payload) {
     const { mapName, key, eventType } = payload;
+    if (!key) {
+      logger.warn({ mapName, eventType }, "Received cluster event with undefined key, ignoring");
+      return;
+    }
     const map = this.getMap(mapName, eventType === "OR_ADD" || eventType === "OR_REMOVE" ? "OR" : "LWW");
     const oldRecord = map instanceof LWWMap3 ? map.getRecord(key) : null;
     if (this.partitionService.isRelated(key)) {
@@ -10354,6 +11813,51 @@ var ServerCoordinator = class {
     }
     return this.maps.get(name);
   }
+  /**
+   * Phase 10.04: Get local record for anti-entropy repair
+   * Returns the LWWRecord for a key, used by RepairScheduler
+   */
+  getLocalRecord(key) {
+    const separatorIndex = key.indexOf(":");
+    if (separatorIndex === -1) {
+      return null;
+    }
+    const mapName = key.substring(0, separatorIndex);
+    const actualKey = key.substring(separatorIndex + 1);
+    const map = this.maps.get(mapName);
+    if (!map || !(map instanceof LWWMap3)) {
+      return null;
+    }
+    return map.getRecord(actualKey) ?? null;
+  }
+  /**
+   * Phase 10.04: Apply repaired record from anti-entropy repair
+   * Used by RepairScheduler to apply resolved conflicts
+   */
+  applyRepairRecord(key, record) {
+    const separatorIndex = key.indexOf(":");
+    if (separatorIndex === -1) {
+      logger.warn({ key }, "Invalid key format for repair");
+      return;
+    }
+    const mapName = key.substring(0, separatorIndex);
+    const actualKey = key.substring(separatorIndex + 1);
+    const map = this.getMap(mapName, "LWW");
+    const existingRecord = map.getRecord(actualKey);
+    if (!existingRecord || record.timestamp.millis > existingRecord.timestamp.millis || record.timestamp.millis === existingRecord.timestamp.millis && record.timestamp.counter > existingRecord.timestamp.counter) {
+      map.merge(actualKey, record);
+      logger.debug({ mapName, key: actualKey }, "Applied repair record");
+      if (this.storage) {
+        this.storage.store(mapName, actualKey, record).catch((err) => {
+          logger.error({ err, mapName, key: actualKey }, "Failed to persist repair record");
+        });
+      }
+      if (this.merkleTreeManager) {
+        const partitionId = this.partitionService.getPartitionId(actualKey);
+        this.merkleTreeManager.updateRecord(partitionId, actualKey, record);
+      }
+    }
+  }
   async loadMapFromStorage(name, typeHint) {
     try {
       const keys = await this.storage.loadAllKeys(name);
@@ -11239,7 +12743,7 @@ function logNativeStatus() {
 }
 
 // src/cluster/ClusterCoordinator.ts
-import { EventEmitter as EventEmitter9 } from "events";
+import { EventEmitter as EventEmitter13 } from "events";
 import {
   DEFAULT_MIGRATION_CONFIG as DEFAULT_MIGRATION_CONFIG3,
   DEFAULT_REPLICATION_CONFIG as DEFAULT_REPLICATION_CONFIG3
@@ -11250,7 +12754,7 @@ var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
   replication: DEFAULT_REPLICATION_CONFIG3,
   replicationEnabled: true
 };
-var ClusterCoordinator = class extends EventEmitter9 {
+var ClusterCoordinator = class extends EventEmitter13 {
   constructor(config) {
     super();
     this.replicationPipeline = null;
@@ -12064,12 +13568,18 @@ export {
   ConnectionRateLimiter,
   DEFAULT_CLUSTER_COORDINATOR_CONFIG,
   DEFAULT_CONFLICT_RESOLVER_CONFIG,
+  DEFAULT_FAILURE_DETECTOR_CONFIG,
   DEFAULT_INDEX_CONFIG,
   DEFAULT_JOURNAL_SERVICE_CONFIG,
   DEFAULT_LAG_TRACKER_CONFIG,
+  DEFAULT_MERKLE_TREE_CONFIG,
+  DEFAULT_READ_REPLICA_CONFIG,
+  DEFAULT_REASSIGNER_CONFIG,
+  DEFAULT_REPAIR_CONFIG,
   DEFAULT_SANDBOX_CONFIG,
   EntryProcessorHandler,
   EventJournalService,
+  FailureDetector,
   FilterTasklet,
   ForEachTasklet,
   IteratorTasklet,
@@ -12079,13 +13589,17 @@ export {
   MapTasklet,
   MapWithResolver,
   MemoryServerAdapter,
+  MerkleTreeManager,
   MigrationManager,
   ObjectPool,
+  PartitionReassigner,
   PartitionService,
   PostgresAdapter,
   ProcessorSandbox,
   RateLimitInterceptor,
+  ReadReplicaHandler,
   ReduceTasklet,
+  RepairScheduler,
   ReplicationPipeline,
   SecurityManager,
   ServerCoordinator,