@topgunbuild/server 0.6.0 → 0.8.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,14 +59,19 @@ __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,
+  SearchCoordinator: () => SearchCoordinator,
   SecurityManager: () => SecurityManager,
   ServerCoordinator: () => ServerCoordinator,
   TaskletScheduler: () => TaskletScheduler,
@@ -95,7 +106,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_core20 = require("@topgunbuild/core");
 var jwt = __toESM(require("jsonwebtoken"));
 var crypto = __toESM(require("crypto"));
 
@@ -1211,6 +1222,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 +1401,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,239 +6689,1439 @@ 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}
-        })()
-      `;
-      const script = await this.getOrCompileScript(
+    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,
         isolate
@@ -7045,7 +8300,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 +8366,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 +8403,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 +8462,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 +8493,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 +8502,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 +8564,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 +8920,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 +8935,7 @@ function validateTableName(name) {
     );
   }
 }
-var EventJournalService = class extends import_core14.EventJournalImpl {
+var EventJournalService = class extends import_core18.EventJournalImpl {
   constructor(config) {
     super(config);
     this.pendingPersist = [];
@@ -7945,59 +9200,607 @@ var EventJournalService = class extends import_core14.EventJournalImpl {
     return parseInt(result.rows[0].count, 10);
   }
   /**
-   * Cleanup old events based on retention policy.
-   */
-  async cleanupOldEvents(retentionDays) {
-    const result = await this.pool.query(
-      `DELETE FROM ${this.tableName}
-       WHERE created_at < NOW() - ($1 || ' days')::INTERVAL
-       RETURNING sequence`,
-      [retentionDays]
-    );
-    const count = result.rowCount ?? 0;
-    if (count > 0) {
-      logger.info({ deletedCount: count, retentionDays }, "Cleaned up old journal events");
+   * Cleanup old events based on retention policy.
+   */
+  async cleanupOldEvents(retentionDays) {
+    const result = await this.pool.query(
+      `DELETE FROM ${this.tableName}
+       WHERE created_at < NOW() - ($1 || ' days')::INTERVAL
+       RETURNING sequence`,
+      [retentionDays]
+    );
+    const count = result.rowCount ?? 0;
+    if (count > 0) {
+      logger.info({ deletedCount: count, retentionDays }, "Cleaned up old journal events");
+    }
+    return count;
+  }
+  /**
+   * Start the periodic persistence timer.
+   */
+  startPersistTimer() {
+    this.persistTimer = setInterval(() => {
+      if (this.pendingPersist.length > 0) {
+        this.persistToStorage().catch((err) => {
+          logger.error({ err }, "Periodic persist failed");
+        });
+      }
+    }, this.persistIntervalMs);
+  }
+  /**
+   * Stop the periodic persistence timer.
+   */
+  stopPersistTimer() {
+    if (this.persistTimer) {
+      clearInterval(this.persistTimer);
+      this.persistTimer = void 0;
+    }
+  }
+  /**
+   * Dispose resources and persist remaining events.
+   */
+  dispose() {
+    this.stopPersistTimer();
+    if (this.pendingPersist.length > 0) {
+      this.persistToStorage().catch((err) => {
+        logger.error({ err }, "Final persist failed on dispose");
+      });
+    }
+    super.dispose();
+  }
+  /**
+   * Get pending persist count (for monitoring).
+   */
+  getPendingPersistCount() {
+    return this.pendingPersist.length;
+  }
+};
+
+// src/search/SearchCoordinator.ts
+var import_core19 = require("@topgunbuild/core");
+var SearchCoordinator = class {
+  constructor() {
+    /** Map name → FullTextIndex */
+    this.indexes = /* @__PURE__ */ new Map();
+    /** Map name → FullTextIndexConfig (for reference) */
+    this.configs = /* @__PURE__ */ new Map();
+    // ============================================
+    // Phase 11.1b: Live Search Subscription tracking
+    // ============================================
+    /** Subscription ID → SearchSubscription */
+    this.subscriptions = /* @__PURE__ */ new Map();
+    /** Map name → Set of subscription IDs */
+    this.subscriptionsByMap = /* @__PURE__ */ new Map();
+    /** Client ID → Set of subscription IDs */
+    this.subscriptionsByClient = /* @__PURE__ */ new Map();
+    // ============================================
+    // Phase 11.2: Notification Batching
+    // ============================================
+    /** Queue of pending notifications per map */
+    this.pendingNotifications = /* @__PURE__ */ new Map();
+    /** Timer for batching notifications */
+    this.notificationTimer = null;
+    /** Batch interval in milliseconds (~1 frame at 60fps) */
+    this.BATCH_INTERVAL = 16;
+    logger.debug("SearchCoordinator initialized");
+  }
+  /**
+   * Set the callback for sending updates to clients.
+   * Called by ServerCoordinator during initialization.
+   */
+  setSendUpdateCallback(callback) {
+    this.sendUpdate = callback;
+  }
+  /**
+   * Set the callback for sending batched updates to clients.
+   * When set, notifications are batched within BATCH_INTERVAL (16ms) window.
+   * Called by ServerCoordinator during initialization.
+   *
+   * @param callback - Function to call with batched updates
+   */
+  setSendBatchUpdateCallback(callback) {
+    this.sendBatchUpdate = callback;
+  }
+  /**
+   * Set the callback for retrieving document values.
+   * Called by ServerCoordinator during initialization.
+   */
+  setDocumentValueGetter(getter) {
+    this.getDocumentValue = getter;
+  }
+  /**
+   * Enable full-text search for a map.
+   *
+   * @param mapName - Name of the map to enable FTS for
+   * @param config - FTS configuration (fields, tokenizer, bm25 options)
+   */
+  enableSearch(mapName, config) {
+    if (this.indexes.has(mapName)) {
+      logger.warn({ mapName }, "FTS already enabled for map, replacing index");
+      this.indexes.delete(mapName);
+    }
+    const index = new import_core19.FullTextIndex(config);
+    this.indexes.set(mapName, index);
+    this.configs.set(mapName, config);
+    logger.info({ mapName, fields: config.fields }, "FTS enabled for map");
+  }
+  /**
+   * Disable full-text search for a map.
+   *
+   * @param mapName - Name of the map to disable FTS for
+   */
+  disableSearch(mapName) {
+    if (!this.indexes.has(mapName)) {
+      logger.warn({ mapName }, "FTS not enabled for map, nothing to disable");
+      return;
+    }
+    this.indexes.delete(mapName);
+    this.configs.delete(mapName);
+    logger.info({ mapName }, "FTS disabled for map");
+  }
+  /**
+   * Check if FTS is enabled for a map.
+   */
+  isSearchEnabled(mapName) {
+    return this.indexes.has(mapName);
+  }
+  /**
+   * Get enabled map names.
+   */
+  getEnabledMaps() {
+    return Array.from(this.indexes.keys());
+  }
+  /**
+   * Execute a one-shot search query.
+   *
+   * @param mapName - Name of the map to search
+   * @param query - Search query text
+   * @param options - Search options (limit, minScore, boost)
+   * @returns Search response payload
+   */
+  search(mapName, query, options) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Search requested for map without FTS enabled");
+      return {
+        requestId: "",
+        results: [],
+        totalCount: 0,
+        error: `Full-text search not enabled for map: ${mapName}`
+      };
+    }
+    try {
+      const searchResults = index.search(query, options);
+      const results = searchResults.map((result) => {
+        const value = this.getDocumentValue ? this.getDocumentValue(mapName, result.docId) : void 0;
+        return {
+          key: result.docId,
+          value,
+          score: result.score,
+          matchedTerms: result.matchedTerms || []
+        };
+      });
+      logger.debug(
+        { mapName, query, resultCount: results.length },
+        "Search executed"
+      );
+      return {
+        requestId: "",
+        results,
+        totalCount: searchResults.length
+      };
+    } catch (err) {
+      logger.error({ mapName, query, err }, "Search failed");
+      return {
+        requestId: "",
+        results: [],
+        totalCount: 0,
+        error: `Search failed: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Handle document set/update.
+   * Called by ServerCoordinator when data changes.
+   *
+   * @param mapName - Name of the map
+   * @param key - Document key
+   * @param value - Document value
+   */
+  onDataChange(mapName, key, value, changeType) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    if (changeType === "remove" || value === null || value === void 0) {
+      index.onRemove(key);
+    } else {
+      index.onSet(key, value);
+    }
+    this.notifySubscribers(mapName, key, value ?? null, changeType);
+  }
+  /**
+   * Build index from existing map entries.
+   * Called when FTS is enabled for a map that already has data.
+   *
+   * @param mapName - Name of the map
+   * @param entries - Iterator of [key, value] tuples
+   */
+  buildIndexFromEntries(mapName, entries) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Cannot build index: FTS not enabled for map");
+      return;
+    }
+    let count = 0;
+    for (const [key, value] of entries) {
+      if (value !== null) {
+        index.onSet(key, value);
+        count++;
+      }
+    }
+    logger.info({ mapName, documentCount: count }, "Index built from entries");
+  }
+  /**
+   * Get index statistics for monitoring.
+   */
+  getIndexStats(mapName) {
+    const index = this.indexes.get(mapName);
+    const config = this.configs.get(mapName);
+    if (!index || !config) {
+      return null;
+    }
+    return {
+      documentCount: index.getSize(),
+      fields: config.fields
+    };
+  }
+  /**
+   * Clear all indexes (for testing or shutdown).
+   */
+  clear() {
+    for (const index of this.indexes.values()) {
+      index.clear();
+    }
+    this.indexes.clear();
+    this.configs.clear();
+    this.subscriptions.clear();
+    this.subscriptionsByMap.clear();
+    this.subscriptionsByClient.clear();
+    this.pendingNotifications.clear();
+    if (this.notificationTimer) {
+      clearTimeout(this.notificationTimer);
+      this.notificationTimer = null;
+    }
+    logger.debug("SearchCoordinator cleared");
+  }
+  // ============================================
+  // Phase 11.1b: Live Search Subscription Methods
+  // ============================================
+  /**
+   * Subscribe to live search results.
+   * Returns initial results and tracks the subscription for delta updates.
+   *
+   * @param clientId - ID of the subscribing client
+   * @param subscriptionId - Unique subscription identifier
+   * @param mapName - Name of the map to search
+   * @param query - Search query text
+   * @param options - Search options (limit, minScore, boost)
+   * @returns Initial search results
+   */
+  subscribe(clientId, subscriptionId, mapName, query, options) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Subscribe requested for map without FTS enabled");
+      return [];
+    }
+    const queryTerms = index.tokenizeQuery(query);
+    const searchResults = index.search(query, options);
+    const currentResults = /* @__PURE__ */ new Map();
+    const results = [];
+    for (const result of searchResults) {
+      const value = this.getDocumentValue ? this.getDocumentValue(mapName, result.docId) : void 0;
+      currentResults.set(result.docId, {
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+      results.push({
+        key: result.docId,
+        value,
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+    }
+    const subscription = {
+      id: subscriptionId,
+      clientId,
+      mapName,
+      query,
+      queryTerms,
+      options: options || {},
+      currentResults
+    };
+    this.subscriptions.set(subscriptionId, subscription);
+    if (!this.subscriptionsByMap.has(mapName)) {
+      this.subscriptionsByMap.set(mapName, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByMap.get(mapName).add(subscriptionId);
+    if (!this.subscriptionsByClient.has(clientId)) {
+      this.subscriptionsByClient.set(clientId, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByClient.get(clientId).add(subscriptionId);
+    logger.debug(
+      { subscriptionId, clientId, mapName, query, resultCount: results.length },
+      "Search subscription created"
+    );
+    return results;
+  }
+  /**
+   * Unsubscribe from a live search.
+   *
+   * @param subscriptionId - Subscription to remove
+   */
+  unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      return;
+    }
+    this.subscriptions.delete(subscriptionId);
+    const mapSubs = this.subscriptionsByMap.get(subscription.mapName);
+    if (mapSubs) {
+      mapSubs.delete(subscriptionId);
+      if (mapSubs.size === 0) {
+        this.subscriptionsByMap.delete(subscription.mapName);
+      }
+    }
+    const clientSubs = this.subscriptionsByClient.get(subscription.clientId);
+    if (clientSubs) {
+      clientSubs.delete(subscriptionId);
+      if (clientSubs.size === 0) {
+        this.subscriptionsByClient.delete(subscription.clientId);
+      }
+    }
+    logger.debug({ subscriptionId }, "Search subscription removed");
+  }
+  /**
+   * Unsubscribe all subscriptions for a client.
+   * Called when a client disconnects.
+   *
+   * @param clientId - ID of the disconnected client
+   */
+  unsubscribeClient(clientId) {
+    const clientSubs = this.subscriptionsByClient.get(clientId);
+    if (!clientSubs) {
+      return;
+    }
+    const subscriptionIds = Array.from(clientSubs);
+    for (const subscriptionId of subscriptionIds) {
+      this.unsubscribe(subscriptionId);
+    }
+    logger.debug({ clientId, count: subscriptionIds.length }, "Client subscriptions cleared");
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Notify subscribers about a document change.
+   * Computes delta (ENTER/UPDATE/LEAVE) for each affected subscription.
+   *
+   * @param mapName - Name of the map that changed
+   * @param key - Document key that changed
+   * @param value - New document value (null if removed)
+   * @param changeType - Type of change
+   */
+  notifySubscribers(mapName, key, value, changeType) {
+    if (!this.sendUpdate) {
+      return;
+    }
+    const subscriptionIds = this.subscriptionsByMap.get(mapName);
+    if (!subscriptionIds || subscriptionIds.size === 0) {
+      return;
+    }
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    for (const subId of subscriptionIds) {
+      const sub = this.subscriptions.get(subId);
+      if (!sub) continue;
+      const wasInResults = sub.currentResults.has(key);
+      let isInResults = false;
+      let newScore = 0;
+      let matchedTerms = [];
+      logger.debug({ subId, key, wasInResults, changeType }, "Processing subscription update");
+      if (changeType !== "remove" && value !== null) {
+        const result = this.scoreDocument(sub, key, value, index);
+        if (result && result.score >= (sub.options.minScore ?? 0)) {
+          isInResults = true;
+          newScore = result.score;
+          matchedTerms = result.matchedTerms;
+        }
+      }
+      let updateType = null;
+      if (!wasInResults && isInResults) {
+        updateType = "ENTER";
+        sub.currentResults.set(key, { score: newScore, matchedTerms });
+      } else if (wasInResults && !isInResults) {
+        updateType = "LEAVE";
+        sub.currentResults.delete(key);
+      } else if (wasInResults && isInResults) {
+        const old = sub.currentResults.get(key);
+        if (Math.abs(old.score - newScore) > 1e-4 || changeType === "update") {
+          updateType = "UPDATE";
+          sub.currentResults.set(key, { score: newScore, matchedTerms });
+        }
+      }
+      logger.debug({ subId, key, wasInResults, isInResults, updateType, newScore }, "Update decision");
+      if (updateType) {
+        this.sendUpdate(
+          sub.clientId,
+          subId,
+          key,
+          value,
+          newScore,
+          matchedTerms,
+          updateType
+        );
+      }
+    }
+  }
+  /**
+   * Score a single document against a subscription's query.
+   *
+   * OPTIMIZED: O(Q × D) complexity instead of O(N) full index scan.
+   * Uses pre-tokenized queryTerms and FullTextIndex.scoreSingleDocument().
+   *
+   * @param subscription - The subscription containing query and cached queryTerms
+   * @param key - Document key
+   * @param value - Document value
+   * @param index - The FullTextIndex for this map
+   * @returns Scored result or null if document doesn't match
+   */
+  scoreDocument(subscription, key, value, index) {
+    const result = index.scoreSingleDocument(key, subscription.queryTerms, value);
+    if (!result) {
+      return null;
+    }
+    return {
+      score: result.score,
+      matchedTerms: result.matchedTerms || []
+    };
+  }
+  // ============================================
+  // Phase 11.2: Notification Batching Methods
+  // ============================================
+  /**
+   * Queue a notification for batched processing.
+   * Notifications are collected and processed together after BATCH_INTERVAL.
+   *
+   * @param mapName - Name of the map that changed
+   * @param key - Document key that changed
+   * @param value - New document value (null if removed)
+   * @param changeType - Type of change
+   */
+  queueNotification(mapName, key, value, changeType) {
+    if (!this.sendBatchUpdate) {
+      this.notifySubscribers(mapName, key, value, changeType);
+      return;
     }
-    return count;
+    const notification = { key, value, changeType };
+    if (!this.pendingNotifications.has(mapName)) {
+      this.pendingNotifications.set(mapName, []);
+    }
+    this.pendingNotifications.get(mapName).push(notification);
+    this.scheduleNotificationFlush();
   }
   /**
-   * Start the periodic persistence timer.
+   * Schedule a flush of pending notifications.
+   * Uses setTimeout to batch notifications within BATCH_INTERVAL window.
    */
-  startPersistTimer() {
-    this.persistTimer = setInterval(() => {
-      if (this.pendingPersist.length > 0) {
-        this.persistToStorage().catch((err) => {
-          logger.error({ err }, "Periodic persist failed");
-        });
-      }
-    }, this.persistIntervalMs);
+  scheduleNotificationFlush() {
+    if (this.notificationTimer) {
+      return;
+    }
+    this.notificationTimer = setTimeout(() => {
+      this.flushNotifications();
+      this.notificationTimer = null;
+    }, this.BATCH_INTERVAL);
   }
   /**
-   * Stop the periodic persistence timer.
+   * Flush all pending notifications.
+   * Processes each map's notifications and sends batched updates.
    */
-  stopPersistTimer() {
-    if (this.persistTimer) {
-      clearInterval(this.persistTimer);
-      this.persistTimer = void 0;
+  flushNotifications() {
+    if (this.pendingNotifications.size === 0) {
+      return;
     }
+    for (const [mapName, notifications] of this.pendingNotifications) {
+      this.processBatchedNotifications(mapName, notifications);
+    }
+    this.pendingNotifications.clear();
   }
   /**
-   * Dispose resources and persist remaining events.
+   * Process batched notifications for a single map.
+   * Computes updates for each subscription and sends as a batch.
+   *
+   * @param mapName - Name of the map
+   * @param notifications - Array of pending notifications
    */
-  dispose() {
-    this.stopPersistTimer();
-    if (this.pendingPersist.length > 0) {
-      this.persistToStorage().catch((err) => {
-        logger.error({ err }, "Final persist failed on dispose");
-      });
+  processBatchedNotifications(mapName, notifications) {
+    const subscriptionIds = this.subscriptionsByMap.get(mapName);
+    if (!subscriptionIds || subscriptionIds.size === 0) {
+      return;
+    }
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    for (const subId of subscriptionIds) {
+      const sub = this.subscriptions.get(subId);
+      if (!sub) continue;
+      const updates = [];
+      for (const { key, value, changeType } of notifications) {
+        const update = this.computeSubscriptionUpdate(sub, key, value, changeType, index);
+        if (update) {
+          updates.push(update);
+        }
+      }
+      if (updates.length > 0 && this.sendBatchUpdate) {
+        this.sendBatchUpdate(sub.clientId, subId, updates);
+      }
     }
-    super.dispose();
   }
   /**
-   * Get pending persist count (for monitoring).
-   */
-  getPendingPersistCount() {
-    return this.pendingPersist.length;
+   * Compute the update for a single document change against a subscription.
+   * Returns null if no update is needed.
+   *
+   * @param subscription - The subscription to check
+   * @param key - Document key
+   * @param value - Document value (null if removed)
+   * @param changeType - Type of change
+   * @param index - The FullTextIndex for this map
+   * @returns BatchedUpdate or null
+   */
+  computeSubscriptionUpdate(subscription, key, value, changeType, index) {
+    const wasInResults = subscription.currentResults.has(key);
+    let isInResults = false;
+    let newScore = 0;
+    let matchedTerms = [];
+    if (changeType !== "remove" && value !== null) {
+      const result = this.scoreDocument(subscription, key, value, index);
+      if (result && result.score >= (subscription.options.minScore ?? 0)) {
+        isInResults = true;
+        newScore = result.score;
+        matchedTerms = result.matchedTerms;
+      }
+    }
+    let updateType = null;
+    if (!wasInResults && isInResults) {
+      updateType = "ENTER";
+      subscription.currentResults.set(key, { score: newScore, matchedTerms });
+    } else if (wasInResults && !isInResults) {
+      updateType = "LEAVE";
+      subscription.currentResults.delete(key);
+    } else if (wasInResults && isInResults) {
+      const old = subscription.currentResults.get(key);
+      if (Math.abs(old.score - newScore) > 1e-4 || changeType === "update") {
+        updateType = "UPDATE";
+        subscription.currentResults.set(key, { score: newScore, matchedTerms });
+      }
+    }
+    if (!updateType) {
+      return null;
+    }
+    return {
+      key,
+      value,
+      score: newScore,
+      matchedTerms,
+      type: updateType
+    };
   }
 };
 
@@ -8027,7 +9830,7 @@ var ServerCoordinator = class {
       this._readyResolve = resolve;
     });
     this._nodeId = config.nodeId;
-    this.hlc = new import_core15.HLC(config.nodeId);
+    this.hlc = new import_core20.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 +9972,8 @@ var ServerCoordinator = class {
           this.cluster,
           this.partitionService,
           {
-            ...import_core15.DEFAULT_REPLICATION_CONFIG,
-            defaultConsistency: config.defaultConsistency ?? import_core15.ConsistencyLevel.EVENTUAL,
+            ...import_core20.DEFAULT_REPLICATION_CONFIG,
+            defaultConsistency: config.defaultConsistency ?? import_core20.ConsistencyLevel.EVENTUAL,
             ...config.replicationConfig
           }
         );
@@ -8212,6 +10015,80 @@ 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_core20.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.searchCoordinator = new SearchCoordinator();
+      this.searchCoordinator.setDocumentValueGetter((mapName, key) => {
+        const map = this.maps.get(mapName);
+        if (!map) return void 0;
+        return map.get(key);
+      });
+      this.searchCoordinator.setSendUpdateCallback((clientId, subscriptionId, key, value, score, matchedTerms, type) => {
+        const client = this.clients.get(clientId);
+        if (client) {
+          client.writer.write({
+            type: "SEARCH_UPDATE",
+            payload: {
+              subscriptionId,
+              key,
+              value,
+              score,
+              matchedTerms,
+              type
+            }
+          });
+        }
+      });
+      if (config.fullTextSearch) {
+        for (const [mapName, ftsConfig] of Object.entries(config.fullTextSearch)) {
+          this.searchCoordinator.enableSearch(mapName, ftsConfig);
+          logger.info({ mapName, fields: ftsConfig.fields }, "FTS enabled for map");
+        }
+      }
       this.systemManager = new SystemManager(
         this.cluster,
         this.metricsService,
@@ -8235,6 +10112,7 @@ var ServerCoordinator = class {
     if (this.storage) {
       this.storage.initialize().then(() => {
         logger.info("Storage adapter initialized");
+        this.backfillSearchIndexes();
       }).catch((err) => {
         logger.error({ err }, "Failed to initialize storage");
       });
@@ -8242,6 +10120,36 @@ var ServerCoordinator = class {
     this.startGarbageCollection();
     this.startHeartbeatCheck();
   }
+  /**
+   * Populate FTS indexes from existing map data.
+   * Called after storage initialization.
+   */
+  async backfillSearchIndexes() {
+    const enabledMaps = this.searchCoordinator.getEnabledMaps();
+    const promises2 = enabledMaps.map(async (mapName) => {
+      try {
+        await this.getMapAsync(mapName);
+        const map = this.maps.get(mapName);
+        if (!map) return;
+        if (map instanceof import_core20.LWWMap) {
+          const entries = Array.from(map.entries());
+          if (entries.length > 0) {
+            logger.info({ mapName, count: entries.length }, "Backfilling FTS index");
+            this.searchCoordinator.buildIndexFromEntries(
+              mapName,
+              map.entries()
+            );
+          }
+        } else {
+          logger.warn({ mapName }, "FTS backfill skipped: Map type not supported (only LWWMap)");
+        }
+      } catch (err) {
+        logger.error({ mapName, err }, "Failed to backfill FTS index");
+      }
+    });
+    await Promise.all(promises2);
+    logger.info("FTS backfill completed");
+  }
   /** Wait for server to be fully ready (ports assigned) */
   ready() {
     return this._readyPromise;
@@ -8308,8 +10216,137 @@ var ServerCoordinator = class {
   getTaskletScheduler() {
     return this.taskletScheduler;
   }
+  // === Phase 11.1: Full-Text Search Public API ===
+  /**
+   * Enable full-text search for a map.
+   * Can be called at runtime to enable FTS dynamically.
+   *
+   * @param mapName - Name of the map to enable FTS for
+   * @param config - FTS configuration (fields, tokenizer, bm25 options)
+   */
+  enableFullTextSearch(mapName, config) {
+    this.searchCoordinator.enableSearch(mapName, config);
+    const map = this.maps.get(mapName);
+    if (map) {
+      const entries = [];
+      if (map instanceof import_core20.LWWMap) {
+        for (const [key, value] of map.entries()) {
+          entries.push([key, value]);
+        }
+      } else if (map instanceof import_core20.ORMap) {
+        for (const key of map.allKeys()) {
+          const values = map.get(key);
+          const value = values.length > 0 ? values[0] : null;
+          entries.push([key, value]);
+        }
+      }
+      this.searchCoordinator.buildIndexFromEntries(mapName, entries);
+    }
+  }
+  /**
+   * Disable full-text search for a map.
+   *
+   * @param mapName - Name of the map to disable FTS for
+   */
+  disableFullTextSearch(mapName) {
+    this.searchCoordinator.disableSearch(mapName);
+  }
+  /**
+   * Check if full-text search is enabled for a map.
+   *
+   * @param mapName - Name of the map to check
+   * @returns True if FTS is enabled
+   */
+  isFullTextSearchEnabled(mapName) {
+    return this.searchCoordinator.isSearchEnabled(mapName);
+  }
+  /**
+   * Get FTS index statistics for a map.
+   *
+   * @param mapName - Name of the map
+   * @returns Index stats or null if FTS not enabled
+   */
+  getFullTextSearchStats(mapName) {
+    return this.searchCoordinator.getIndexStats(mapName);
+  }
+  /**
+   * 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 +10354,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_core20.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.clients.values()) {
       try {
         if (client.socket.readyState === import_ws3.WebSocket.OPEN) {
@@ -8342,6 +10379,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 +10487,7 @@ var ServerCoordinator = class {
           buf = Buffer.from(message);
         }
         try {
-          data = (0, import_core15.deserialize)(buf);
+          data = (0, import_core20.deserialize)(buf);
         } catch (e) {
           try {
             const text = Buffer.isBuffer(buf) ? buf.toString() : new TextDecoder().decode(buf);
@@ -8482,6 +10527,7 @@ var ServerCoordinator = class {
       this.lockManager.handleClientDisconnect(clientId);
       this.topicManager.unsubscribeAll(clientId);
       this.counterHandler.unsubscribeAll(clientId);
+      this.searchCoordinator.unsubscribeClient(clientId);
       const members = this.cluster.getMembers();
       for (const memberId of members) {
         if (!this.cluster.isLocal(memberId)) {
@@ -8494,10 +10540,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_core20.serialize)({ type: "AUTH_REQUIRED" }));
   }
   async handleMessage(client, rawMessage) {
-    const parseResult = import_core15.MessageSchema.safeParse(rawMessage);
+    const parseResult = import_core20.MessageSchema.safeParse(rawMessage);
     if (!parseResult.success) {
       logger.error({ clientId: client.id, error: parseResult.error }, "Invalid message format from client");
       client.writer.write({
@@ -8557,7 +10603,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_core20.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 +10808,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_core20.LWWMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -8775,7 +10846,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_core20.LWWMap) {
             const treeForBucket = mapForBucket.getMerkleTree();
             const buckets = treeForBucket.getBuckets(path);
             const node = treeForBucket.getNode(path);
@@ -9157,7 +11228,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_core20.ORMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -9194,7 +11265,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_core20.ORMap) {
             const tree = mapForBucket.getMerkleTree();
             const buckets = tree.getBuckets(path);
             const isLeaf = tree.isLeaf(path);
@@ -9238,7 +11309,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_core20.ORMap) {
             const entries = [];
             const allTombstones = mapForDiff.getTombstones();
             for (const key of keys) {
@@ -9270,7 +11341,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_core20.ORMap) {
             let totalAdded = 0;
             let totalUpdated = 0;
             for (const entry of pushEntries) {
@@ -9398,6 +11469,106 @@ var ServerCoordinator = class {
         });
         break;
       }
+      // Phase 11.1: Full-Text Search
+      case "SEARCH": {
+        const { requestId: searchReqId, mapName: searchMapName, query: searchQuery, options: searchOptions } = message.payload;
+        if (!this.securityManager.checkPermission(client.principal, searchMapName, "READ")) {
+          logger.warn({ clientId: client.id, mapName: searchMapName }, "Access Denied: SEARCH");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: searchReqId,
+              results: [],
+              totalCount: 0,
+              error: `Access denied for map: ${searchMapName}`
+            }
+          });
+          break;
+        }
+        if (!this.searchCoordinator.isSearchEnabled(searchMapName)) {
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: searchReqId,
+              results: [],
+              totalCount: 0,
+              error: `Full-text search not enabled for map: ${searchMapName}`
+            }
+          });
+          break;
+        }
+        const searchResult = this.searchCoordinator.search(searchMapName, searchQuery, searchOptions);
+        searchResult.requestId = searchReqId;
+        logger.debug({
+          clientId: client.id,
+          mapName: searchMapName,
+          query: searchQuery,
+          resultCount: searchResult.results.length
+        }, "Search executed");
+        client.writer.write({
+          type: "SEARCH_RESP",
+          payload: searchResult
+        });
+        break;
+      }
+      // Phase 11.1b: Live Search Subscriptions
+      case "SEARCH_SUB": {
+        const { subscriptionId, mapName: subMapName, query: subQuery, options: subOptions } = message.payload;
+        if (!this.securityManager.checkPermission(client.principal, subMapName, "READ")) {
+          logger.warn({ clientId: client.id, mapName: subMapName }, "Access Denied: SEARCH_SUB");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: subscriptionId,
+              results: [],
+              totalCount: 0,
+              error: `Access denied for map: ${subMapName}`
+            }
+          });
+          break;
+        }
+        if (!this.searchCoordinator.isSearchEnabled(subMapName)) {
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: subscriptionId,
+              results: [],
+              totalCount: 0,
+              error: `Full-text search not enabled for map: ${subMapName}`
+            }
+          });
+          break;
+        }
+        const initialResults = this.searchCoordinator.subscribe(
+          client.id,
+          subscriptionId,
+          subMapName,
+          subQuery,
+          subOptions
+        );
+        logger.debug({
+          clientId: client.id,
+          subscriptionId,
+          mapName: subMapName,
+          query: subQuery,
+          resultCount: initialResults.length
+        }, "Search subscription created");
+        client.writer.write({
+          type: "SEARCH_RESP",
+          payload: {
+            requestId: subscriptionId,
+            results: initialResults,
+            totalCount: initialResults.length
+          }
+        });
+        break;
+      }
+      case "SEARCH_UNSUB": {
+        const { subscriptionId: unsubId } = message.payload;
+        this.searchCoordinator.unsubscribe(unsubId);
+        logger.debug({ clientId: client.id, subscriptionId: unsubId }, "Search unsubscription");
+        break;
+      }
       default:
         logger.warn({ type: message.type }, "Unknown message type");
     }
@@ -9411,7 +11582,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_core20.HLC.parse(op.orTag);
         } catch (e) {
         }
       }
@@ -9435,7 +11606,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 +11679,7 @@ var ServerCoordinator = class {
         client.writer.write({ ...message, payload: newPayload });
       }
     } else {
-      const msgData = (0, import_core15.serialize)(message);
+      const msgData = (0, import_core20.serialize)(message);
       for (const [id, client] of this.clients) {
         if (id !== excludeClientId && client.socket.readyState === 1) {
           client.writer.writeRaw(msgData);
@@ -9586,7 +11757,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core15.serialize)(batchMessage);
+      const serializedBatch = (0, import_core20.serialize)(batchMessage);
       for (const client of clients) {
         try {
           client.writer.writeRaw(serializedBatch);
@@ -9671,7 +11842,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core15.serialize)(batchMessage);
+      const serializedBatch = (0, import_core20.serialize)(batchMessage);
       for (const client of clients) {
         sendPromises.push(new Promise((resolve, reject) => {
           try {
@@ -9702,7 +11873,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 +11987,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 +12040,7 @@ var ServerCoordinator = class {
     const localQuery = { ...query };
     delete localQuery.offset;
     delete localQuery.limit;
-    if (map instanceof import_core15.IndexedLWWMap) {
+    if (map instanceof import_core20.IndexedLWWMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const entries = map.queryEntries(coreQuery);
@@ -9827,7 +12050,7 @@ var ServerCoordinator = class {
         });
       }
     }
-    if (map instanceof import_core15.IndexedORMap) {
+    if (map instanceof import_core20.IndexedORMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const results = map.query(coreQuery);
@@ -9835,14 +12058,14 @@ var ServerCoordinator = class {
       }
     }
     const records = /* @__PURE__ */ new Map();
-    if (map instanceof import_core15.LWWMap) {
+    if (map instanceof import_core20.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_core20.ORMap) {
       const items = map.items;
       for (const key of items.keys()) {
         const values = map.get(key);
@@ -9990,11 +12213,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_core20.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_core20.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 +12228,7 @@ var ServerCoordinator = class {
       mapName: op.mapName,
       key: op.key
     };
-    if (map instanceof import_core15.LWWMap) {
+    if (map instanceof import_core20.LWWMap) {
       oldRecord = map.getRecord(op.key);
       if (this.conflictResolverHandler.hasResolvers(op.mapName)) {
         const mergeResult = await this.conflictResolverHandler.mergeWithResolver(
@@ -10033,7 +12256,7 @@ var ServerCoordinator = class {
         eventPayload.eventType = "UPDATED";
         eventPayload.record = op.record;
       }
-    } else if (map instanceof import_core15.ORMap) {
+    } else if (map instanceof import_core20.ORMap) {
       oldRecord = map.getRecords(op.key);
       if (op.opType === "OR_ADD") {
         map.apply(op.key, op.orRecord);
@@ -10049,7 +12272,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_core20.ORMap ? map.totalRecords : map.size;
     this.metricsService.setMapSize(op.mapName, mapSize);
     if (this.storage) {
       if (recordToStore) {
@@ -10078,6 +12301,16 @@ 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);
+    }
+    if (this.searchCoordinator.isSearchEnabled(op.mapName)) {
+      const isRemove = op.opType === "REMOVE" || op.record && op.record.value === null;
+      const value = isRemove ? null : op.record?.value ?? op.orRecord?.value;
+      const changeType = isRemove ? "remove" : oldRecord ? "update" : "add";
+      this.searchCoordinator.onDataChange(op.mapName, op.key, value, changeType);
+    }
     return { eventPayload, oldRecord };
   }
   /**
@@ -10205,7 +12438,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 +12581,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_core20.LWWMap ? map.getRecord(key) : null;
     if (this.partitionService.isRelated(key)) {
-      if (map instanceof import_core15.LWWMap && payload.record) {
+      if (map instanceof import_core20.LWWMap && payload.record) {
         map.merge(key, payload.record);
-      } else if (map instanceof import_core15.ORMap) {
+      } else if (map instanceof import_core20.ORMap) {
         if (eventType === "OR_ADD" && payload.orRecord) {
           map.apply(key, payload.orRecord);
         } else if (eventType === "OR_REMOVE" && payload.orTag) {
@@ -10372,9 +12609,9 @@ var ServerCoordinator = class {
     if (!this.maps.has(name)) {
       let map;
       if (typeHint === "OR") {
-        map = new import_core15.ORMap(this.hlc);
+        map = new import_core20.ORMap(this.hlc);
       } else {
-        map = new import_core15.LWWMap(this.hlc);
+        map = new import_core20.LWWMap(this.hlc);
       }
       this.maps.set(name, map);
       if (this.storage) {
@@ -10397,7 +12634,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_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.ORMap ? map.size : 0;
     logger.info({
       mapName: name,
       mapExisted,
@@ -10407,11 +12644,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_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.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_core20.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 +12715,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_core20.LWWMap) {
         logger.info({ mapName: name }, "Map auto-detected as ORMap. Switching type.");
-        targetMap = new import_core15.ORMap(this.hlc);
+        targetMap = new import_core20.ORMap(this.hlc);
         this.maps.set(name, targetMap);
-      } else if (!isOR && currentMap instanceof import_core15.ORMap && typeHint !== "OR") {
+      } else if (!isOR && currentMap instanceof import_core20.ORMap && typeHint !== "OR") {
         logger.info({ mapName: name }, "Map auto-detected as LWWMap. Switching type.");
-        targetMap = new import_core15.LWWMap(this.hlc);
+        targetMap = new import_core20.LWWMap(this.hlc);
         this.maps.set(name, targetMap);
       }
-      if (targetMap instanceof import_core15.ORMap) {
+      if (targetMap instanceof import_core20.ORMap) {
         for (const [key, record] of records) {
           if (key === "__tombstones__") {
             const t = record;
@@ -10455,7 +12737,7 @@ var ServerCoordinator = class {
             }
           }
         }
-      } else if (targetMap instanceof import_core15.LWWMap) {
+      } else if (targetMap instanceof import_core20.LWWMap) {
         for (const [key, record] of records) {
           if (!record.type) {
             targetMap.merge(key, record);
@@ -10466,7 +12748,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_core20.ORMap ? targetMap.totalRecords : targetMap.size;
         this.metricsService.setMapSize(name, mapSize);
       }
     } catch (err) {
@@ -10548,7 +12830,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_core20.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
         minHlc = client.lastActiveHlc;
       }
     }
@@ -10569,7 +12851,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_core20.HLC.compare(ts, globalSafe) < 0) {
           globalSafe = ts;
           initialized = true;
         }
@@ -10604,7 +12886,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_core20.LWWMap) {
         for (const key of map.allKeys()) {
           const record = map.getRecord(key);
           if (record && record.value !== null && record.ttlMs) {
@@ -10656,7 +12938,7 @@ var ServerCoordinator = class {
             });
           }
         }
-      } else if (map instanceof import_core15.ORMap) {
+      } else if (map instanceof import_core20.ORMap) {
         const items = map.items;
         const tombstonesSet = map.tombstones;
         const tagsToExpire = [];
@@ -10759,17 +13041,17 @@ var ServerCoordinator = class {
   stringToWriteConcern(value) {
     switch (value) {
       case "FIRE_AND_FORGET":
-        return import_core15.WriteConcern.FIRE_AND_FORGET;
+        return import_core20.WriteConcern.FIRE_AND_FORGET;
       case "MEMORY":
-        return import_core15.WriteConcern.MEMORY;
+        return import_core20.WriteConcern.MEMORY;
       case "APPLIED":
-        return import_core15.WriteConcern.APPLIED;
+        return import_core20.WriteConcern.APPLIED;
       case "REPLICATED":
-        return import_core15.WriteConcern.REPLICATED;
+        return import_core20.WriteConcern.REPLICATED;
       case "PERSISTED":
-        return import_core15.WriteConcern.PERSISTED;
+        return import_core20.WriteConcern.PERSISTED;
       default:
-        return import_core15.WriteConcern.MEMORY;
+        return import_core20.WriteConcern.MEMORY;
     }
   }
   /**
@@ -10826,7 +13108,7 @@ var ServerCoordinator = class {
             }
           });
           if (op.id) {
-            this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
           }
         }
       }
@@ -10834,7 +13116,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_core20.WriteConcern.REPLICATED);
           }
         }
       }
@@ -10862,7 +13144,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_core20.WriteConcern.REPLICATED);
         }
       }
     }
@@ -10870,7 +13152,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_core20.WriteConcern.REPLICATED);
         }
       }
     }
@@ -10904,7 +13186,7 @@ var ServerCoordinator = class {
       return;
     }
     if (op.id) {
-      this.writeAckManager.notifyLevel(op.id, import_core15.WriteConcern.APPLIED);
+      this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.APPLIED);
     }
     if (eventPayload) {
       batchedEvents.push({
@@ -10918,7 +13200,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_core20.WriteConcern.PERSISTED);
         }
       } catch (err) {
         logger.error({ opId: op.id, err }, "Persistence failed");
@@ -11261,10 +13543,10 @@ var RateLimitInterceptor = class {
 };
 
 // src/utils/nativeStats.ts
-var import_core16 = require("@topgunbuild/core");
+var import_core21 = require("@topgunbuild/core");
 function getNativeModuleStatus() {
   return {
-    nativeHash: (0, import_core16.isUsingNativeHash)(),
+    nativeHash: (0, import_core21.isUsingNativeHash)(),
     sharedArrayBuffer: SharedMemoryManager.isAvailable()
   };
 }
@@ -11297,15 +13579,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_core22 = require("@topgunbuild/core");
 var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
   gradualRebalancing: true,
-  migration: import_core17.DEFAULT_MIGRATION_CONFIG,
-  replication: import_core17.DEFAULT_REPLICATION_CONFIG,
+  migration: import_core22.DEFAULT_MIGRATION_CONFIG,
+  replication: import_core22.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 +13952,12 @@ var ClusterCoordinator = class extends import_events9.EventEmitter {
 };
 
 // src/MapWithResolver.ts
-var import_core18 = require("@topgunbuild/core");
+var import_core23 = 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_core23.HLC(config.nodeId);
+    this.map = new import_core23.LWWMap(this.hlc);
     this.resolverService = config.resolverService;
     this.onRejection = config.onRejection;
   }
@@ -11931,7 +14213,7 @@ function mergeWithDefaults(userConfig) {
 }
 
 // src/config/MapFactory.ts
-var import_core19 = require("@topgunbuild/core");
+var import_core24 = require("@topgunbuild/core");
 var MapFactory = class {
   /**
    * Create a MapFactory.
@@ -11955,9 +14237,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_core24.LWWMap(hlc);
     }
-    const map = new import_core19.IndexedLWWMap(hlc);
+    const map = new import_core24.IndexedLWWMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToLWWMap(map, indexDef);
     }
@@ -11973,9 +14255,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_core24.ORMap(hlc);
     }
-    const map = new import_core19.IndexedORMap(hlc);
+    const map = new import_core24.IndexedORMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToORMap(map, indexDef);
     }
@@ -12012,7 +14294,7 @@ var MapFactory = class {
    * Supports dot notation for nested paths.
    */
   createAttribute(path) {
-    return (0, import_core19.simpleAttribute)(path, (record) => {
+    return (0, import_core24.simpleAttribute)(path, (record) => {
       return this.getNestedValue(record, path);
     });
   }
@@ -12111,12 +14393,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,14 +14414,19 @@ var MapFactory = class {
   MapTasklet,
   MapWithResolver,
   MemoryServerAdapter,
+  MerkleTreeManager,
   MigrationManager,
   ObjectPool,
+  PartitionReassigner,
   PartitionService,
   PostgresAdapter,
   ProcessorSandbox,
   RateLimitInterceptor,
+  ReadReplicaHandler,
   ReduceTasklet,
+  RepairScheduler,
   ReplicationPipeline,
+  SearchCoordinator,
   SecurityManager,
   ServerCoordinator,
   TaskletScheduler,