@topgunbuild/server 0.6.0 → 0.7.0

package/dist/index.js

@@ -38,12 +38,18 @@ __export(index_exports, {
   ConnectionRateLimiter: () => ConnectionRateLimiter,
   DEFAULT_CLUSTER_COORDINATOR_CONFIG: () => DEFAULT_CLUSTER_COORDINATOR_CONFIG,
   DEFAULT_CONFLICT_RESOLVER_CONFIG: () => DEFAULT_CONFLICT_RESOLVER_CONFIG,
+  DEFAULT_FAILURE_DETECTOR_CONFIG: () => DEFAULT_FAILURE_DETECTOR_CONFIG,
   DEFAULT_INDEX_CONFIG: () => DEFAULT_INDEX_CONFIG,
   DEFAULT_JOURNAL_SERVICE_CONFIG: () => DEFAULT_JOURNAL_SERVICE_CONFIG,
   DEFAULT_LAG_TRACKER_CONFIG: () => DEFAULT_LAG_TRACKER_CONFIG,
+  DEFAULT_MERKLE_TREE_CONFIG: () => DEFAULT_MERKLE_TREE_CONFIG,
+  DEFAULT_READ_REPLICA_CONFIG: () => DEFAULT_READ_REPLICA_CONFIG,
+  DEFAULT_REASSIGNER_CONFIG: () => DEFAULT_REASSIGNER_CONFIG,
+  DEFAULT_REPAIR_CONFIG: () => DEFAULT_REPAIR_CONFIG,
   DEFAULT_SANDBOX_CONFIG: () => DEFAULT_SANDBOX_CONFIG,
   EntryProcessorHandler: () => EntryProcessorHandler,
   EventJournalService: () => EventJournalService,
+  FailureDetector: () => FailureDetector,
   FilterTasklet: () => FilterTasklet,
   ForEachTasklet: () => ForEachTasklet,
   IteratorTasklet: () => IteratorTasklet,
@@ -53,13 +59,17 @@ __export(index_exports, {
   MapTasklet: () => MapTasklet,
   MapWithResolver: () => MapWithResolver,
   MemoryServerAdapter: () => MemoryServerAdapter,
+  MerkleTreeManager: () => MerkleTreeManager,
   MigrationManager: () => MigrationManager,
   ObjectPool: () => ObjectPool,
+  PartitionReassigner: () => PartitionReassigner,
   PartitionService: () => PartitionService,
   PostgresAdapter: () => PostgresAdapter,
   ProcessorSandbox: () => ProcessorSandbox,
   RateLimitInterceptor: () => RateLimitInterceptor,
+  ReadReplicaHandler: () => ReadReplicaHandler,
   ReduceTasklet: () => ReduceTasklet,
+  RepairScheduler: () => RepairScheduler,
   ReplicationPipeline: () => ReplicationPipeline,
   SecurityManager: () => SecurityManager,
   ServerCoordinator: () => ServerCoordinator,
@@ -95,7 +105,7 @@ var import_http = require("http");
 var import_https = require("https");
 var import_fs2 = require("fs");
 var import_ws3 = require("ws");
-var import_core15 = require("@topgunbuild/core");
+var import_core19 = require("@topgunbuild/core");
 var jwt = __toESM(require("jsonwebtoken"));
 var crypto = __toESM(require("crypto"));
 
@@ -1211,6 +1221,47 @@ var ClusterManager = class extends import_events2.EventEmitter {
   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 === import_ws.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.
    */
@@ -1349,6 +1400,9 @@ var ClusterManager = class extends import_events2.EventEmitter {
           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);
@@ -6634,238 +6688,1438 @@ var ReplicationPipeline = class extends import_events8.EventEmitter {
   }
 };
 
-// src/handlers/CounterHandler.ts
+// src/cluster/PartitionReassigner.ts
+var import_events9 = require("events");
 var import_core10 = require("@topgunbuild/core");
-var CounterHandler = class {
-  // counterName -> Set<clientId>
-  constructor(nodeId = "server") {
-    this.nodeId = nodeId;
-    this.counters = /* @__PURE__ */ new Map();
-    this.subscriptions = /* @__PURE__ */ new Map();
+var DEFAULT_REASSIGNER_CONFIG = {
+  reassignmentDelayMs: 1e3,
+  maxConcurrentTransfers: 10,
+  autoPromoteBackups: true,
+  autoAssignNewBackups: true
+};
+var PartitionReassigner = class extends import_events9.EventEmitter {
+  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 import_core10.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(import_core10.DEFAULT_BACKUP_COUNT, 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
-var import_core12 = require("@topgunbuild/core");
-
-// src/ProcessorSandbox.ts
+// src/cluster/ReadReplicaHandler.ts
+var import_events10 = require("events");
 var import_core11 = require("@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 DEFAULT_READ_REPLICA_CONFIG = {
+  defaultConsistency: import_core11.ConsistencyLevel.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 import_events10.EventEmitter {
+  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 === import_core11.ConsistencyLevel.STRONG) {
+      return this.partitionService.isLocalOwner(request.key);
     }
-    if (this.config.strictValidation) {
-      const validation = (0, import_core11.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 === import_core11.ConsistencyLevel.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)};
-      `);
-      const wrappedCode = `
-        (function() {
-          ${processor.code}
-        })()
-      `;
+    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 === import_core11.ConsistencyLevel.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
+var import_events11 = require("events");
+var import_core12 = require("@topgunbuild/core");
+var DEFAULT_MERKLE_TREE_CONFIG = {
+  treeDepth: 3,
+  autoUpdate: true,
+  lazyInit: true
+};
+var MerkleTreeManager = class extends import_events11.EventEmitter {
+  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 import_core12.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 import_core12.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 = (0, import_core12.hashString)(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
+var import_events12 = require("events");
+var import_core13 = require("@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 import_events12.EventEmitter {
+  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 < import_core13.PARTITION_COUNT; 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 < import_core13.PARTITION_COUNT; 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
+var import_core14 = require("@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 import_core14.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
+var import_core16 = require("@topgunbuild/core");
+
+// src/ProcessorSandbox.ts
+var import_core15 = require("@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 = (0, import_core15.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() {
+          ${processor.code}
+        })()
+      `;
       const script = await this.getOrCompileScript(
         processor.name,
         wrappedCode,
@@ -7045,7 +8299,7 @@ var EntryProcessorHandler = class {
    * @returns Result with success status, processor result, and new value
    */
   async executeOnKey(map, key, processorDef) {
-    const parseResult = import_core12.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core16.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       logger.warn(
         { key, error: parseResult.error.message },
@@ -7111,7 +8365,7 @@ var EntryProcessorHandler = class {
   async executeOnKeys(map, keys, processorDef) {
     const results = /* @__PURE__ */ new Map();
     const timestamps = /* @__PURE__ */ new Map();
-    const parseResult = import_core12.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core16.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       const errorResult = {
         success: false,
@@ -7148,7 +8402,7 @@ var EntryProcessorHandler = class {
   async executeOnEntries(map, processorDef, predicateCode) {
     const results = /* @__PURE__ */ new Map();
     const timestamps = /* @__PURE__ */ new Map();
-    const parseResult = import_core12.EntryProcessorDefSchema.safeParse(processorDef);
+    const parseResult = import_core16.EntryProcessorDefSchema.safeParse(processorDef);
     if (!parseResult.success) {
       return { results, timestamps };
     }
@@ -7207,7 +8461,7 @@ var EntryProcessorHandler = class {
 };
 
 // src/ConflictResolverService.ts
-var import_core13 = require("@topgunbuild/core");
+var import_core17 = require("@topgunbuild/core");
 var DEFAULT_CONFLICT_RESOLVER_CONFIG = {
   maxResolversPerMap: 100,
   enableSandboxedResolvers: true,
@@ -7238,7 +8492,7 @@ var ConflictResolverService = class {
       throw new Error("ConflictResolverService has been disposed");
     }
     if (resolver.code) {
-      const parsed = import_core13.ConflictResolverDefSchema.safeParse({
+      const parsed = import_core17.ConflictResolverDefSchema.safeParse({
         name: resolver.name,
         code: resolver.code,
         priority: resolver.priority,
@@ -7247,7 +8501,7 @@ var ConflictResolverService = class {
       if (!parsed.success) {
         throw new Error(`Invalid resolver definition: ${parsed.error.message}`);
       }
-      const validation = (0, import_core13.validateResolverCode)(resolver.code);
+      const validation = (0, import_core17.validateResolverCode)(resolver.code);
       if (!validation.valid) {
         throw new Error(`Invalid resolver code: ${validation.error}`);
       }
@@ -7309,7 +8563,7 @@ var ConflictResolverService = class {
     const entries = this.resolvers.get(context.mapName) ?? [];
     const allEntries = [
       ...entries,
-      { resolver: import_core13.BuiltInResolvers.LWW() }
+      { resolver: import_core17.BuiltInResolvers.LWW() }
     ];
     for (const entry of allEntries) {
       const { resolver } = entry;
@@ -7665,9 +8919,9 @@ var ConflictResolverHandler = class {
 };
 
 // src/EventJournalService.ts
-var import_core14 = require("@topgunbuild/core");
+var import_core18 = require("@topgunbuild/core");
 var DEFAULT_JOURNAL_SERVICE_CONFIG = {
-  ...import_core14.DEFAULT_EVENT_JOURNAL_CONFIG,
+  ...import_core18.DEFAULT_EVENT_JOURNAL_CONFIG,
   tableName: "event_journal",
   persistBatchSize: 100,
   persistIntervalMs: 1e3
@@ -7680,7 +8934,7 @@ function validateTableName(name) {
     );
   }
 }
-var EventJournalService = class extends import_core14.EventJournalImpl {
+var EventJournalService = class extends import_core18.EventJournalImpl {
   constructor(config) {
     super(config);
     this.pendingPersist = [];
@@ -8027,7 +9281,7 @@ var ServerCoordinator = class {
       this._readyResolve = resolve;
     });
     this._nodeId = config.nodeId;
-    this.hlc = new import_core15.HLC(config.nodeId);
+    this.hlc = new import_core19.HLC(config.nodeId);
     this.storage = config.storage;
     const rawSecret = config.jwtSecret || process.env.JWT_SECRET || "topgun-secret-dev";
     this.jwtSecret = rawSecret.replace(/\\n/g, "\n");
@@ -8169,8 +9423,8 @@ var ServerCoordinator = class {
           this.cluster,
           this.partitionService,
           {
-            ...import_core15.DEFAULT_REPLICATION_CONFIG,
-            defaultConsistency: config.defaultConsistency ?? import_core15.ConsistencyLevel.EVENTUAL,
+            ...import_core19.DEFAULT_REPLICATION_CONFIG,
+            defaultConsistency: config.defaultConsistency ?? import_core19.ConsistencyLevel.EVENTUAL,
             ...config.replicationConfig
           }
         );
@@ -8212,6 +9466,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 ?? import_core19.ConsistencyLevel.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,
@@ -8308,8 +9608,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();
@@ -8317,7 +9693,7 @@ var ServerCoordinator = class {
     this.metricsService.destroy();
     this.wss.close();
     logger.info(`Closing ${this.clients.size} client connections...`);
-    const shutdownMsg = (0, import_core15.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
+    const shutdownMsg = (0, import_core19.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.clients.values()) {
       try {
         if (client.socket.readyState === import_ws3.WebSocket.OPEN) {
@@ -8342,6 +9718,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();
     }
@@ -8442,7 +9826,7 @@ var ServerCoordinator = class {
           buf = Buffer.from(message);
         }
         try {
-          data = (0, import_core15.deserialize)(buf);
+          data = (0, import_core19.deserialize)(buf);
         } catch (e) {
           try {
             const text = Buffer.isBuffer(buf) ? buf.toString() : new TextDecoder().decode(buf);
@@ -8494,10 +9878,10 @@ var ServerCoordinator = class {
       this.clients.delete(clientId);
       this.metricsService.setConnectedClients(this.clients.size);
     });
-    ws.send((0, import_core15.serialize)({ type: "AUTH_REQUIRED" }));
+    ws.send((0, import_core19.serialize)({ type: "AUTH_REQUIRED" }));
   }
   async handleMessage(client, rawMessage) {
-    const parseResult = import_core15.MessageSchema.safeParse(rawMessage);
+    const parseResult = import_core19.MessageSchema.safeParse(rawMessage);
     if (!parseResult.success) {
       logger.error({ clientId: client.id, error: parseResult.error }, "Invalid message format from client");
       client.writer.write({
@@ -8557,7 +9941,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: import_core19.ConsistencyLevel.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,
@@ -8737,7 +10146,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName);
-          if (mapForSync instanceof import_core15.LWWMap) {
+          if (mapForSync instanceof import_core19.LWWMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -8775,7 +10184,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName);
-          if (mapForBucket instanceof import_core15.LWWMap) {
+          if (mapForBucket instanceof import_core19.LWWMap) {
             const treeForBucket = mapForBucket.getMerkleTree();
             const buckets = treeForBucket.getBuckets(path);
             const node = treeForBucket.getNode(path);
@@ -9157,7 +10566,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName, "OR");
-          if (mapForSync instanceof import_core15.ORMap) {
+          if (mapForSync instanceof import_core19.ORMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -9194,7 +10603,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName, "OR");
-          if (mapForBucket instanceof import_core15.ORMap) {
+          if (mapForBucket instanceof import_core19.ORMap) {
             const tree = mapForBucket.getMerkleTree();
             const buckets = tree.getBuckets(path);
             const isLeaf = tree.isLeaf(path);
@@ -9238,7 +10647,7 @@ var ServerCoordinator = class {
         const { mapName: diffMapName, keys } = message.payload;
         try {
           const mapForDiff = await this.getMapAsync(diffMapName, "OR");
-          if (mapForDiff instanceof import_core15.ORMap) {
+          if (mapForDiff instanceof import_core19.ORMap) {
             const entries = [];
             const allTombstones = mapForDiff.getTombstones();
             for (const key of keys) {
@@ -9270,7 +10679,7 @@ var ServerCoordinator = class {
         const { mapName: pushMapName, entries: pushEntries } = message.payload;
         try {
           const mapForPush = await this.getMapAsync(pushMapName, "OR");
-          if (mapForPush instanceof import_core15.ORMap) {
+          if (mapForPush instanceof import_core19.ORMap) {
             let totalAdded = 0;
             let totalUpdated = 0;
             for (const entry of pushEntries) {
@@ -9411,7 +10820,7 @@ var ServerCoordinator = class {
       } else if (op.orRecord && op.orRecord.timestamp) {
       } else if (op.orTag) {
         try {
-          ts = import_core15.HLC.parse(op.orTag);
+          ts = import_core19.HLC.parse(op.orTag);
         } catch (e) {
         }
       }
@@ -9435,7 +10844,7 @@ var ServerCoordinator = class {
     };
     let broadcastCount = 0;
     for (const client of this.clients.values()) {
-      if (client.isAuthenticated && client.socket.readyState === import_ws3.WebSocket.OPEN) {
+      if (client.isAuthenticated && client.socket.readyState === import_ws3.WebSocket.OPEN && client.writer) {
         client.writer.write(message);
         broadcastCount++;
       }
@@ -9508,7 +10917,7 @@ var ServerCoordinator = class {
         client.writer.write({ ...message, payload: newPayload });
       }
     } else {
-      const msgData = (0, import_core15.serialize)(message);
+      const msgData = (0, import_core19.serialize)(message);
       for (const [id, client] of this.clients) {
         if (id !== excludeClientId && client.socket.readyState === 1) {
           client.writer.writeRaw(msgData);
@@ -9586,7 +10995,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core15.serialize)(batchMessage);
+      const serializedBatch = (0, import_core19.serialize)(batchMessage);
       for (const client of clients) {
         try {
           client.writer.writeRaw(serializedBatch);
@@ -9671,7 +11080,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core15.serialize)(batchMessage);
+      const serializedBatch = (0, import_core19.serialize)(batchMessage);
       for (const client of clients) {
         sendPromises.push(new Promise((resolve, reject) => {
           try {
@@ -9702,7 +11111,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");
@@ -9809,6 +11225,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;
+        }
       }
     });
   }
@@ -9817,7 +11278,7 @@ var ServerCoordinator = class {
     const localQuery = { ...query };
     delete localQuery.offset;
     delete localQuery.limit;
-    if (map instanceof import_core15.IndexedLWWMap) {
+    if (map instanceof import_core19.IndexedLWWMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const entries = map.queryEntries(coreQuery);
@@ -9827,7 +11288,7 @@ var ServerCoordinator = class {
         });
       }
     }
-    if (map instanceof import_core15.IndexedORMap) {
+    if (map instanceof import_core19.IndexedORMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const results = map.query(coreQuery);
@@ -9835,14 +11296,14 @@ var ServerCoordinator = class {
       }
     }
     const records = /* @__PURE__ */ new Map();
-    if (map instanceof import_core15.LWWMap) {
+    if (map instanceof import_core19.LWWMap) {
       for (const key of map.allKeys()) {
         const rec = map.getRecord(key);
         if (rec && rec.value !== null) {
           records.set(key, rec);
         }
       }
-    } else if (map instanceof import_core15.ORMap) {
+    } else if (map instanceof import_core19.ORMap) {
       const items = map.items;
       for (const key of items.keys()) {
         const values = map.get(key);
@@ -9990,11 +11451,11 @@ var ServerCoordinator = class {
   async applyOpToMap(op, remoteNodeId) {
     const typeHint = op.opType === "OR_ADD" || op.opType === "OR_REMOVE" ? "OR" : "LWW";
     const map = this.getMap(op.mapName, typeHint);
-    if (typeHint === "OR" && map instanceof import_core15.LWWMap) {
+    if (typeHint === "OR" && map instanceof import_core19.LWWMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: LWWMap but received OR op");
       throw new Error("Map type mismatch: LWWMap but received OR op");
     }
-    if (typeHint === "LWW" && map instanceof import_core15.ORMap) {
+    if (typeHint === "LWW" && map instanceof import_core19.ORMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: ORMap but received LWW op");
       throw new Error("Map type mismatch: ORMap but received LWW op");
     }
@@ -10005,7 +11466,7 @@ var ServerCoordinator = class {
       mapName: op.mapName,
       key: op.key
     };
-    if (map instanceof import_core15.LWWMap) {
+    if (map instanceof import_core19.LWWMap) {
       oldRecord = map.getRecord(op.key);
       if (this.conflictResolverHandler.hasResolvers(op.mapName)) {
         const mergeResult = await this.conflictResolverHandler.mergeWithResolver(
@@ -10033,7 +11494,7 @@ var ServerCoordinator = class {
         eventPayload.eventType = "UPDATED";
         eventPayload.record = op.record;
       }
-    } else if (map instanceof import_core15.ORMap) {
+    } else if (map instanceof import_core19.ORMap) {
       oldRecord = map.getRecords(op.key);
       if (op.opType === "OR_ADD") {
         map.apply(op.key, op.orRecord);
@@ -10049,7 +11510,7 @@ var ServerCoordinator = class {
       }
     }
     this.queryRegistry.processChange(op.mapName, map, op.key, op.record || op.orRecord, oldRecord);
-    const mapSize = map instanceof import_core15.ORMap ? map.totalRecords : map.size;
+    const mapSize = map instanceof import_core19.ORMap ? map.totalRecords : map.size;
     this.metricsService.setMapSize(op.mapName, mapSize);
     if (this.storage) {
       if (recordToStore) {
@@ -10078,6 +11539,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 };
   }
   /**
@@ -10205,7 +11670,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)");
@@ -10348,12 +11813,16 @@ 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 import_core15.LWWMap ? map.getRecord(key) : null;
+    const oldRecord = map instanceof import_core19.LWWMap ? map.getRecord(key) : null;
     if (this.partitionService.isRelated(key)) {
-      if (map instanceof import_core15.LWWMap && payload.record) {
+      if (map instanceof import_core19.LWWMap && payload.record) {
         map.merge(key, payload.record);
-      } else if (map instanceof import_core15.ORMap) {
+      } else if (map instanceof import_core19.ORMap) {
         if (eventType === "OR_ADD" && payload.orRecord) {
           map.apply(key, payload.orRecord);
         } else if (eventType === "OR_REMOVE" && payload.orTag) {
@@ -10372,9 +11841,9 @@ var ServerCoordinator = class {
     if (!this.maps.has(name)) {
       let map;
       if (typeHint === "OR") {
-        map = new import_core15.ORMap(this.hlc);
+        map = new import_core19.ORMap(this.hlc);
       } else {
-        map = new import_core15.LWWMap(this.hlc);
+        map = new import_core19.LWWMap(this.hlc);
       }
       this.maps.set(name, map);
       if (this.storage) {
@@ -10397,7 +11866,7 @@ var ServerCoordinator = class {
     this.getMap(name, typeHint);
     const loadingPromise = this.mapLoadingPromises.get(name);
     const map = this.maps.get(name);
-    const mapSize = map instanceof import_core15.LWWMap ? Array.from(map.entries()).length : map instanceof import_core15.ORMap ? map.size : 0;
+    const mapSize = map instanceof import_core19.LWWMap ? Array.from(map.entries()).length : map instanceof import_core19.ORMap ? map.size : 0;
     logger.info({
       mapName: name,
       mapExisted,
@@ -10407,11 +11876,56 @@ var ServerCoordinator = class {
     if (loadingPromise) {
       logger.info({ mapName: name }, "[getMapAsync] Waiting for loadMapFromStorage...");
       await loadingPromise;
-      const newMapSize = map instanceof import_core15.LWWMap ? Array.from(map.entries()).length : map instanceof import_core15.ORMap ? map.size : 0;
+      const newMapSize = map instanceof import_core19.LWWMap ? Array.from(map.entries()).length : map instanceof import_core19.ORMap ? map.size : 0;
       logger.info({ mapName: name, mapSizeAfterLoad: newMapSize }, "[getMapAsync] Load completed");
     }
     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 import_core19.LWWMap)) {
+      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);
@@ -10433,16 +11947,16 @@ var ServerCoordinator = class {
       const currentMap = this.maps.get(name);
       if (!currentMap) return;
       let targetMap = currentMap;
-      if (isOR && currentMap instanceof import_core15.LWWMap) {
+      if (isOR && currentMap instanceof import_core19.LWWMap) {
         logger.info({ mapName: name }, "Map auto-detected as ORMap. Switching type.");
-        targetMap = new import_core15.ORMap(this.hlc);
+        targetMap = new import_core19.ORMap(this.hlc);
         this.maps.set(name, targetMap);
-      } else if (!isOR && currentMap instanceof import_core15.ORMap && typeHint !== "OR") {
+      } else if (!isOR && currentMap instanceof import_core19.ORMap && typeHint !== "OR") {
         logger.info({ mapName: name }, "Map auto-detected as LWWMap. Switching type.");
-        targetMap = new import_core15.LWWMap(this.hlc);
+        targetMap = new import_core19.LWWMap(this.hlc);
         this.maps.set(name, targetMap);
       }
-      if (targetMap instanceof import_core15.ORMap) {
+      if (targetMap instanceof import_core19.ORMap) {
         for (const [key, record] of records) {
           if (key === "__tombstones__") {
             const t = record;
@@ -10455,7 +11969,7 @@ var ServerCoordinator = class {
             }
           }
         }
-      } else if (targetMap instanceof import_core15.LWWMap) {
+      } else if (targetMap instanceof import_core19.LWWMap) {
         for (const [key, record] of records) {
           if (!record.type) {
             targetMap.merge(key, record);
@@ -10466,7 +11980,7 @@ var ServerCoordinator = class {
       if (count > 0) {
         logger.info({ mapName: name, count }, "Loaded records for map");
         this.queryRegistry.refreshSubscriptions(name, targetMap);
-        const mapSize = targetMap instanceof import_core15.ORMap ? targetMap.totalRecords : targetMap.size;
+        const mapSize = targetMap instanceof import_core19.ORMap ? targetMap.totalRecords : targetMap.size;
         this.metricsService.setMapSize(name, mapSize);
       }
     } catch (err) {
@@ -10548,7 +12062,7 @@ var ServerCoordinator = class {
   reportLocalHlc() {
     let minHlc = this.hlc.now();
     for (const client of this.clients.values()) {
-      if (import_core15.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
+      if (import_core19.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
         minHlc = client.lastActiveHlc;
       }
     }
@@ -10569,7 +12083,7 @@ var ServerCoordinator = class {
       let globalSafe = this.hlc.now();
       let initialized = false;
       for (const ts of this.gcReports.values()) {
-        if (!initialized || import_core15.HLC.compare(ts, globalSafe) < 0) {
+        if (!initialized || import_core19.HLC.compare(ts, globalSafe) < 0) {
           globalSafe = ts;
           initialized = true;
         }
@@ -10604,7 +12118,7 @@ var ServerCoordinator = class {
     logger.info({ olderThanMillis: olderThan.millis }, "Performing Garbage Collection");
     const now = Date.now();
     for (const [name, map] of this.maps) {
-      if (map instanceof import_core15.LWWMap) {
+      if (map instanceof import_core19.LWWMap) {
         for (const key of map.allKeys()) {
           const record = map.getRecord(key);
           if (record && record.value !== null && record.ttlMs) {
@@ -10656,7 +12170,7 @@ var ServerCoordinator = class {
             });
           }
         }
-      } else if (map instanceof import_core15.ORMap) {
+      } else if (map instanceof import_core19.ORMap) {
         const items = map.items;
         const tombstonesSet = map.tombstones;
         const tagsToExpire = [];
@@ -10759,17 +12273,17 @@ var ServerCoordinator = class {
   stringToWriteConcern(value) {
     switch (value) {
       case "FIRE_AND_FORGET":
-        return import_core15.WriteConcern.FIRE_AND_FORGET;
+        return import_core19.WriteConcern.FIRE_AND_FORGET;
       case "MEMORY":
-        return import_core15.WriteConcern.MEMORY;
+        return import_core19.WriteConcern.MEMORY;
       case "APPLIED":
-        return import_core15.WriteConcern.APPLIED;
+        return import_core19.WriteConcern.APPLIED;
       case "REPLICATED":
-        return import_core15.WriteConcern.REPLICATED;
+        return import_core19.WriteConcern.REPLICATED;
       case "PERSISTED":
-        return import_core15.WriteConcern.PERSISTED;
+        return import_core19.WriteConcern.PERSISTED;
       default:
-        return import_core15.WriteConcern.MEMORY;
+        return import_core19.WriteConcern.MEMORY;
     }
   }
   /**
@@ -10826,7 +12340,7 @@ var ServerCoordinator = class {
             }
           });
           if (op.id) {
-            this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
           }
         }
       }
@@ -10834,7 +12348,7 @@ var ServerCoordinator = class {
         this.broadcastBatch(batchedEvents, clientId);
         for (const op of ops) {
           if (op.id && this.partitionService.isLocalOwner(op.key)) {
-            this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
           }
         }
       }
@@ -10862,7 +12376,7 @@ var ServerCoordinator = class {
         const owner = this.partitionService.getOwner(op.key);
         await this.forwardOpAndWait(op, owner);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
         }
       }
     }
@@ -10870,7 +12384,7 @@ var ServerCoordinator = class {
       await this.broadcastBatchSync(batchedEvents, clientId);
       for (const op of ops) {
         if (op.id && this.partitionService.isLocalOwner(op.key)) {
-          this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
         }
       }
     }
@@ -10904,7 +12418,7 @@ var ServerCoordinator = class {
       return;
     }
     if (op.id) {
-      this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.APPLIED);
+      this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.APPLIED);
     }
     if (eventPayload) {
       batchedEvents.push({
@@ -10918,7 +12432,7 @@ var ServerCoordinator = class {
       try {
         await this.persistOpSync(op);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.PERSISTED);
+          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.PERSISTED);
         }
       } catch (err) {
         logger.error({ opId: op.id, err }, "Persistence failed");
@@ -11261,10 +12775,10 @@ var RateLimitInterceptor = class {
 };
 
 // src/utils/nativeStats.ts
-var import_core16 = require("@topgunbuild/core");
+var import_core20 = require("@topgunbuild/core");
 function getNativeModuleStatus() {
   return {
-    nativeHash: (0, import_core16.isUsingNativeHash)(),
+    nativeHash: (0, import_core20.isUsingNativeHash)(),
     sharedArrayBuffer: SharedMemoryManager.isAvailable()
   };
 }
@@ -11297,15 +12811,15 @@ function logNativeStatus() {
 }
 
 // src/cluster/ClusterCoordinator.ts
-var import_events9 = require("events");
-var import_core17 = require("@topgunbuild/core");
+var import_events13 = require("events");
+var import_core21 = require("@topgunbuild/core");
 var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
   gradualRebalancing: true,
-  migration: import_core17.DEFAULT_MIGRATION_CONFIG,
-  replication: import_core17.DEFAULT_REPLICATION_CONFIG,
+  migration: import_core21.DEFAULT_MIGRATION_CONFIG,
+  replication: import_core21.DEFAULT_REPLICATION_CONFIG,
   replicationEnabled: true
 };
-var ClusterCoordinator = class extends import_events9.EventEmitter {
+var ClusterCoordinator = class extends import_events13.EventEmitter {
   constructor(config) {
     super();
     this.replicationPipeline = null;
@@ -11670,12 +13184,12 @@ var ClusterCoordinator = class extends import_events9.EventEmitter {
 };
 
 // src/MapWithResolver.ts
-var import_core18 = require("@topgunbuild/core");
+var import_core22 = require("@topgunbuild/core");
 var MapWithResolver = class {
   constructor(config) {
     this.mapName = config.name;
-    this.hlc = new import_core18.HLC(config.nodeId);
-    this.map = new import_core18.LWWMap(this.hlc);
+    this.hlc = new import_core22.HLC(config.nodeId);
+    this.map = new import_core22.LWWMap(this.hlc);
     this.resolverService = config.resolverService;
     this.onRejection = config.onRejection;
   }
@@ -11931,7 +13445,7 @@ function mergeWithDefaults(userConfig) {
 }
 
 // src/config/MapFactory.ts
-var import_core19 = require("@topgunbuild/core");
+var import_core23 = require("@topgunbuild/core");
 var MapFactory = class {
   /**
    * Create a MapFactory.
@@ -11955,9 +13469,9 @@ var MapFactory = class {
   createLWWMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core19.LWWMap(hlc);
+      return new import_core23.LWWMap(hlc);
     }
-    const map = new import_core19.IndexedLWWMap(hlc);
+    const map = new import_core23.IndexedLWWMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToLWWMap(map, indexDef);
     }
@@ -11973,9 +13487,9 @@ var MapFactory = class {
   createORMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core19.ORMap(hlc);
+      return new import_core23.ORMap(hlc);
     }
-    const map = new import_core19.IndexedORMap(hlc);
+    const map = new import_core23.IndexedORMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToORMap(map, indexDef);
     }
@@ -12012,7 +13526,7 @@ var MapFactory = class {
    * Supports dot notation for nested paths.
    */
   createAttribute(path) {
-    return (0, import_core19.simpleAttribute)(path, (record) => {
+    return (0, import_core23.simpleAttribute)(path, (record) => {
       return this.getNestedValue(record, path);
     });
   }
@@ -12111,12 +13625,18 @@ var MapFactory = class {
   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,
@@ -12126,13 +13646,17 @@ var MapFactory = class {
   MapTasklet,
   MapWithResolver,
   MemoryServerAdapter,
+  MerkleTreeManager,
   MigrationManager,
   ObjectPool,
+  PartitionReassigner,
   PartitionService,
   PostgresAdapter,
   ProcessorSandbox,
   RateLimitInterceptor,
+  ReadReplicaHandler,
   ReduceTasklet,
+  RepairScheduler,
   ReplicationPipeline,
   SecurityManager,
   ServerCoordinator,