@topgunbuild/server 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ import { createServer as createHttpServer } from "http";
 import { createServer as createHttpsServer } from "https";
 import { readFileSync as readFileSync2 } from "fs";
 import { WebSocketServer as WebSocketServer2, WebSocket as WebSocket3 } from "ws";
-import { HLC, LWWMap as LWWMap2, ORMap as ORMap2, serialize as serialize3, deserialize, MessageSchema, WriteConcern as WriteConcern2 } from "@topgunbuild/core";
+import { HLC, LWWMap as LWWMap2, ORMap as ORMap2, serialize as serialize4, deserialize, MessageSchema, WriteConcern as WriteConcern2, ConsistencyLevel as ConsistencyLevel2, DEFAULT_REPLICATION_CONFIG as DEFAULT_REPLICATION_CONFIG2 } from "@topgunbuild/core";
 import * as jwt from "jsonwebtoken";
 import * as crypto from "crypto";
 
@@ -570,11 +570,268 @@ var TopicManager = class {
 
 // src/cluster/ClusterManager.ts
 import { WebSocket, WebSocketServer } from "ws";
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 import * as dns from "dns";
 import { readFileSync } from "fs";
 import * as https from "https";
-var ClusterManager = class extends EventEmitter {
+
+// src/cluster/FailureDetector.ts
+import { EventEmitter } from "events";
+var DEFAULT_FAILURE_DETECTOR_CONFIG = {
+  heartbeatIntervalMs: 1e3,
+  suspicionTimeoutMs: 5e3,
+  confirmationTimeoutMs: 1e4,
+  phiThreshold: 8,
+  minSamples: 10,
+  maxSamples: 100,
+  initialHeartbeatIntervalMs: 1e3
+};
+var FailureDetector = class extends EventEmitter {
+  constructor(config = {}) {
+    super();
+    this.nodeStates = /* @__PURE__ */ new Map();
+    this.monitoringNodes = /* @__PURE__ */ new Set();
+    this.confirmationTimers = /* @__PURE__ */ new Map();
+    this.started = false;
+    this.config = { ...DEFAULT_FAILURE_DETECTOR_CONFIG, ...config };
+  }
+  /**
+   * Start the failure detector monitoring loop.
+   */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.checkTimer = setInterval(() => {
+      this.checkAllNodes();
+    }, this.config.heartbeatIntervalMs);
+    logger.info({ config: this.config }, "FailureDetector started");
+  }
+  /**
+   * Stop the failure detector and clean up.
+   */
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+    for (const timer of this.confirmationTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.confirmationTimers.clear();
+    logger.info("FailureDetector stopped");
+  }
+  /**
+   * Start monitoring a node.
+   */
+  startMonitoring(nodeId) {
+    if (this.monitoringNodes.has(nodeId)) return;
+    this.monitoringNodes.add(nodeId);
+    this.nodeStates.set(nodeId, {
+      lastHeartbeat: Date.now(),
+      intervalHistory: [],
+      isSuspected: false,
+      isConfirmedFailed: false
+    });
+    logger.debug({ nodeId }, "Started monitoring node");
+  }
+  /**
+   * Stop monitoring a node.
+   */
+  stopMonitoring(nodeId) {
+    this.monitoringNodes.delete(nodeId);
+    this.nodeStates.delete(nodeId);
+    const timer = this.confirmationTimers.get(nodeId);
+    if (timer) {
+      clearTimeout(timer);
+      this.confirmationTimers.delete(nodeId);
+    }
+    logger.debug({ nodeId }, "Stopped monitoring node");
+  }
+  /**
+   * Record a heartbeat from a node.
+   * This updates the node's state and clears any suspicion.
+   */
+  recordHeartbeat(nodeId) {
+    const state = this.nodeStates.get(nodeId);
+    if (!state) {
+      this.startMonitoring(nodeId);
+      return;
+    }
+    const now = Date.now();
+    const interval = now - state.lastHeartbeat;
+    state.intervalHistory.push(interval);
+    if (state.intervalHistory.length > this.config.maxSamples) {
+      state.intervalHistory.shift();
+    }
+    state.lastHeartbeat = now;
+    if (state.isSuspected) {
+      state.isSuspected = false;
+      state.suspicionStartTime = void 0;
+      state.isConfirmedFailed = false;
+      const timer = this.confirmationTimers.get(nodeId);
+      if (timer) {
+        clearTimeout(timer);
+        this.confirmationTimers.delete(nodeId);
+      }
+      this.emit("nodeRecovered", { nodeId });
+      logger.info({ nodeId }, "Node recovered");
+    }
+  }
+  /**
+   * Check all monitored nodes for failure.
+   */
+  checkAllNodes() {
+    for (const nodeId of this.monitoringNodes) {
+      const phi = this.calculatePhi(nodeId);
+      const state = this.nodeStates.get(nodeId);
+      if (!state) continue;
+      if (phi > this.config.phiThreshold) {
+        if (!state.isSuspected) {
+          state.isSuspected = true;
+          state.suspicionStartTime = Date.now();
+          this.emit("nodeSuspected", { nodeId, phi });
+          logger.warn({ nodeId, phi }, "Node suspected");
+          this.scheduleConfirmation(nodeId);
+        }
+      }
+    }
+  }
+  /**
+   * Schedule failure confirmation after suspicion timeout.
+   */
+  scheduleConfirmation(nodeId) {
+    const existingTimer = this.confirmationTimers.get(nodeId);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.confirmFailure(nodeId);
+    }, this.config.confirmationTimeoutMs);
+    this.confirmationTimers.set(nodeId, timer);
+  }
+  /**
+   * Confirm node failure after confirmation timeout.
+   */
+  confirmFailure(nodeId) {
+    const state = this.nodeStates.get(nodeId);
+    if (!state) return;
+    if (state.isSuspected && !state.isConfirmedFailed) {
+      state.isConfirmedFailed = true;
+      this.emit("nodeConfirmedFailed", { nodeId });
+      logger.error({ nodeId }, "Node failure confirmed");
+    }
+    this.confirmationTimers.delete(nodeId);
+  }
+  /**
+   * Calculate the phi value for a node using the Phi Accrual algorithm.
+   *
+   * Phi = -log10(P_later(t_now - t_last))
+   *
+   * where P_later is the probability that a heartbeat will arrive later than expected.
+   */
+  calculatePhi(nodeId) {
+    const state = this.nodeStates.get(nodeId);
+    if (!state) return 0;
+    const now = Date.now();
+    const timeSinceLastHeartbeat = now - state.lastHeartbeat;
+    if (state.intervalHistory.length < this.config.minSamples) {
+      const expectedInterval = this.config.initialHeartbeatIntervalMs;
+      return timeSinceLastHeartbeat / expectedInterval;
+    }
+    const mean = this.calculateMean(state.intervalHistory);
+    const variance = this.calculateVariance(state.intervalHistory, mean);
+    const stdDev = Math.sqrt(variance);
+    if (timeSinceLastHeartbeat <= mean) {
+      return 0;
+    }
+    const deviations = stdDev > 0 ? (timeSinceLastHeartbeat - mean) / stdDev : 0;
+    const phi = Math.max(0, deviations);
+    return phi;
+  }
+  /**
+   * Calculate mean of an array of numbers.
+   */
+  calculateMean(values) {
+    if (values.length === 0) return 0;
+    return values.reduce((sum, v) => sum + v, 0) / values.length;
+  }
+  /**
+   * Calculate variance of an array of numbers.
+   */
+  calculateVariance(values, mean) {
+    if (values.length < 2) return 0;
+    return values.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / values.length;
+  }
+  /**
+   * Get list of currently suspected nodes.
+   */
+  getSuspectedNodes() {
+    const suspected = [];
+    for (const [nodeId, state] of this.nodeStates) {
+      if (state.isSuspected) {
+        suspected.push(nodeId);
+      }
+    }
+    return suspected;
+  }
+  /**
+   * Get list of confirmed failed nodes.
+   */
+  getConfirmedFailedNodes() {
+    const failed = [];
+    for (const [nodeId, state] of this.nodeStates) {
+      if (state.isConfirmedFailed) {
+        failed.push(nodeId);
+      }
+    }
+    return failed;
+  }
+  /**
+   * Check if a specific node is suspected.
+   */
+  isSuspected(nodeId) {
+    return this.nodeStates.get(nodeId)?.isSuspected ?? false;
+  }
+  /**
+   * Check if a specific node's failure is confirmed.
+   */
+  isConfirmedFailed(nodeId) {
+    return this.nodeStates.get(nodeId)?.isConfirmedFailed ?? false;
+  }
+  /**
+   * Get the current phi value for a node.
+   */
+  getPhi(nodeId) {
+    return this.calculatePhi(nodeId);
+  }
+  /**
+   * Get all monitored nodes.
+   */
+  getMonitoredNodes() {
+    return Array.from(this.monitoringNodes);
+  }
+  /**
+   * Get metrics for monitoring.
+   */
+  getMetrics() {
+    let suspectedCount = 0;
+    let confirmedCount = 0;
+    for (const state of this.nodeStates.values()) {
+      if (state.isSuspected) suspectedCount++;
+      if (state.isConfirmedFailed) confirmedCount++;
+    }
+    return {
+      monitoredNodes: this.monitoringNodes.size,
+      suspectedNodes: suspectedCount,
+      confirmedFailedNodes: confirmedCount
+    };
+  }
+};
+
+// src/cluster/ClusterManager.ts
+var ClusterManager = class extends EventEmitter2 {
   constructor(config) {
     super();
     this.members = /* @__PURE__ */ new Map();
@@ -582,6 +839,30 @@ var ClusterManager = class extends EventEmitter {
     this.reconnectIntervals = /* @__PURE__ */ new Map();
     this._actualPort = 0;
     this.config = config;
+    this.failureDetector = new FailureDetector({
+      ...DEFAULT_FAILURE_DETECTOR_CONFIG,
+      heartbeatIntervalMs: config.heartbeatIntervalMs ?? 1e3,
+      ...config.failureDetection
+    });
+    this.failureDetector.on("nodeSuspected", (event) => {
+      logger.warn({ nodeId: event.nodeId, phi: event.phi }, "Node suspected (failure detector)");
+      this.emit("nodeSuspected", event.nodeId, event.phi);
+    });
+    this.failureDetector.on("nodeRecovered", (event) => {
+      logger.info({ nodeId: event.nodeId }, "Node recovered (failure detector)");
+      this.emit("nodeRecovered", event.nodeId);
+    });
+    this.failureDetector.on("nodeConfirmedFailed", (event) => {
+      logger.error({ nodeId: event.nodeId }, "Node failure confirmed");
+      this.emit("nodeConfirmedFailed", event.nodeId);
+      this.handleNodeFailure(event.nodeId);
+    });
+  }
+  /**
+   * Get the failure detector instance.
+   */
+  getFailureDetector() {
+    return this.failureDetector;
   }
   /** Get the actual port the cluster is listening on */
   get port() {
@@ -633,6 +914,8 @@ var ClusterManager = class extends EventEmitter {
   }
   stop() {
     logger.info({ port: this.config.port }, "Stopping Cluster Manager");
+    this.stopHeartbeat();
+    this.failureDetector.stop();
     for (const timeout of this.reconnectIntervals.values()) {
       clearTimeout(timeout);
     }
@@ -652,6 +935,61 @@ var ClusterManager = class extends EventEmitter {
       this.server.close();
     }
   }
+  /**
+   * Start sending heartbeats to all peers.
+   */
+  startHeartbeat() {
+    if (this.heartbeatTimer) return;
+    const intervalMs = this.config.heartbeatIntervalMs ?? 1e3;
+    this.heartbeatTimer = setInterval(() => {
+      this.sendHeartbeatToAll();
+    }, intervalMs);
+    this.failureDetector.start();
+    logger.debug({ intervalMs }, "Heartbeat started");
+  }
+  /**
+   * Stop sending heartbeats.
+   */
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = void 0;
+    }
+  }
+  /**
+   * Send heartbeat to all connected peers.
+   */
+  sendHeartbeatToAll() {
+    for (const [nodeId, member] of this.members) {
+      if (member.isSelf) continue;
+      if (member.socket && member.socket.readyState === WebSocket.OPEN) {
+        this.send(nodeId, "HEARTBEAT", { timestamp: Date.now() });
+      }
+    }
+  }
+  /**
+   * Handle incoming heartbeat from a peer.
+   */
+  handleHeartbeat(senderId, _payload) {
+    this.failureDetector.recordHeartbeat(senderId);
+  }
+  /**
+   * Handle confirmed node failure.
+   */
+  handleNodeFailure(nodeId) {
+    const member = this.members.get(nodeId);
+    if (!member) return;
+    logger.warn({ nodeId }, "Removing failed node from cluster");
+    if (member.socket && member.socket.readyState !== WebSocket.CLOSED) {
+      try {
+        member.socket.terminate();
+      } catch (e) {
+      }
+    }
+    this.members.delete(nodeId);
+    this.failureDetector.stopMonitoring(nodeId);
+    this.emit("memberLeft", nodeId);
+  }
   connectToPeers() {
     for (const peer of this.config.peers) {
       this.connectToPeer(peer);
@@ -770,7 +1108,13 @@ var ClusterManager = class extends EventEmitter {
             socket: ws,
             isSelf: false
           });
+          this.failureDetector.startMonitoring(remoteNodeId);
+          this.startHeartbeat();
           this.emit("memberJoined", remoteNodeId);
+        } else if (msg.type === "HEARTBEAT") {
+          if (remoteNodeId) {
+            this.handleHeartbeat(remoteNodeId, msg.payload);
+          }
         } else {
           this.emit("message", msg);
         }
@@ -784,6 +1128,7 @@ var ClusterManager = class extends EventEmitter {
         if (current && current.socket === ws) {
           logger.info({ nodeId: remoteNodeId }, "Peer disconnected");
           this.members.delete(remoteNodeId);
+          this.failureDetector.stopMonitoring(remoteNodeId);
           this.emit("memberLeft", remoteNodeId);
           if (initiated && peerAddress) {
             this.scheduleReconnect(peerAddress, 0);
@@ -837,526 +1182,1345 @@ var ClusterManager = class extends EventEmitter {
 };
 
 // src/cluster/PartitionService.ts
-import { hashString } from "@topgunbuild/core";
-var PartitionService = class {
-  // Standard Hazelcast default
-  constructor(cluster) {
-    // partitionId -> { owner, backups }
-    this.partitions = /* @__PURE__ */ new Map();
-    this.PARTITION_COUNT = 271;
-    this.BACKUP_COUNT = 1;
-    this.cluster = cluster;
-    this.cluster.on("memberJoined", () => this.rebalance());
-    this.cluster.on("memberLeft", () => this.rebalance());
-    this.rebalance();
-  }
-  getPartitionId(key) {
-    return Math.abs(hashString(key)) % this.PARTITION_COUNT;
-  }
-  getDistribution(key) {
-    const pId = this.getPartitionId(key);
-    return this.partitions.get(pId) || {
-      owner: this.cluster.config.nodeId,
-      backups: []
+import { EventEmitter as EventEmitter4 } from "events";
+
+// src/cluster/MigrationManager.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import {
+  PartitionState,
+  DEFAULT_MIGRATION_CONFIG
+} from "@topgunbuild/core";
+import { xxhash64AsNumber, createXxHash64State } from "@topgunbuild/native";
+var MigrationManager = class extends EventEmitter3 {
+  constructor(clusterManager, partitionService, config = {}) {
+    super();
+    // Active outgoing migrations (this node is source)
+    this.activeMigrations = /* @__PURE__ */ new Map();
+    // Queue of migrations to process
+    this.migrationQueue = [];
+    // Incoming migrations (this node is target)
+    this.incomingMigrations = /* @__PURE__ */ new Map();
+    // Pending chunk acknowledgments
+    this.pendingChunkAcks = /* @__PURE__ */ new Map();
+    // Pending verification results
+    this.pendingVerifications = /* @__PURE__ */ new Map();
+    // Metrics tracking
+    this.metrics = {
+      migrationsStarted: 0,
+      migrationsCompleted: 0,
+      migrationsFailed: 0,
+      chunksTransferred: 0,
+      bytesTransferred: 0,
+      activeMigrations: 0,
+      queuedMigrations: 0
     };
+    // Batch processing timer
+    this.batchTimer = null;
+    // Data collection callback (injected from ServerCoordinator)
+    this.dataCollector = null;
+    // Data storage callback (injected from ServerCoordinator)
+    this.dataStorer = null;
+    this.clusterManager = clusterManager;
+    this.partitionService = partitionService;
+    this.config = {
+      ...DEFAULT_MIGRATION_CONFIG,
+      ...config
+    };
+    this.setupMessageHandlers();
+  }
+  // ============================================
+  // Configuration
+  // ============================================
+  /**
+   * Set the data collector callback
+   * Called to collect all records for a partition before migration
+   */
+  setDataCollector(collector) {
+    this.dataCollector = collector;
+  }
+  /**
+   * Set the data storer callback
+   * Called to store received records after successful migration
+   */
+  setDataStorer(storer) {
+    this.dataStorer = storer;
+  }
+  // ============================================
+  // Migration Planning
+  // ============================================
+  /**
+   * Plan migration for topology change
+   */
+  planMigration(oldDistribution, newDistribution) {
+    const migrations = [];
+    for (const [partitionId, newDist] of newDistribution) {
+      const oldDist = oldDistribution.get(partitionId);
+      const oldOwner = oldDist?.owner ?? this.clusterManager.config.nodeId;
+      const newOwner = newDist.owner;
+      if (oldOwner !== newOwner && oldOwner === this.clusterManager.config.nodeId) {
+        migrations.push({
+          partitionId,
+          state: PartitionState.STABLE,
+          sourceNode: oldOwner,
+          targetNode: newOwner,
+          startTime: 0,
+          bytesTransferred: 0,
+          totalBytes: 0,
+          retryCount: 0
+        });
+      }
+    }
+    migrations.sort((a, b) => a.partitionId - b.partitionId);
+    this.migrationQueue = migrations;
+    this.metrics.queuedMigrations = migrations.length;
+    logger.info({ total: migrations.length }, "Migration planned");
+    this.emit("migrationPlanned", { total: migrations.length });
+    if (migrations.length > 0) {
+      this.startBatchProcessing();
+    }
   }
-  getOwner(key) {
-    return this.getDistribution(key).owner;
-  }
-  isLocalOwner(key) {
-    return this.getOwner(key) === this.cluster.config.nodeId;
+  /**
+   * Start batch processing timer
+   */
+  startBatchProcessing() {
+    if (this.batchTimer) return;
+    this.startNextBatch().catch((err) => {
+      logger.error({ error: err }, "Failed to start first migration batch");
+      this.emit("error", err);
+    });
+    this.batchTimer = setInterval(() => {
+      this.startNextBatch().catch((err) => {
+        logger.error({ error: err }, "Failed to start migration batch");
+        this.emit("error", err);
+      });
+    }, this.config.batchIntervalMs);
   }
-  isLocalBackup(key) {
-    const dist = this.getDistribution(key);
-    return dist.backups.includes(this.cluster.config.nodeId);
+  /**
+   * Stop batch processing
+   */
+  stopBatchProcessing() {
+    if (this.batchTimer) {
+      clearInterval(this.batchTimer);
+      this.batchTimer = null;
+    }
   }
-  isRelated(key) {
-    return this.isLocalOwner(key) || this.isLocalBackup(key);
+  /**
+   * Start next batch of migrations
+   */
+  async startNextBatch() {
+    if (this.activeMigrations.size >= this.config.parallelTransfers) {
+      return;
+    }
+    const slotsAvailable = this.config.parallelTransfers - this.activeMigrations.size;
+    const batch = this.migrationQueue.splice(0, Math.min(slotsAvailable, this.config.batchSize));
+    if (batch.length === 0) {
+      if (this.migrationQueue.length === 0 && this.activeMigrations.size === 0) {
+        this.stopBatchProcessing();
+      }
+      return;
+    }
+    for (const migration of batch) {
+      migration.state = PartitionState.MIGRATING;
+      migration.startTime = Date.now();
+      this.activeMigrations.set(migration.partitionId, migration);
+      this.metrics.migrationsStarted++;
+      this.metrics.activeMigrations = this.activeMigrations.size;
+      this.metrics.queuedMigrations = this.migrationQueue.length;
+      this.startPartitionMigration(migration).catch((error) => {
+        this.onMigrationFailed(migration.partitionId, error);
+      });
+    }
+    logger.info({ count: batch.length, remaining: this.migrationQueue.length }, "Batch started");
+    this.emit("batchStarted", { count: batch.length, remaining: this.migrationQueue.length });
   }
-  rebalance() {
-    let allMembers = this.cluster.getMembers().sort();
-    if (allMembers.length === 0) {
-      allMembers = [this.cluster.config.nodeId];
+  // ============================================
+  // Migration Execution
+  // ============================================
+  /**
+   * Start migration for a single partition
+   */
+  async startPartitionMigration(migration) {
+    const { partitionId, targetNode } = migration;
+    logger.info({ partitionId, targetNode }, "Starting partition migration");
+    let records;
+    if (this.dataCollector) {
+      records = await this.dataCollector(partitionId);
+    } else {
+      records = [];
     }
-    logger.info({ memberCount: allMembers.length, members: allMembers }, "Rebalancing partitions");
-    for (let i = 0; i < this.PARTITION_COUNT; i++) {
-      const ownerIndex = i % allMembers.length;
-      const owner = allMembers[ownerIndex];
-      const backups = [];
-      if (allMembers.length > 1) {
-        for (let b = 1; b <= this.BACKUP_COUNT; b++) {
-          const backupIndex = (ownerIndex + b) % allMembers.length;
-          backups.push(allMembers[backupIndex]);
+    migration.totalBytes = records.reduce((sum, r) => sum + r.length, 0);
+    this.clusterManager.send(targetNode, "OP_FORWARD", {
+      _migration: {
+        type: "MIGRATION_START",
+        payload: {
+          partitionId,
+          sourceNode: this.clusterManager.config.nodeId,
+          estimatedSize: migration.totalBytes
         }
       }
-      this.partitions.set(i, { owner, backups });
+    });
+    const chunks = this.chunkify(records);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
+      const checksum = this.calculateChecksum(chunk);
+      this.clusterManager.send(targetNode, "OP_FORWARD", {
+        _migration: {
+          type: "MIGRATION_CHUNK",
+          payload: {
+            partitionId,
+            chunkIndex: i,
+            totalChunks: chunks.length,
+            data: Array.from(chunk),
+            // Convert Uint8Array to array for JSON serialization
+            checksum
+          }
+        }
+      });
+      await this.waitForChunkAck(partitionId, i);
+      migration.bytesTransferred += chunk.length;
+      this.metrics.chunksTransferred++;
+      this.metrics.bytesTransferred += chunk.length;
+      this.emit("migrationProgress", migration);
+    }
+    const fullChecksum = this.calculatePartitionChecksum(records);
+    migration.state = PartitionState.SYNC;
+    this.clusterManager.send(targetNode, "OP_FORWARD", {
+      _migration: {
+        type: "MIGRATION_COMPLETE",
+        payload: {
+          partitionId,
+          totalRecords: records.length,
+          checksum: fullChecksum
+        }
+      }
+    });
+    const verified = await this.waitForVerification(partitionId);
+    if (verified) {
+      await this.onMigrationComplete(partitionId);
+    } else {
+      throw new Error(`Migration verification failed for partition ${partitionId}`);
     }
   }
-};
-
-// src/cluster/LockManager.ts
-import { EventEmitter as EventEmitter2 } from "events";
-var _LockManager = class _LockManager extends EventEmitter2 {
-  // 5 minutes
-  constructor() {
-    super();
-    this.locks = /* @__PURE__ */ new Map();
-    this.checkInterval = setInterval(() => this.cleanupExpiredLocks(), 1e3);
-  }
-  stop() {
-    clearInterval(this.checkInterval);
-  }
-  acquire(name, clientId, requestId, ttl) {
-    const safeTtl = Math.max(_LockManager.MIN_TTL, Math.min(ttl || _LockManager.MIN_TTL, _LockManager.MAX_TTL));
-    let lock = this.locks.get(name);
-    if (!lock) {
-      lock = {
-        name,
-        owner: "",
-        fencingToken: 0,
-        expiry: 0,
-        queue: []
-      };
-      this.locks.set(name, lock);
+  /**
+   * Split records into chunks
+   */
+  chunkify(records) {
+    const chunks = [];
+    let currentChunk = [];
+    let currentSize = 0;
+    for (const record of records) {
+      const lengthPrefix = new Uint8Array(4);
+      new DataView(lengthPrefix.buffer).setUint32(0, record.length, true);
+      currentChunk.push(...lengthPrefix, ...record);
+      currentSize += 4 + record.length;
+      if (currentSize >= this.config.transferChunkSize) {
+        chunks.push(new Uint8Array(currentChunk));
+        currentChunk = [];
+        currentSize = 0;
+      }
     }
-    const now = Date.now();
-    if (!lock.owner || lock.expiry < now) {
-      this.grantLock(lock, clientId, safeTtl);
-      return { granted: true, fencingToken: lock.fencingToken };
+    if (currentChunk.length > 0) {
+      chunks.push(new Uint8Array(currentChunk));
     }
-    if (lock.owner === clientId) {
-      lock.expiry = Math.max(lock.expiry, now + safeTtl);
-      logger.info({ name, clientId, fencingToken: lock.fencingToken }, "Lock lease extended");
-      return { granted: true, fencingToken: lock.fencingToken };
+    if (chunks.length === 0) {
+      chunks.push(new Uint8Array(0));
     }
-    lock.queue.push({ clientId, requestId, ttl: safeTtl, timestamp: now });
-    logger.info({ name, clientId, queueLength: lock.queue.length }, "Lock queued");
-    return { granted: false };
+    return chunks;
   }
-  release(name, clientId, fencingToken) {
-    const lock = this.locks.get(name);
-    if (!lock) return false;
-    if (lock.owner !== clientId) {
-      logger.warn({ name, clientId, owner: lock.owner }, "Release failed: Not owner");
-      return false;
-    }
-    if (lock.fencingToken !== fencingToken) {
-      logger.warn({ name, clientId, sentToken: fencingToken, actualToken: lock.fencingToken }, "Release failed: Token mismatch");
-      return false;
-    }
-    this.processNext(lock);
-    return true;
+  /**
+   * Calculate checksum for a chunk using native xxhash
+   */
+  calculateChecksum(data) {
+    return String(xxhash64AsNumber(data));
   }
-  handleClientDisconnect(clientId) {
-    for (const lock of this.locks.values()) {
-      if (lock.owner === clientId) {
-        logger.info({ name: lock.name, clientId }, "Releasing lock due to disconnect");
-        this.processNext(lock);
-      } else {
-        const initialLen = lock.queue.length;
-        lock.queue = lock.queue.filter((req) => req.clientId !== clientId);
-        if (lock.queue.length < initialLen) {
-          logger.info({ name: lock.name, clientId }, "Removed from lock queue due to disconnect");
-        }
-      }
+  /**
+   * Calculate checksum for all partition records using streaming xxhash
+   */
+  calculatePartitionChecksum(records) {
+    const state = createXxHash64State();
+    for (const record of records) {
+      state.update(record);
     }
+    return String(state.digestAsNumber());
   }
-  grantLock(lock, clientId, ttl) {
-    lock.owner = clientId;
-    lock.expiry = Date.now() + ttl;
-    lock.fencingToken++;
-    logger.info({ name: lock.name, clientId, fencingToken: lock.fencingToken }, "Lock granted");
+  /**
+   * Wait for chunk acknowledgment
+   */
+  waitForChunkAck(partitionId, chunkIndex) {
+    return new Promise((resolve, reject) => {
+      const key = `${partitionId}:${chunkIndex}`;
+      const timeout = setTimeout(() => {
+        this.pendingChunkAcks.delete(key);
+        reject(new Error(`Chunk ack timeout for partition ${partitionId}, chunk ${chunkIndex}`));
+      }, this.config.syncTimeoutMs);
+      this.pendingChunkAcks.set(key, { resolve, reject, timeout });
+    });
   }
-  processNext(lock) {
-    const now = Date.now();
-    lock.owner = "";
-    lock.expiry = 0;
-    while (lock.queue.length > 0) {
-      const next = lock.queue.shift();
-      this.grantLock(lock, next.clientId, next.ttl);
-      this.emit("lockGranted", {
-        clientId: next.clientId,
-        requestId: next.requestId,
-        name: lock.name,
-        fencingToken: lock.fencingToken
-      });
+  /**
+   * Wait for migration verification
+   */
+  waitForVerification(partitionId) {
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pendingVerifications.delete(partitionId);
+        resolve(false);
+      }, this.config.syncTimeoutMs);
+      this.pendingVerifications.set(partitionId, { resolve, timeout });
+    });
+  }
+  // ============================================
+  // Migration Completion
+  // ============================================
+  /**
+   * Handle successful migration completion
+   */
+  async onMigrationComplete(partitionId) {
+    const migration = this.activeMigrations.get(partitionId);
+    if (!migration) return;
+    migration.state = PartitionState.STABLE;
+    this.activeMigrations.delete(partitionId);
+    this.metrics.migrationsCompleted++;
+    this.metrics.activeMigrations = this.activeMigrations.size;
+    logger.info({
+      partitionId,
+      duration: Date.now() - migration.startTime,
+      bytesTransferred: migration.bytesTransferred
+    }, "Migration completed");
+    this.emit("migrationComplete", partitionId);
+  }
+  /**
+   * Handle migration failure
+   */
+  async onMigrationFailed(partitionId, error) {
+    const migration = this.activeMigrations.get(partitionId);
+    if (!migration) return;
+    migration.retryCount++;
+    if (migration.retryCount <= this.config.maxRetries) {
+      migration.state = PartitionState.STABLE;
+      migration.bytesTransferred = 0;
+      this.activeMigrations.delete(partitionId);
+      this.migrationQueue.unshift(migration);
+      this.metrics.queuedMigrations = this.migrationQueue.length;
+      this.metrics.activeMigrations = this.activeMigrations.size;
+      logger.warn({
+        partitionId,
+        retryCount: migration.retryCount,
+        error: error.message
+      }, "Migration failed, will retry");
+    } else {
+      migration.state = PartitionState.FAILED;
+      this.activeMigrations.delete(partitionId);
+      this.metrics.migrationsFailed++;
+      this.metrics.activeMigrations = this.activeMigrations.size;
+      logger.error({
+        partitionId,
+        retryCount: migration.retryCount,
+        error: error.message
+      }, "Migration failed permanently");
+      this.emit("migrationFailed", partitionId, error);
+    }
+  }
+  // ============================================
+  // Incoming Migration Handlers (Target Node)
+  // ============================================
+  /**
+   * Handle MIGRATION_START message
+   */
+  handleMigrationStart(payload) {
+    const { partitionId, sourceNode, estimatedSize } = payload;
+    logger.info({ partitionId, sourceNode, estimatedSize }, "Receiving migration");
+    this.incomingMigrations.set(partitionId, {
+      sourceNode,
+      chunks: [],
+      expectedSize: estimatedSize,
+      receivedSize: 0,
+      startTime: Date.now()
+    });
+  }
+  /**
+   * Handle MIGRATION_CHUNK message
+   */
+  handleMigrationChunk(payload) {
+    const { partitionId, chunkIndex, data, checksum } = payload;
+    const incoming = this.incomingMigrations.get(partitionId);
+    if (!incoming) {
+      logger.warn({ partitionId, chunkIndex }, "Received chunk for unknown migration");
       return;
     }
-    if (lock.queue.length === 0) {
-      this.locks.delete(lock.name);
+    const chunkData = new Uint8Array(data);
+    const actualChecksum = this.calculateChecksum(chunkData);
+    const success = actualChecksum === checksum;
+    if (success) {
+      incoming.chunks[chunkIndex] = chunkData;
+      incoming.receivedSize += chunkData.length;
+    } else {
+      logger.warn({ partitionId, chunkIndex, expected: checksum, actual: actualChecksum }, "Chunk checksum mismatch");
     }
-  }
-  cleanupExpiredLocks() {
-    const now = Date.now();
-    const lockNames = Array.from(this.locks.keys());
-    for (const name of lockNames) {
-      const lock = this.locks.get(name);
-      if (!lock) continue;
-      if (lock.owner && lock.expiry < now) {
-        logger.info({ name: lock.name, owner: lock.owner }, "Lock expired, processing next");
-        this.processNext(lock);
-      } else if (!lock.owner && lock.queue.length === 0) {
-        this.locks.delete(name);
+    this.clusterManager.send(incoming.sourceNode, "OP_FORWARD", {
+      _migration: {
+        type: "MIGRATION_CHUNK_ACK",
+        payload: {
+          partitionId,
+          chunkIndex,
+          success
+        }
       }
-    }
-  }
-};
-_LockManager.MIN_TTL = 1e3;
-// 1 second
-_LockManager.MAX_TTL = 3e5;
-var LockManager = _LockManager;
-
-// src/security/SecurityManager.ts
-var SecurityManager = class {
-  constructor(policies = []) {
-    this.policies = [];
-    this.policies = policies;
-  }
-  addPolicy(policy) {
-    this.policies.push(policy);
+    });
   }
-  checkPermission(principal, mapName, action) {
-    if (principal.roles.includes("ADMIN")) {
-      return true;
+  /**
+   * Handle MIGRATION_COMPLETE message
+   */
+  async handleMigrationComplete(payload) {
+    const { partitionId, totalRecords, checksum } = payload;
+    const incoming = this.incomingMigrations.get(partitionId);
+    if (!incoming) {
+      logger.warn({ partitionId }, "Received complete for unknown migration");
+      return;
     }
-    if (mapName.startsWith("$sys/")) {
-      logger.warn({ userId: principal.userId, mapName }, "Access Denied: System Map requires ADMIN role");
-      return false;
+    const allData = this.reassemble(incoming.chunks);
+    const records = this.deserializeRecords(allData);
+    const actualChecksum = this.calculatePartitionChecksum(records);
+    const checksumMatch = actualChecksum === checksum;
+    const success = checksumMatch && records.length === totalRecords;
+    if (success && this.dataStorer) {
+      await this.dataStorer(partitionId, records);
     }
-    for (const policy of this.policies) {
-      const hasRole = this.hasRole(principal, policy.role);
-      const matchesMap = this.matchesMap(mapName, policy.mapNamePattern, principal);
-      if (hasRole && matchesMap) {
-        if (policy.actions.includes("ALL") || policy.actions.includes(action)) {
-          return true;
+    logger.info({
+      partitionId,
+      duration: Date.now() - incoming.startTime,
+      records: records.length,
+      checksumMatch
+    }, "Migration received");
+    this.clusterManager.send(incoming.sourceNode, "OP_FORWARD", {
+      _migration: {
+        type: "MIGRATION_VERIFY",
+        payload: {
+          partitionId,
+          success,
+          checksumMatch
         }
+      }
+    });
+    this.incomingMigrations.delete(partitionId);
+  }
+  /**
+   * Handle MIGRATION_CHUNK_ACK message
+   */
+  handleMigrationChunkAck(payload) {
+    const { partitionId, chunkIndex, success } = payload;
+    const key = `${partitionId}:${chunkIndex}`;
+    const pending = this.pendingChunkAcks.get(key);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingChunkAcks.delete(key);
+      if (success) {
+        pending.resolve();
       } else {
+        pending.reject(new Error(`Chunk ${chunkIndex} rejected by target`));
       }
     }
-    logger.warn({
-      userId: principal.userId,
-      roles: principal.roles,
-      mapName,
-      action,
-      policyCount: this.policies.length
-    }, "SecurityManager: Access Denied - No matching policy found");
-    return false;
   }
-  filterObject(object, principal, mapName) {
-    if (!object || typeof object !== "object") return object;
-    if (principal.roles.includes("ADMIN")) return object;
-    if (Array.isArray(object)) {
-      return object.map((item) => this.filterObject(item, principal, mapName));
+  /**
+   * Handle MIGRATION_VERIFY message
+   */
+  handleMigrationVerify(payload) {
+    const { partitionId, success } = payload;
+    const pending = this.pendingVerifications.get(partitionId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingVerifications.delete(partitionId);
+      pending.resolve(success);
     }
-    let allowedFields = null;
-    let accessGranted = false;
-    for (const policy of this.policies) {
-      if (this.hasRole(principal, policy.role) && this.matchesMap(mapName, policy.mapNamePattern, principal)) {
-        if (policy.actions.includes("ALL") || policy.actions.includes("READ")) {
-          accessGranted = true;
-          if (!policy.allowedFields || policy.allowedFields.length === 0 || policy.allowedFields.includes("*")) {
-            return object;
-          }
-          if (allowedFields === null) allowedFields = /* @__PURE__ */ new Set();
-          policy.allowedFields.forEach((f) => allowedFields.add(f));
-        }
+  }
+  /**
+   * Reassemble chunks into continuous data
+   */
+  reassemble(chunks) {
+    const totalLength = chunks.reduce((sum, c) => sum + (c?.length ?? 0), 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      if (chunk) {
+        result.set(chunk, offset);
+        offset += chunk.length;
       }
     }
-    if (!accessGranted) return null;
-    if (allowedFields === null) return object;
-    const filtered = {};
-    for (const key of Object.keys(object)) {
-      if (allowedFields.has(key)) {
-        filtered[key] = object[key];
-      }
+    return result;
+  }
+  /**
+   * Deserialize records from chunk data
+   */
+  deserializeRecords(data) {
+    const records = [];
+    let offset = 0;
+    while (offset < data.length) {
+      if (offset + 4 > data.length) break;
+      const length = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, true);
+      offset += 4;
+      if (offset + length > data.length) break;
+      records.push(data.slice(offset, offset + length));
+      offset += length;
     }
-    return filtered;
+    return records;
   }
-  hasRole(principal, role) {
-    return principal.roles.includes(role);
+  // ============================================
+  // Message Handling
+  // ============================================
+  /**
+   * Setup cluster message handlers
+   */
+  setupMessageHandlers() {
+    this.clusterManager.on("message", (msg) => {
+      if (msg.payload?._migration) {
+        const migration = msg.payload._migration;
+        switch (migration.type) {
+          case "MIGRATION_START":
+            this.handleMigrationStart(migration.payload);
+            break;
+          case "MIGRATION_CHUNK":
+            this.handleMigrationChunk(migration.payload);
+            break;
+          case "MIGRATION_COMPLETE":
+            this.handleMigrationComplete(migration.payload).catch((err) => {
+              logger.error({ error: err }, "Error handling migration complete");
+            });
+            break;
+          case "MIGRATION_CHUNK_ACK":
+            this.handleMigrationChunkAck(migration.payload);
+            break;
+          case "MIGRATION_VERIFY":
+            this.handleMigrationVerify(migration.payload);
+            break;
+        }
+      }
+    });
   }
-  matchesMap(mapName, pattern, principal) {
-    let finalPattern = pattern;
-    if (pattern.includes("{userId}") && principal) {
-      finalPattern = pattern.replace("{userId}", principal.userId);
+  // ============================================
+  // Status and Metrics
+  // ============================================
+  /**
+   * Check if a partition is currently migrating
+   */
+  isActive(partitionId) {
+    return this.activeMigrations.has(partitionId) || this.incomingMigrations.has(partitionId);
+  }
+  /**
+   * Get migration status
+   */
+  getStatus() {
+    const avgMigrationTime = this.metrics.migrationsCompleted > 0 ? Date.now() - (this.activeMigrations.values().next().value?.startTime ?? Date.now()) : 0;
+    const estimatedTimeRemainingMs = (this.migrationQueue.length + this.activeMigrations.size) * (avgMigrationTime || 1e3);
+    return {
+      inProgress: this.activeMigrations.size > 0 || this.migrationQueue.length > 0,
+      active: Array.from(this.activeMigrations.values()),
+      queued: this.migrationQueue.length,
+      completed: this.metrics.migrationsCompleted,
+      failed: this.metrics.migrationsFailed,
+      estimatedTimeRemainingMs
+    };
+  }
+  /**
+   * Get migration metrics
+   */
+  getMetrics() {
+    return { ...this.metrics };
+  }
+  /**
+   * Cancel all active and queued migrations
+   */
+  async cancelAll() {
+    this.stopBatchProcessing();
+    this.migrationQueue = [];
+    this.metrics.queuedMigrations = 0;
+    for (const [partitionId, migration] of this.activeMigrations) {
+      migration.state = PartitionState.FAILED;
+      this.metrics.migrationsFailed++;
+      this.emit("migrationFailed", partitionId, new Error("Migration cancelled"));
     }
-    if (finalPattern === "*") return true;
-    if (finalPattern === mapName) return true;
-    if (finalPattern.endsWith("*")) {
-      const prefix = finalPattern.slice(0, -1);
-      return mapName.startsWith(prefix);
+    this.activeMigrations.clear();
+    this.metrics.activeMigrations = 0;
+    for (const pending of this.pendingChunkAcks.values()) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Migration cancelled"));
     }
-    return false;
+    this.pendingChunkAcks.clear();
+    for (const pending of this.pendingVerifications.values()) {
+      clearTimeout(pending.timeout);
+      pending.resolve(false);
+    }
+    this.pendingVerifications.clear();
+    this.incomingMigrations.clear();
+    logger.info("All migrations cancelled");
+  }
+  /**
+   * Cleanup resources (sync version for backwards compatibility)
+   */
+  close() {
+    this.cancelAll();
+  }
+  /**
+   * Async cleanup - waits for cancellation to complete
+   */
+  async closeAsync() {
+    await this.cancelAll();
+    this.removeAllListeners();
   }
 };
 
-// src/monitoring/MetricsService.ts
-import { Registry, Gauge, Counter, Summary, collectDefaultMetrics } from "prom-client";
-var MetricsService = class {
-  constructor() {
-    this.registry = new Registry();
-    collectDefaultMetrics({ register: this.registry, prefix: "topgun_" });
-    this.connectedClients = new Gauge({
-      name: "topgun_connected_clients",
-      help: "Number of currently connected clients",
-      registers: [this.registry]
-    });
-    this.mapSizeItems = new Gauge({
-      name: "topgun_map_size_items",
-      help: "Number of items in a map",
-      labelNames: ["map"],
-      registers: [this.registry]
-    });
-    this.opsTotal = new Counter({
-      name: "topgun_ops_total",
-      help: "Total number of operations",
-      labelNames: ["type", "map"],
-      registers: [this.registry]
-    });
-    this.memoryUsage = new Gauge({
-      name: "topgun_memory_usage_bytes",
-      help: "Current memory usage in bytes",
-      registers: [this.registry],
-      collect() {
-        this.set(process.memoryUsage().heapUsed);
-      }
-    });
-    this.clusterMembers = new Gauge({
-      name: "topgun_cluster_members",
-      help: "Number of active cluster members",
-      registers: [this.registry]
-    });
-    this.eventsRoutedTotal = new Counter({
-      name: "topgun_events_routed_total",
-      help: "Total number of events processed for routing",
-      registers: [this.registry]
-    });
-    this.eventsFilteredBySubscription = new Counter({
-      name: "topgun_events_filtered_by_subscription",
-      help: "Events NOT sent due to no active subscriptions",
-      registers: [this.registry]
-    });
-    this.subscribersPerEvent = new Summary({
-      name: "topgun_subscribers_per_event",
-      help: "Distribution of subscribers per event",
-      percentiles: [0.5, 0.9, 0.99],
-      registers: [this.registry]
-    });
-    this.eventQueueSize = new Gauge({
-      name: "topgun_event_queue_size",
-      help: "Current size of the event queue across all stripes",
-      labelNames: ["stripe"],
-      registers: [this.registry]
-    });
-    this.eventQueueEnqueued = new Counter({
-      name: "topgun_event_queue_enqueued_total",
-      help: "Total number of events enqueued",
-      registers: [this.registry]
-    });
-    this.eventQueueDequeued = new Counter({
-      name: "topgun_event_queue_dequeued_total",
-      help: "Total number of events dequeued",
-      registers: [this.registry]
-    });
-    this.eventQueueRejected = new Counter({
-      name: "topgun_event_queue_rejected_total",
-      help: "Total number of events rejected due to queue capacity",
-      registers: [this.registry]
-    });
-    this.backpressureSyncForcedTotal = new Counter({
-      name: "topgun_backpressure_sync_forced_total",
-      help: "Total number of times sync processing was forced",
-      registers: [this.registry]
-    });
-    this.backpressurePendingOps = new Gauge({
-      name: "topgun_backpressure_pending_ops",
-      help: "Current number of pending async operations",
-      registers: [this.registry]
-    });
-    this.backpressureWaitsTotal = new Counter({
-      name: "topgun_backpressure_waits_total",
-      help: "Total number of times had to wait for capacity",
-      registers: [this.registry]
-    });
-    this.backpressureTimeoutsTotal = new Counter({
-      name: "topgun_backpressure_timeouts_total",
-      help: "Total number of backpressure timeouts",
-      registers: [this.registry]
-    });
-    this.connectionsAcceptedTotal = new Counter({
-      name: "topgun_connections_accepted_total",
-      help: "Total number of connections accepted",
-      registers: [this.registry]
-    });
-    this.connectionsRejectedTotal = new Counter({
-      name: "topgun_connections_rejected_total",
-      help: "Total number of connections rejected due to rate limiting",
-      registers: [this.registry]
-    });
-    this.connectionsPending = new Gauge({
-      name: "topgun_connections_pending",
-      help: "Number of connections currently pending (handshake in progress)",
-      registers: [this.registry]
-    });
-    this.connectionRatePerSecond = new Gauge({
-      name: "topgun_connection_rate_per_second",
-      help: "Current connection rate per second",
-      registers: [this.registry]
-    });
+// src/cluster/PartitionService.ts
+import {
+  hashString,
+  PARTITION_COUNT,
+  DEFAULT_BACKUP_COUNT,
+  DEFAULT_MIGRATION_CONFIG as DEFAULT_MIGRATION_CONFIG2
+} from "@topgunbuild/core";
+var DEFAULT_PARTITION_SERVICE_CONFIG = {
+  gradualRebalancing: false,
+  migration: DEFAULT_MIGRATION_CONFIG2
+};
+var PartitionService = class extends EventEmitter4 {
+  constructor(cluster, config = {}) {
+    super();
+    // partitionId -> { owner, backups }
+    this.partitions = /* @__PURE__ */ new Map();
+    this.PARTITION_COUNT = PARTITION_COUNT;
+    this.BACKUP_COUNT = DEFAULT_BACKUP_COUNT;
+    // Phase 4: Version tracking for partition map
+    this.mapVersion = 0;
+    this.lastRebalanceTime = 0;
+    this.migrationManager = null;
+    this.cluster = cluster;
+    this.config = {
+      ...DEFAULT_PARTITION_SERVICE_CONFIG,
+      ...config
+    };
+    if (this.config.gradualRebalancing) {
+      this.migrationManager = new MigrationManager(
+        cluster,
+        this,
+        this.config.migration
+      );
+      this.migrationManager.on("migrationComplete", (partitionId) => {
+        logger.info({ partitionId }, "Migration completed, updating ownership");
+      });
+      this.migrationManager.on("migrationFailed", (partitionId, error) => {
+        logger.error({ partitionId, error: error.message }, "Migration failed");
+      });
+    }
+    this.cluster.on("memberJoined", (nodeId) => this.onMembershipChange("JOIN", nodeId));
+    this.cluster.on("memberLeft", (nodeId) => this.onMembershipChange("LEAVE", nodeId));
+    this.rebalance("REBALANCE");
   }
-  destroy() {
-    this.registry.clear();
+  /**
+   * Handle membership change
+   */
+  onMembershipChange(reason, nodeId) {
+    if (this.config.gradualRebalancing && this.migrationManager) {
+      this.rebalanceGradual(reason, nodeId);
+    } else {
+      this.rebalance(reason, nodeId);
+    }
   }
-  setConnectedClients(count) {
-    this.connectedClients.set(count);
+  getPartitionId(key) {
+    return Math.abs(hashString(key)) % this.PARTITION_COUNT;
   }
-  setMapSize(mapName, size) {
-    this.mapSizeItems.set({ map: mapName }, size);
+  getDistribution(key) {
+    const pId = this.getPartitionId(key);
+    return this.partitions.get(pId) || {
+      owner: this.cluster.config.nodeId,
+      backups: []
+    };
   }
-  incOp(type, mapName) {
-    this.opsTotal.inc({ type, map: mapName });
+  getOwner(key) {
+    return this.getDistribution(key).owner;
   }
-  setClusterMembers(count) {
-    this.clusterMembers.set(count);
+  isLocalOwner(key) {
+    return this.getOwner(key) === this.cluster.config.nodeId;
   }
-  // === Subscription-based routing metric methods ===
-  /**
-   * Increment counter for total events processed for routing.
-   */
-  incEventsRouted() {
-    this.eventsRoutedTotal.inc();
+  isLocalBackup(key) {
+    const dist = this.getDistribution(key);
+    return dist.backups.includes(this.cluster.config.nodeId);
   }
-  /**
-   * Increment counter for events filtered out due to no subscribers.
-   */
-  incEventsFilteredBySubscription() {
-    this.eventsFilteredBySubscription.inc();
+  isRelated(key) {
+    return this.isLocalOwner(key) || this.isLocalBackup(key);
   }
+  // ============================================
+  // Phase 4: Partition Map Methods
+  // ============================================
   /**
-   * Record the number of subscribers for an event (for average calculation).
+   * Get current partition map version
    */
-  recordSubscribersPerEvent(count) {
-    this.subscribersPerEvent.observe(count);
+  getMapVersion() {
+    return this.mapVersion;
   }
-  // === Bounded event queue metric methods ===
   /**
-   * Set the current size of a specific queue stripe.
+   * Generate full PartitionMap for client consumption
    */
-  setEventQueueSize(stripe, size) {
-    this.eventQueueSize.set({ stripe: String(stripe) }, size);
+  getPartitionMap() {
+    const nodes = [];
+    const partitions = [];
+    for (const nodeId of this.cluster.getMembers()) {
+      const isSelf = nodeId === this.cluster.config.nodeId;
+      const host = isSelf ? this.cluster.config.host : "unknown";
+      const port = isSelf ? this.cluster.port : 0;
+      nodes.push({
+        nodeId,
+        endpoints: {
+          websocket: `ws://${host}:${port}`
+        },
+        status: "ACTIVE"
+      });
+    }
+    for (let i = 0; i < this.PARTITION_COUNT; i++) {
+      const dist = this.partitions.get(i);
+      if (dist) {
+        partitions.push({
+          partitionId: i,
+          ownerNodeId: dist.owner,
+          backupNodeIds: dist.backups
+        });
+      }
+    }
+    return {
+      version: this.mapVersion,
+      partitionCount: this.PARTITION_COUNT,
+      nodes,
+      partitions,
+      generatedAt: Date.now()
+    };
   }
   /**
-   * Increment counter for events enqueued.
+   * Get partition info by ID
    */
-  incEventQueueEnqueued() {
-    this.eventQueueEnqueued.inc();
+  getPartitionInfo(partitionId) {
+    const dist = this.partitions.get(partitionId);
+    if (!dist) return null;
+    return {
+      partitionId,
+      ownerNodeId: dist.owner,
+      backupNodeIds: dist.backups
+    };
   }
   /**
-   * Increment counter for events dequeued.
+   * Get owner node for a partition ID
    */
-  incEventQueueDequeued() {
-    this.eventQueueDequeued.inc();
+  getPartitionOwner(partitionId) {
+    const dist = this.partitions.get(partitionId);
+    return dist?.owner ?? null;
   }
-  /**
-   * Increment counter for events rejected due to queue capacity.
-   */
-  incEventQueueRejected() {
-    this.eventQueueRejected.inc();
+  rebalance(reason = "REBALANCE", triggerNodeId) {
+    const oldPartitions = new Map(this.partitions);
+    let allMembers = this.cluster.getMembers().sort();
+    if (allMembers.length === 0) {
+      allMembers = [this.cluster.config.nodeId];
+    }
+    logger.info({ memberCount: allMembers.length, members: allMembers, reason }, "Rebalancing partitions");
+    const changes = [];
+    for (let i = 0; i < this.PARTITION_COUNT; i++) {
+      const ownerIndex = i % allMembers.length;
+      const owner = allMembers[ownerIndex];
+      const backups = [];
+      if (allMembers.length > 1) {
+        for (let b = 1; b <= this.BACKUP_COUNT; b++) {
+          const backupIndex = (ownerIndex + b) % allMembers.length;
+          backups.push(allMembers[backupIndex]);
+        }
+      }
+      const oldDist = oldPartitions.get(i);
+      if (oldDist && oldDist.owner !== owner) {
+        changes.push({
+          partitionId: i,
+          previousOwner: oldDist.owner,
+          newOwner: owner,
+          reason
+        });
+      }
+      this.partitions.set(i, { owner, backups });
+    }
+    if (changes.length > 0 || this.mapVersion === 0) {
+      this.mapVersion++;
+      this.lastRebalanceTime = Date.now();
+      logger.info({
+        version: this.mapVersion,
+        changesCount: changes.length,
+        reason
+      }, "Partition map updated");
+      this.emit("rebalanced", this.getPartitionMap(), changes);
+    }
   }
-  // === Backpressure metric methods ===
+  // ============================================
+  // Phase 4 Task 03: Gradual Rebalancing
+  // ============================================
   /**
-   * Increment counter for forced sync operations.
+   * Perform gradual rebalancing using MigrationManager
    */
-  incBackpressureSyncForced() {
-    this.backpressureSyncForcedTotal.inc();
+  rebalanceGradual(reason, triggerNodeId) {
+    if (!this.migrationManager) {
+      this.rebalance(reason, triggerNodeId);
+      return;
+    }
+    const oldDistribution = new Map(this.partitions);
+    let allMembers = this.cluster.getMembers().sort();
+    if (allMembers.length === 0) {
+      allMembers = [this.cluster.config.nodeId];
+    }
+    const newDistribution = /* @__PURE__ */ new Map();
+    for (let i = 0; i < this.PARTITION_COUNT; i++) {
+      const ownerIndex = i % allMembers.length;
+      const owner = allMembers[ownerIndex];
+      const backups = [];
+      if (allMembers.length > 1) {
+        for (let b = 1; b <= this.BACKUP_COUNT; b++) {
+          const backupIndex = (ownerIndex + b) % allMembers.length;
+          backups.push(allMembers[backupIndex]);
+        }
+      }
+      newDistribution.set(i, { owner, backups });
+    }
+    logger.info({ memberCount: allMembers.length, reason, triggerNodeId }, "Planning gradual rebalance");
+    this.migrationManager.planMigration(oldDistribution, newDistribution);
+    for (const [partitionId, dist] of newDistribution) {
+      this.partitions.set(partitionId, dist);
+    }
+    this.mapVersion++;
+    this.lastRebalanceTime = Date.now();
+    const changes = [];
+    for (const [partitionId, newDist] of newDistribution) {
+      const oldDist = oldDistribution.get(partitionId);
+      if (oldDist && oldDist.owner !== newDist.owner) {
+        changes.push({
+          partitionId,
+          previousOwner: oldDist.owner,
+          newOwner: newDist.owner,
+          reason
+        });
+      }
+    }
+    this.emit("rebalanced", this.getPartitionMap(), changes);
   }
   /**
-   * Set the current number of pending async operations.
+   * Set partition owner (called after migration completes)
    */
-  setBackpressurePendingOps(count) {
-    this.backpressurePendingOps.set(count);
+  setOwner(partitionId, nodeId) {
+    const partition = this.partitions.get(partitionId);
+    if (!partition) return;
+    const previousOwner = partition.owner;
+    if (previousOwner === nodeId) return;
+    partition.owner = nodeId;
+    this.mapVersion++;
+    logger.info({ partitionId, previousOwner, newOwner: nodeId, version: this.mapVersion }, "Partition owner updated");
+    this.emit("partitionMoved", {
+      partitionId,
+      previousOwner,
+      newOwner: nodeId,
+      version: this.mapVersion
+    });
   }
   /**
-   * Increment counter for times had to wait for capacity.
+   * Get backups for a partition
    */
-  incBackpressureWaits() {
-    this.backpressureWaitsTotal.inc();
+  getBackups(partitionId) {
+    const dist = this.partitions.get(partitionId);
+    return dist?.backups ?? [];
   }
   /**
-   * Increment counter for backpressure timeouts.
+   * Get migration status
    */
-  incBackpressureTimeouts() {
-    this.backpressureTimeoutsTotal.inc();
+  getMigrationStatus() {
+    return this.migrationManager?.getStatus() ?? null;
   }
-  // === Connection scaling metric methods ===
   /**
-   * Increment counter for accepted connections.
+   * Check if partition is currently migrating
    */
-  incConnectionsAccepted() {
-    this.connectionsAcceptedTotal.inc();
+  isMigrating(partitionId) {
+    return this.migrationManager?.isActive(partitionId) ?? false;
   }
   /**
-   * Increment counter for rejected connections.
+   * Check if any partition is currently migrating
    */
-  incConnectionsRejected() {
-    this.connectionsRejectedTotal.inc();
+  isRebalancing() {
+    const status = this.getMigrationStatus();
+    return status?.inProgress ?? false;
   }
   /**
-   * Set the current number of pending connections.
+   * Get MigrationManager for configuration
    */
-  setConnectionsPending(count) {
-    this.connectionsPending.set(count);
+  getMigrationManager() {
+    return this.migrationManager;
   }
   /**
-   * Set the current connection rate per second.
+   * Cancel all migrations
    */
-  setConnectionRatePerSecond(rate) {
-    this.connectionRatePerSecond.set(rate);
-  }
-  async getMetrics() {
-    return this.registry.metrics();
-  }
-  async getMetricsJson() {
-    const metrics = await this.registry.getMetricsAsJSON();
-    const result = {};
-    for (const metric of metrics) {
-      if (metric.values.length === 1) {
-        result[metric.name] = metric.values[0].value;
-      } else {
-        result[metric.name] = metric.values;
-      }
+  async cancelMigrations() {
+    if (this.migrationManager) {
+      await this.migrationManager.cancelAll();
     }
-    return result;
-  }
-  getContentType() {
-    return this.registry.contentType;
   }
 };
 
-// src/system/SystemManager.ts
-var SystemManager = class {
-  constructor(cluster, metrics, getMap) {
-    this.cluster = cluster;
-    this.metrics = metrics;
-    this.getMap = getMap;
-  }
-  start() {
-    this.setupClusterMap();
-    this.setupStatsMap();
-    this.setupMapsMap();
-    this.statsInterval = setInterval(() => this.updateStats(), 5e3);
-    this.cluster.on("memberJoined", () => this.updateClusterMap());
-    this.cluster.on("memberLeft", () => this.updateClusterMap());
-    this.updateClusterMap();
-    this.updateStats();
+// src/cluster/LockManager.ts
+import { EventEmitter as EventEmitter5 } from "events";
+var _LockManager = class _LockManager extends EventEmitter5 {
+  // 5 minutes
+  constructor() {
+    super();
+    this.locks = /* @__PURE__ */ new Map();
+    this.checkInterval = setInterval(() => this.cleanupExpiredLocks(), 1e3);
   }
   stop() {
-    if (this.statsInterval) {
-      clearInterval(this.statsInterval);
-    }
+    clearInterval(this.checkInterval);
   }
-  notifyMapCreated(mapName) {
-    if (mapName.startsWith("$sys/")) return;
+  acquire(name, clientId, requestId, ttl) {
+    const safeTtl = Math.max(_LockManager.MIN_TTL, Math.min(ttl || _LockManager.MIN_TTL, _LockManager.MAX_TTL));
+    let lock = this.locks.get(name);
+    if (!lock) {
+      lock = {
+        name,
+        owner: "",
+        fencingToken: 0,
+        expiry: 0,
+        queue: []
+      };
+      this.locks.set(name, lock);
+    }
+    const now = Date.now();
+    if (!lock.owner || lock.expiry < now) {
+      this.grantLock(lock, clientId, safeTtl);
+      return { granted: true, fencingToken: lock.fencingToken };
+    }
+    if (lock.owner === clientId) {
+      lock.expiry = Math.max(lock.expiry, now + safeTtl);
+      logger.info({ name, clientId, fencingToken: lock.fencingToken }, "Lock lease extended");
+      return { granted: true, fencingToken: lock.fencingToken };
+    }
+    lock.queue.push({ clientId, requestId, ttl: safeTtl, timestamp: now });
+    logger.info({ name, clientId, queueLength: lock.queue.length }, "Lock queued");
+    return { granted: false };
+  }
+  release(name, clientId, fencingToken) {
+    const lock = this.locks.get(name);
+    if (!lock) return false;
+    if (lock.owner !== clientId) {
+      logger.warn({ name, clientId, owner: lock.owner }, "Release failed: Not owner");
+      return false;
+    }
+    if (lock.fencingToken !== fencingToken) {
+      logger.warn({ name, clientId, sentToken: fencingToken, actualToken: lock.fencingToken }, "Release failed: Token mismatch");
+      return false;
+    }
+    this.processNext(lock);
+    return true;
+  }
+  handleClientDisconnect(clientId) {
+    for (const lock of this.locks.values()) {
+      if (lock.owner === clientId) {
+        logger.info({ name: lock.name, clientId }, "Releasing lock due to disconnect");
+        this.processNext(lock);
+      } else {
+        const initialLen = lock.queue.length;
+        lock.queue = lock.queue.filter((req) => req.clientId !== clientId);
+        if (lock.queue.length < initialLen) {
+          logger.info({ name: lock.name, clientId }, "Removed from lock queue due to disconnect");
+        }
+      }
+    }
+  }
+  grantLock(lock, clientId, ttl) {
+    lock.owner = clientId;
+    lock.expiry = Date.now() + ttl;
+    lock.fencingToken++;
+    logger.info({ name: lock.name, clientId, fencingToken: lock.fencingToken }, "Lock granted");
+  }
+  processNext(lock) {
+    const now = Date.now();
+    lock.owner = "";
+    lock.expiry = 0;
+    while (lock.queue.length > 0) {
+      const next = lock.queue.shift();
+      this.grantLock(lock, next.clientId, next.ttl);
+      this.emit("lockGranted", {
+        clientId: next.clientId,
+        requestId: next.requestId,
+        name: lock.name,
+        fencingToken: lock.fencingToken
+      });
+      return;
+    }
+    if (lock.queue.length === 0) {
+      this.locks.delete(lock.name);
+    }
+  }
+  cleanupExpiredLocks() {
+    const now = Date.now();
+    const lockNames = Array.from(this.locks.keys());
+    for (const name of lockNames) {
+      const lock = this.locks.get(name);
+      if (!lock) continue;
+      if (lock.owner && lock.expiry < now) {
+        logger.info({ name: lock.name, owner: lock.owner }, "Lock expired, processing next");
+        this.processNext(lock);
+      } else if (!lock.owner && lock.queue.length === 0) {
+        this.locks.delete(name);
+      }
+    }
+  }
+};
+_LockManager.MIN_TTL = 1e3;
+// 1 second
+_LockManager.MAX_TTL = 3e5;
+var LockManager = _LockManager;
+
+// src/security/SecurityManager.ts
+var SecurityManager = class {
+  constructor(policies = []) {
+    this.policies = [];
+    this.policies = policies;
+  }
+  addPolicy(policy) {
+    this.policies.push(policy);
+  }
+  checkPermission(principal, mapName, action) {
+    if (principal.roles.includes("ADMIN")) {
+      return true;
+    }
+    if (mapName.startsWith("$sys/")) {
+      logger.warn({ userId: principal.userId, mapName }, "Access Denied: System Map requires ADMIN role");
+      return false;
+    }
+    for (const policy of this.policies) {
+      const hasRole = this.hasRole(principal, policy.role);
+      const matchesMap = this.matchesMap(mapName, policy.mapNamePattern, principal);
+      if (hasRole && matchesMap) {
+        if (policy.actions.includes("ALL") || policy.actions.includes(action)) {
+          return true;
+        }
+      } else {
+      }
+    }
+    logger.warn({
+      userId: principal.userId,
+      roles: principal.roles,
+      mapName,
+      action,
+      policyCount: this.policies.length
+    }, "SecurityManager: Access Denied - No matching policy found");
+    return false;
+  }
+  filterObject(object, principal, mapName) {
+    if (!object || typeof object !== "object") return object;
+    if (principal.roles.includes("ADMIN")) return object;
+    if (Array.isArray(object)) {
+      return object.map((item) => this.filterObject(item, principal, mapName));
+    }
+    let allowedFields = null;
+    let accessGranted = false;
+    for (const policy of this.policies) {
+      if (this.hasRole(principal, policy.role) && this.matchesMap(mapName, policy.mapNamePattern, principal)) {
+        if (policy.actions.includes("ALL") || policy.actions.includes("READ")) {
+          accessGranted = true;
+          if (!policy.allowedFields || policy.allowedFields.length === 0 || policy.allowedFields.includes("*")) {
+            return object;
+          }
+          if (allowedFields === null) allowedFields = /* @__PURE__ */ new Set();
+          policy.allowedFields.forEach((f) => allowedFields.add(f));
+        }
+      }
+    }
+    if (!accessGranted) return null;
+    if (allowedFields === null) return object;
+    const filtered = {};
+    for (const key of Object.keys(object)) {
+      if (allowedFields.has(key)) {
+        filtered[key] = object[key];
+      }
+    }
+    return filtered;
+  }
+  hasRole(principal, role) {
+    return principal.roles.includes(role);
+  }
+  matchesMap(mapName, pattern, principal) {
+    let finalPattern = pattern;
+    if (pattern.includes("{userId}") && principal) {
+      finalPattern = pattern.replace("{userId}", principal.userId);
+    }
+    if (finalPattern === "*") return true;
+    if (finalPattern === mapName) return true;
+    if (finalPattern.endsWith("*")) {
+      const prefix = finalPattern.slice(0, -1);
+      return mapName.startsWith(prefix);
+    }
+    return false;
+  }
+};
+
+// src/monitoring/MetricsService.ts
+import { Registry, Gauge, Counter, Summary, collectDefaultMetrics } from "prom-client";
+var MetricsService = class {
+  constructor() {
+    this.registry = new Registry();
+    collectDefaultMetrics({ register: this.registry, prefix: "topgun_" });
+    this.connectedClients = new Gauge({
+      name: "topgun_connected_clients",
+      help: "Number of currently connected clients",
+      registers: [this.registry]
+    });
+    this.mapSizeItems = new Gauge({
+      name: "topgun_map_size_items",
+      help: "Number of items in a map",
+      labelNames: ["map"],
+      registers: [this.registry]
+    });
+    this.opsTotal = new Counter({
+      name: "topgun_ops_total",
+      help: "Total number of operations",
+      labelNames: ["type", "map"],
+      registers: [this.registry]
+    });
+    this.memoryUsage = new Gauge({
+      name: "topgun_memory_usage_bytes",
+      help: "Current memory usage in bytes",
+      registers: [this.registry],
+      collect() {
+        this.set(process.memoryUsage().heapUsed);
+      }
+    });
+    this.clusterMembers = new Gauge({
+      name: "topgun_cluster_members",
+      help: "Number of active cluster members",
+      registers: [this.registry]
+    });
+    this.eventsRoutedTotal = new Counter({
+      name: "topgun_events_routed_total",
+      help: "Total number of events processed for routing",
+      registers: [this.registry]
+    });
+    this.eventsFilteredBySubscription = new Counter({
+      name: "topgun_events_filtered_by_subscription",
+      help: "Events NOT sent due to no active subscriptions",
+      registers: [this.registry]
+    });
+    this.subscribersPerEvent = new Summary({
+      name: "topgun_subscribers_per_event",
+      help: "Distribution of subscribers per event",
+      percentiles: [0.5, 0.9, 0.99],
+      registers: [this.registry]
+    });
+    this.eventQueueSize = new Gauge({
+      name: "topgun_event_queue_size",
+      help: "Current size of the event queue across all stripes",
+      labelNames: ["stripe"],
+      registers: [this.registry]
+    });
+    this.eventQueueEnqueued = new Counter({
+      name: "topgun_event_queue_enqueued_total",
+      help: "Total number of events enqueued",
+      registers: [this.registry]
+    });
+    this.eventQueueDequeued = new Counter({
+      name: "topgun_event_queue_dequeued_total",
+      help: "Total number of events dequeued",
+      registers: [this.registry]
+    });
+    this.eventQueueRejected = new Counter({
+      name: "topgun_event_queue_rejected_total",
+      help: "Total number of events rejected due to queue capacity",
+      registers: [this.registry]
+    });
+    this.backpressureSyncForcedTotal = new Counter({
+      name: "topgun_backpressure_sync_forced_total",
+      help: "Total number of times sync processing was forced",
+      registers: [this.registry]
+    });
+    this.backpressurePendingOps = new Gauge({
+      name: "topgun_backpressure_pending_ops",
+      help: "Current number of pending async operations",
+      registers: [this.registry]
+    });
+    this.backpressureWaitsTotal = new Counter({
+      name: "topgun_backpressure_waits_total",
+      help: "Total number of times had to wait for capacity",
+      registers: [this.registry]
+    });
+    this.backpressureTimeoutsTotal = new Counter({
+      name: "topgun_backpressure_timeouts_total",
+      help: "Total number of backpressure timeouts",
+      registers: [this.registry]
+    });
+    this.connectionsAcceptedTotal = new Counter({
+      name: "topgun_connections_accepted_total",
+      help: "Total number of connections accepted",
+      registers: [this.registry]
+    });
+    this.connectionsRejectedTotal = new Counter({
+      name: "topgun_connections_rejected_total",
+      help: "Total number of connections rejected due to rate limiting",
+      registers: [this.registry]
+    });
+    this.connectionsPending = new Gauge({
+      name: "topgun_connections_pending",
+      help: "Number of connections currently pending (handshake in progress)",
+      registers: [this.registry]
+    });
+    this.connectionRatePerSecond = new Gauge({
+      name: "topgun_connection_rate_per_second",
+      help: "Current connection rate per second",
+      registers: [this.registry]
+    });
+  }
+  destroy() {
+    this.registry.clear();
+  }
+  setConnectedClients(count) {
+    this.connectedClients.set(count);
+  }
+  setMapSize(mapName, size) {
+    this.mapSizeItems.set({ map: mapName }, size);
+  }
+  incOp(type, mapName) {
+    this.opsTotal.inc({ type, map: mapName });
+  }
+  setClusterMembers(count) {
+    this.clusterMembers.set(count);
+  }
+  // === Subscription-based routing metric methods ===
+  /**
+   * Increment counter for total events processed for routing.
+   */
+  incEventsRouted() {
+    this.eventsRoutedTotal.inc();
+  }
+  /**
+   * Increment counter for events filtered out due to no subscribers.
+   */
+  incEventsFilteredBySubscription() {
+    this.eventsFilteredBySubscription.inc();
+  }
+  /**
+   * Record the number of subscribers for an event (for average calculation).
+   */
+  recordSubscribersPerEvent(count) {
+    this.subscribersPerEvent.observe(count);
+  }
+  // === Bounded event queue metric methods ===
+  /**
+   * Set the current size of a specific queue stripe.
+   */
+  setEventQueueSize(stripe, size) {
+    this.eventQueueSize.set({ stripe: String(stripe) }, size);
+  }
+  /**
+   * Increment counter for events enqueued.
+   */
+  incEventQueueEnqueued() {
+    this.eventQueueEnqueued.inc();
+  }
+  /**
+   * Increment counter for events dequeued.
+   */
+  incEventQueueDequeued() {
+    this.eventQueueDequeued.inc();
+  }
+  /**
+   * Increment counter for events rejected due to queue capacity.
+   */
+  incEventQueueRejected() {
+    this.eventQueueRejected.inc();
+  }
+  // === Backpressure metric methods ===
+  /**
+   * Increment counter for forced sync operations.
+   */
+  incBackpressureSyncForced() {
+    this.backpressureSyncForcedTotal.inc();
+  }
+  /**
+   * Set the current number of pending async operations.
+   */
+  setBackpressurePendingOps(count) {
+    this.backpressurePendingOps.set(count);
+  }
+  /**
+   * Increment counter for times had to wait for capacity.
+   */
+  incBackpressureWaits() {
+    this.backpressureWaitsTotal.inc();
+  }
+  /**
+   * Increment counter for backpressure timeouts.
+   */
+  incBackpressureTimeouts() {
+    this.backpressureTimeoutsTotal.inc();
+  }
+  // === Connection scaling metric methods ===
+  /**
+   * Increment counter for accepted connections.
+   */
+  incConnectionsAccepted() {
+    this.connectionsAcceptedTotal.inc();
+  }
+  /**
+   * Increment counter for rejected connections.
+   */
+  incConnectionsRejected() {
+    this.connectionsRejectedTotal.inc();
+  }
+  /**
+   * Set the current number of pending connections.
+   */
+  setConnectionsPending(count) {
+    this.connectionsPending.set(count);
+  }
+  /**
+   * Set the current connection rate per second.
+   */
+  setConnectionRatePerSecond(rate) {
+    this.connectionRatePerSecond.set(rate);
+  }
+  async getMetrics() {
+    return this.registry.metrics();
+  }
+  async getMetricsJson() {
+    const metrics = await this.registry.getMetricsAsJSON();
+    const result = {};
+    for (const metric of metrics) {
+      if (metric.values.length === 1) {
+        result[metric.name] = metric.values[0].value;
+      } else {
+        result[metric.name] = metric.values;
+      }
+    }
+    return result;
+  }
+  getContentType() {
+    return this.registry.contentType;
+  }
+};
+
+// src/system/SystemManager.ts
+var SystemManager = class {
+  constructor(cluster, metrics, getMap) {
+    this.cluster = cluster;
+    this.metrics = metrics;
+    this.getMap = getMap;
+  }
+  start() {
+    this.setupClusterMap();
+    this.setupStatsMap();
+    this.setupMapsMap();
+    this.statsInterval = setInterval(() => this.updateStats(), 5e3);
+    this.cluster.on("memberJoined", () => this.updateClusterMap());
+    this.cluster.on("memberLeft", () => this.updateClusterMap());
+    this.updateClusterMap();
+    this.updateStats();
+  }
+  stop() {
+    if (this.statsInterval) {
+      clearInterval(this.statsInterval);
+    }
+  }
+  notifyMapCreated(mapName) {
+    if (mapName.startsWith("$sys/")) return;
     this.updateMapsMap(mapName);
   }
   setupClusterMap() {
@@ -1411,8 +2575,8 @@ var SystemManager = class {
 };
 
 // src/utils/BoundedEventQueue.ts
-import { EventEmitter as EventEmitter3 } from "events";
-var BoundedEventQueue = class extends EventEmitter3 {
+import { EventEmitter as EventEmitter6 } from "events";
+var BoundedEventQueue = class extends EventEmitter6 {
   constructor(options) {
     super();
     this.queue = [];
@@ -1844,7 +3008,7 @@ var BackpressureRegulator = class {
 
 // src/utils/CoalescingWriter.ts
 import { WebSocket as WebSocket2 } from "ws";
-import { serialize as serialize2 } from "@topgunbuild/core";
+import { serialize as serialize3 } from "@topgunbuild/core";
 
 // src/memory/BufferPool.ts
 var DEFAULT_CONFIG2 = {
@@ -2375,7 +3539,7 @@ var CoalescingWriter = class {
     if (this.closed) {
       return;
     }
-    const data = serialize2(message);
+    const data = serialize3(message);
     this.writeRaw(data, urgent);
   }
   /**
@@ -2559,7 +3723,7 @@ var CoalescingWriter = class {
       offset += msg.data.length;
     }
     const usedBatch = batch.subarray(0, totalSize);
-    const batchEnvelope = serialize2({
+    const batchEnvelope = serialize3({
       type: "BATCH",
       count: messages.length,
       data: usedBatch
@@ -2574,13 +3738,23 @@ var CoalescingWriter = class {
 // src/utils/coalescingPresets.ts
 var coalescingPresets = {
   /**
-   * Conservative defaults - good for low-latency workloads.
-   * Minimizes batching delay at the cost of more network calls.
-   * Use for: gaming, real-time chat, interactive applications.
+   * Low latency - optimized for minimal response time.
+   * Best for: gaming, real-time chat, interactive applications.
+   * Benchmark: p50=2ms, ~18K ops/sec
+   */
+  lowLatency: {
+    maxBatchSize: 100,
+    maxDelayMs: 1,
+    maxBatchBytes: 65536
+    // 64KB
+  },
+  /**
+   * Conservative - good balance of latency and batching.
+   * Use for: general purpose with latency sensitivity.
    */
   conservative: {
     maxBatchSize: 100,
-    maxDelayMs: 5,
+    maxDelayMs: 2,
     maxBatchBytes: 65536
     // 64KB
   },
@@ -2591,7 +3765,7 @@ var coalescingPresets = {
    */
   balanced: {
     maxBatchSize: 300,
-    maxDelayMs: 8,
+    maxDelayMs: 2,
     maxBatchBytes: 131072
     // 128KB
   },
@@ -2599,10 +3773,11 @@ var coalescingPresets = {
    * High throughput - optimized for write-heavy workloads.
    * Higher batching for better network utilization.
    * Use for: data ingestion, logging, IoT data streams.
+   * Benchmark: p50=7ms, ~18K ops/sec
    */
   highThroughput: {
     maxBatchSize: 500,
-    maxDelayMs: 10,
+    maxDelayMs: 2,
     maxBatchBytes: 262144
     // 256KB
   },
@@ -2613,7 +3788,7 @@ var coalescingPresets = {
    */
   aggressive: {
     maxBatchSize: 1e3,
-    maxDelayMs: 15,
+    maxDelayMs: 5,
     maxBatchBytes: 524288
     // 512KB
   }
@@ -3144,6 +4319,7 @@ var WorkerPool = class {
 
 // src/workers/MerkleWorker.ts
 import { join as join2 } from "path";
+import { hashString as coreHashString } from "@topgunbuild/core";
 var WORKER_THRESHOLD = 10;
 var taskIdCounter = 0;
 function generateTaskId() {
@@ -3353,12 +4529,7 @@ var MerkleWorker = class {
   }
   // ============ Hash utilities ============
   hashString(str) {
-    let hash = 2166136261;
-    for (let i = 0; i < str.length; i++) {
-      hash ^= str.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-    return hash >>> 0;
+    return coreHashString(str);
   }
   buildTree(entries, depth) {
     const root = { hash: 0, children: {} };
@@ -3857,726 +5028,1387 @@ var SharedMemoryManager = class {
     return true;
   }
   /**
-   * Read data length from a slot.
+   * Read data length from a slot.
+   */
+  getDataLength(slotIndex) {
+    const lengthView = new DataView(
+      this.buffer,
+      this.getLengthOffset(slotIndex),
+      4
+    );
+    return lengthView.getUint32(0, true);
+  }
+  /**
+   * Get data view for a slot (for reading).
+   */
+  getDataView(slotIndex) {
+    const length = this.getDataLength(slotIndex);
+    const dataOffset = this.getDataOffset(slotIndex);
+    return new Uint8Array(this.buffer, dataOffset, length);
+  }
+  /**
+   * Get slot status.
+   */
+  getStatus(slotIndex) {
+    return Atomics.load(this.statusArray, this.getStatusOffset(slotIndex));
+  }
+  /**
+   * Wait for a specific status with timeout.
+   * Returns the actual status (may differ if timeout occurred).
+   */
+  waitForStatus(slotIndex, expectedStatus, timeoutMs = 5e3) {
+    const statusOffset = this.getStatusOffset(slotIndex);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      const status = Atomics.load(this.statusArray, statusOffset);
+      if (status === expectedStatus || status === 255 /* ERROR */) {
+        return status;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining > 0) {
+        Atomics.wait(
+          this.statusArray,
+          statusOffset,
+          status,
+          Math.min(remaining, 100)
+        );
+      }
+    }
+    return Atomics.load(this.statusArray, statusOffset);
+  }
+  /**
+   * Wait for result and read it.
+   * Returns null on timeout or error.
+   */
+  waitForResult(slot, timeoutMs = 5e3) {
+    const status = this.waitForStatus(
+      slot.index,
+      4 /* RESULT_READY */,
+      timeoutMs
+    );
+    if (status === 4 /* RESULT_READY */) {
+      const length = this.getDataLength(slot.index);
+      const result = new Uint8Array(length);
+      result.set(slot.dataView.subarray(0, length));
+      return result;
+    }
+    return null;
+  }
+  /**
+   * Get the SharedArrayBuffer for passing to workers.
+   */
+  getBuffer() {
+    return this.buffer;
+  }
+  /**
+   * Get configuration needed by workers.
+   */
+  getWorkerConfig() {
+    return {
+      sharedBuffer: this.buffer,
+      slotSize: this.slotSize,
+      slotCount: this.slotCount,
+      metadataSize: this.metadataSize
+    };
+  }
+  /**
+   * Get statistics.
+   */
+  getStats() {
+    return {
+      totalSize: this.buffer.byteLength,
+      slotCount: this.slotCount,
+      slotSize: this.slotSize,
+      allocatedSlots: this.allocatedCount,
+      availableSlots: this.freeSlots.size,
+      peakUsage: this.peakUsage,
+      totalAllocations: this.totalAllocations,
+      totalReleases: this.totalReleases
+    };
+  }
+  /**
+   * Check if SharedArrayBuffer is available in current environment.
+   */
+  static isAvailable() {
+    try {
+      new SharedArrayBuffer(1);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Shutdown and release resources.
+   * Resets all slots to FREE status.
+   */
+  shutdown() {
+    for (let i = 0; i < this.slotCount; i++) {
+      Atomics.store(this.statusArray, this.getStatusOffset(i), 0 /* FREE */);
+    }
+    this.freeSlots.clear();
+    for (let i = 0; i < this.slotCount; i++) {
+      this.freeSlots.add(i);
+    }
+    this.allocatedCount = 0;
+  }
+};
+
+// src/tasklet/TaskletScheduler.ts
+var DEFAULT_CONFIG4 = {
+  defaultTimeBudgetMs: 5,
+  maxConcurrent: 10,
+  tickIntervalMs: 1,
+  metricsEnabled: true
+};
+var TaskletScheduler = class {
+  constructor(config) {
+    this.activeTasklets = /* @__PURE__ */ new Map();
+    this.tickTimer = null;
+    this.isRunning = false;
+    this.isShuttingDown = false;
+    // Metrics
+    this.totalScheduled = 0;
+    this.completedTasklets = 0;
+    this.cancelledTasklets = 0;
+    this.totalIterations = 0;
+    this.singleIterationCompletions = 0;
+    this.totalExecutionTimeMs = 0;
+    this.config = { ...DEFAULT_CONFIG4, ...config };
+  }
+  /**
+   * Schedule a tasklet for execution.
+   * Returns a promise that resolves when the tasklet completes.
+   */
+  schedule(tasklet) {
+    if (this.isShuttingDown) {
+      return Promise.reject(new Error("Scheduler is shutting down"));
+    }
+    return new Promise((resolve, reject) => {
+      const taskletId = `${tasklet.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      if (this.activeTasklets.size >= this.config.maxConcurrent) {
+        reject(new Error(`Max concurrent tasklets (${this.config.maxConcurrent}) reached`));
+        return;
+      }
+      const state = {
+        tasklet,
+        resolve,
+        reject,
+        iterations: 0,
+        startTime: Date.now(),
+        lastProgressTime: Date.now()
+      };
+      this.activeTasklets.set(taskletId, state);
+      this.totalScheduled++;
+      if (!this.isRunning) {
+        this.startScheduler();
+      }
+    });
+  }
+  /**
+   * Run a tasklet synchronously (blocking).
+   * Useful for small operations or when cooperative scheduling isn't needed.
+   */
+  runSync(tasklet) {
+    let state;
+    let iterations = 0;
+    const startTime = Date.now();
+    do {
+      state = tasklet.call();
+      iterations++;
+    } while (state === "MADE_PROGRESS");
+    if (state === "NO_PROGRESS") {
+      throw new Error(`Tasklet ${tasklet.name} made no progress`);
+    }
+    if (this.config.metricsEnabled) {
+      this.totalIterations += iterations;
+      this.totalExecutionTimeMs += Date.now() - startTime;
+      if (iterations === 1) {
+        this.singleIterationCompletions++;
+      }
+    }
+    return tasklet.getResult();
+  }
+  /**
+   * Cancel a specific tasklet by name pattern.
+   * Returns the number of tasklets cancelled.
+   */
+  cancel(namePattern) {
+    let cancelled = 0;
+    const pattern = typeof namePattern === "string" ? new RegExp(`^${namePattern}`) : namePattern;
+    for (const [id, state] of this.activeTasklets) {
+      if (pattern.test(state.tasklet.name)) {
+        this.cancelTasklet(id, state);
+        cancelled++;
+      }
+    }
+    return cancelled;
+  }
+  /**
+   * Cancel all running tasklets.
+   */
+  cancelAll() {
+    let cancelled = 0;
+    for (const [id, state] of this.activeTasklets) {
+      this.cancelTasklet(id, state);
+      cancelled++;
+    }
+    return cancelled;
+  }
+  /**
+   * Get scheduler statistics.
+   */
+  getStats() {
+    return {
+      totalScheduled: this.totalScheduled,
+      activeTasklets: this.activeTasklets.size,
+      completedTasklets: this.completedTasklets,
+      cancelledTasklets: this.cancelledTasklets,
+      totalIterations: this.totalIterations,
+      avgIterationsPerTasklet: this.completedTasklets > 0 ? this.totalIterations / this.completedTasklets : 0,
+      singleIterationCompletions: this.singleIterationCompletions,
+      totalExecutionTimeMs: this.totalExecutionTimeMs
+    };
+  }
+  /**
+   * Reset statistics.
    */
-  getDataLength(slotIndex) {
-    const lengthView = new DataView(
-      this.buffer,
-      this.getLengthOffset(slotIndex),
-      4
-    );
-    return lengthView.getUint32(0, true);
+  resetStats() {
+    this.totalScheduled = 0;
+    this.completedTasklets = 0;
+    this.cancelledTasklets = 0;
+    this.totalIterations = 0;
+    this.singleIterationCompletions = 0;
+    this.totalExecutionTimeMs = 0;
   }
   /**
-   * Get data view for a slot (for reading).
+   * Shutdown the scheduler.
+   * Cancels all running tasklets and stops the tick timer.
    */
-  getDataView(slotIndex) {
-    const length = this.getDataLength(slotIndex);
-    const dataOffset = this.getDataOffset(slotIndex);
-    return new Uint8Array(this.buffer, dataOffset, length);
+  shutdown() {
+    this.isShuttingDown = true;
+    this.cancelAll();
+    this.stopScheduler();
   }
   /**
-   * Get slot status.
+   * Check if scheduler is running.
    */
-  getStatus(slotIndex) {
-    return Atomics.load(this.statusArray, this.getStatusOffset(slotIndex));
+  get running() {
+    return this.isRunning;
   }
   /**
-   * Wait for a specific status with timeout.
-   * Returns the actual status (may differ if timeout occurred).
+   * Get number of active tasklets.
    */
-  waitForStatus(slotIndex, expectedStatus, timeoutMs = 5e3) {
-    const statusOffset = this.getStatusOffset(slotIndex);
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-      const status = Atomics.load(this.statusArray, statusOffset);
-      if (status === expectedStatus || status === 255 /* ERROR */) {
-        return status;
+  get activeCount() {
+    return this.activeTasklets.size;
+  }
+  startScheduler() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    this.scheduleTick();
+  }
+  stopScheduler() {
+    this.isRunning = false;
+    if (this.tickTimer) {
+      clearImmediate(this.tickTimer);
+      this.tickTimer = null;
+    }
+  }
+  scheduleTick() {
+    if (!this.isRunning) return;
+    this.tickTimer = setImmediate(() => {
+      this.tick();
+    });
+  }
+  tick() {
+    if (!this.isRunning || this.activeTasklets.size === 0) {
+      this.stopScheduler();
+      return;
+    }
+    const tickStart = Date.now();
+    const taskletIds = Array.from(this.activeTasklets.keys());
+    for (const id of taskletIds) {
+      const state = this.activeTasklets.get(id);
+      if (!state) continue;
+      try {
+        const iterationStart = Date.now();
+        const result = state.tasklet.call();
+        const iterationTime = Date.now() - iterationStart;
+        state.iterations++;
+        state.lastProgressTime = Date.now();
+        if (this.config.metricsEnabled) {
+          this.totalIterations++;
+          this.totalExecutionTimeMs += iterationTime;
+        }
+        if (result === "DONE") {
+          this.completeTasklet(id, state);
+        } else if (result === "NO_PROGRESS") {
+        }
+      } catch (error) {
+        this.failTasklet(id, state, error);
       }
-      const remaining = deadline - Date.now();
-      if (remaining > 0) {
-        Atomics.wait(
-          this.statusArray,
-          statusOffset,
-          status,
-          Math.min(remaining, 100)
-        );
+      if (Date.now() - tickStart > this.config.defaultTimeBudgetMs * 2) {
+        break;
       }
     }
-    return Atomics.load(this.statusArray, statusOffset);
+    if (this.activeTasklets.size > 0) {
+      this.scheduleTick();
+    } else {
+      this.stopScheduler();
+    }
   }
-  /**
-   * Wait for result and read it.
-   * Returns null on timeout or error.
-   */
-  waitForResult(slot, timeoutMs = 5e3) {
-    const status = this.waitForStatus(
-      slot.index,
-      4 /* RESULT_READY */,
-      timeoutMs
-    );
-    if (status === 4 /* RESULT_READY */) {
-      const length = this.getDataLength(slot.index);
-      const result = new Uint8Array(length);
-      result.set(slot.dataView.subarray(0, length));
-      return result;
+  completeTasklet(id, state) {
+    this.activeTasklets.delete(id);
+    this.completedTasklets++;
+    if (state.iterations === 1) {
+      this.singleIterationCompletions++;
     }
-    return null;
+    try {
+      const result = state.tasklet.getResult();
+      state.resolve(result);
+    } catch (error) {
+      state.reject(error);
+    }
+  }
+  failTasklet(id, state, error) {
+    this.activeTasklets.delete(id);
+    state.reject(error);
+  }
+  cancelTasklet(id, state) {
+    this.activeTasklets.delete(id);
+    this.cancelledTasklets++;
+    if (state.tasklet.onCancel) {
+      try {
+        state.tasklet.onCancel();
+      } catch {
+      }
+    }
+    state.reject(new Error(`Tasklet ${state.tasklet.name} was cancelled`));
+  }
+};
+
+// src/tasklet/tasklets/IteratorTasklet.ts
+var DEFAULT_CONFIG5 = {
+  timeBudgetMs: 5,
+  maxItemsPerIteration: 1e3
+};
+var IteratorTasklet = class {
+  constructor(iterator, config) {
+    this.itemsProcessed = 0;
+    this.isDone = false;
+    this.iterator = iterator;
+    this.config = { ...DEFAULT_CONFIG5, ...config };
   }
   /**
-   * Get the SharedArrayBuffer for passing to workers.
+   * Execute one chunk of iteration.
    */
-  getBuffer() {
-    return this.buffer;
+  call() {
+    if (this.isDone) {
+      return "DONE";
+    }
+    const deadline = Date.now() + this.config.timeBudgetMs;
+    let processedThisIteration = 0;
+    while (Date.now() < deadline && processedThisIteration < this.config.maxItemsPerIteration) {
+      const { value, done } = this.iterator.next();
+      if (done) {
+        this.isDone = true;
+        return "DONE";
+      }
+      this.processItem(value);
+      this.itemsProcessed++;
+      processedThisIteration++;
+    }
+    return "MADE_PROGRESS";
   }
   /**
-   * Get configuration needed by workers.
+   * Called when tasklet is cancelled.
    */
-  getWorkerConfig() {
-    return {
-      sharedBuffer: this.buffer,
-      slotSize: this.slotSize,
-      slotCount: this.slotCount,
-      metadataSize: this.metadataSize
-    };
+  onCancel() {
   }
   /**
-   * Get statistics.
+   * Get number of items processed so far.
    */
-  getStats() {
-    return {
-      totalSize: this.buffer.byteLength,
-      slotCount: this.slotCount,
-      slotSize: this.slotSize,
-      allocatedSlots: this.allocatedCount,
-      availableSlots: this.freeSlots.size,
-      peakUsage: this.peakUsage,
-      totalAllocations: this.totalAllocations,
-      totalReleases: this.totalReleases
-    };
+  get processed() {
+    return this.itemsProcessed;
+  }
+};
+var FilterTasklet = class extends IteratorTasklet {
+  constructor(name, iterator, predicate, config) {
+    super(iterator, config);
+    this.results = [];
+    this.name = name;
+    this.predicate = predicate;
+  }
+  processItem(item) {
+    if (this.predicate(item)) {
+      this.results.push(item);
+    }
+  }
+  getResult() {
+    return this.results;
+  }
+};
+var MapTasklet = class extends IteratorTasklet {
+  constructor(name, iterator, mapper, config) {
+    super(iterator, config);
+    this.results = [];
+    this.name = name;
+    this.mapper = mapper;
+  }
+  processItem(item) {
+    this.results.push(this.mapper(item));
+  }
+  getResult() {
+    return this.results;
+  }
+};
+var ForEachTasklet = class extends IteratorTasklet {
+  constructor(name, iterator, action, config) {
+    super(iterator, config);
+    this.name = name;
+    this.action = action;
+  }
+  processItem(item) {
+    this.action(item);
+  }
+  getResult() {
+    return this.itemsProcessed;
   }
-  /**
-   * Check if SharedArrayBuffer is available in current environment.
-   */
-  static isAvailable() {
-    try {
-      new SharedArrayBuffer(1);
-      return true;
-    } catch {
-      return false;
-    }
+};
+var ReduceTasklet = class extends IteratorTasklet {
+  constructor(name, iterator, initialValue, reducer, config) {
+    super(iterator, config);
+    this.name = name;
+    this.accumulator = initialValue;
+    this.reducer = reducer;
   }
-  /**
-   * Shutdown and release resources.
-   * Resets all slots to FREE status.
-   */
-  shutdown() {
-    for (let i = 0; i < this.slotCount; i++) {
-      Atomics.store(this.statusArray, this.getStatusOffset(i), 0 /* FREE */);
-    }
-    this.freeSlots.clear();
-    for (let i = 0; i < this.slotCount; i++) {
-      this.freeSlots.add(i);
-    }
-    this.allocatedCount = 0;
+  processItem(item) {
+    this.accumulator = this.reducer(this.accumulator, item);
+  }
+  getResult() {
+    return this.accumulator;
   }
 };
 
-// src/tasklet/TaskletScheduler.ts
-var DEFAULT_CONFIG4 = {
-  defaultTimeBudgetMs: 5,
-  maxConcurrent: 10,
-  tickIntervalMs: 1,
-  metricsEnabled: true
-};
-var TaskletScheduler = class {
+// src/ack/WriteAckManager.ts
+import { EventEmitter as EventEmitter7 } from "events";
+import {
+  WriteConcern,
+  DEFAULT_WRITE_CONCERN_TIMEOUT,
+  isWriteConcernAchieved,
+  getHighestWriteConcernLevel
+} from "@topgunbuild/core";
+var WriteAckManager = class extends EventEmitter7 {
   constructor(config) {
-    this.activeTasklets = /* @__PURE__ */ new Map();
-    this.tickTimer = null;
-    this.isRunning = false;
-    this.isShuttingDown = false;
-    // Metrics
-    this.totalScheduled = 0;
-    this.completedTasklets = 0;
-    this.cancelledTasklets = 0;
-    this.totalIterations = 0;
-    this.singleIterationCompletions = 0;
-    this.totalExecutionTimeMs = 0;
-    this.config = { ...DEFAULT_CONFIG4, ...config };
+    super();
+    this.pending = /* @__PURE__ */ new Map();
+    this.defaultTimeout = config?.defaultTimeout ?? DEFAULT_WRITE_CONCERN_TIMEOUT;
   }
   /**
-   * Schedule a tasklet for execution.
-   * Returns a promise that resolves when the tasklet completes.
+   * Register a pending write operation.
+   * Returns a promise that resolves when target Write Concern is achieved.
+   *
+   * @param opId - Operation ID
+   * @param writeConcern - Target Write Concern level
+   * @param timeout - Optional timeout in ms (defaults to config or 5000ms)
+   * @returns Promise that resolves with WriteResult
    */
-  schedule(tasklet) {
-    if (this.isShuttingDown) {
-      return Promise.reject(new Error("Scheduler is shutting down"));
+  registerPending(opId, writeConcern, timeout) {
+    if (writeConcern === WriteConcern.FIRE_AND_FORGET) {
+      return Promise.resolve({
+        success: true,
+        opId,
+        achievedLevel: WriteConcern.FIRE_AND_FORGET,
+        latencyMs: 0
+      });
     }
     return new Promise((resolve, reject) => {
-      const taskletId = `${tasklet.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-      if (this.activeTasklets.size >= this.config.maxConcurrent) {
-        reject(new Error(`Max concurrent tasklets (${this.config.maxConcurrent}) reached`));
-        return;
-      }
-      const state = {
-        tasklet,
+      const effectiveTimeout = timeout ?? this.defaultTimeout;
+      const timestamp = Date.now();
+      const pendingWrite = {
+        opId,
+        writeConcern,
+        timestamp,
+        timeout: effectiveTimeout,
         resolve,
         reject,
-        iterations: 0,
-        startTime: Date.now(),
-        lastProgressTime: Date.now()
+        achievedLevels: /* @__PURE__ */ new Set([WriteConcern.FIRE_AND_FORGET])
       };
-      this.activeTasklets.set(taskletId, state);
-      this.totalScheduled++;
-      if (!this.isRunning) {
-        this.startScheduler();
+      pendingWrite.timeoutHandle = setTimeout(() => {
+        this.handleTimeout(opId);
+      }, effectiveTimeout);
+      this.pending.set(opId, pendingWrite);
+      logger.debug(
+        { opId, writeConcern, timeout: effectiveTimeout },
+        "Registered pending write"
+      );
+      if (writeConcern === WriteConcern.MEMORY) {
+        this.notifyLevel(opId, WriteConcern.MEMORY);
       }
     });
   }
   /**
-   * Run a tasklet synchronously (blocking).
-   * Useful for small operations or when cooperative scheduling isn't needed.
+   * Notify that a Write Concern level has been achieved for an operation.
+   *
+   * @param opId - Operation ID
+   * @param level - Write Concern level that was achieved
    */
-  runSync(tasklet) {
-    let state;
-    let iterations = 0;
-    const startTime = Date.now();
-    do {
-      state = tasklet.call();
-      iterations++;
-    } while (state === "MADE_PROGRESS");
-    if (state === "NO_PROGRESS") {
-      throw new Error(`Tasklet ${tasklet.name} made no progress`);
+  notifyLevel(opId, level) {
+    const pending = this.pending.get(opId);
+    if (!pending) {
+      return;
     }
-    if (this.config.metricsEnabled) {
-      this.totalIterations += iterations;
-      this.totalExecutionTimeMs += Date.now() - startTime;
-      if (iterations === 1) {
-        this.singleIterationCompletions++;
-      }
+    pending.achievedLevels.add(level);
+    logger.debug(
+      { opId, level, target: pending.writeConcern },
+      "Write Concern level achieved"
+    );
+    if (isWriteConcernAchieved(pending.achievedLevels, pending.writeConcern)) {
+      this.resolvePending(opId, level);
     }
-    return tasklet.getResult();
   }
   /**
-   * Cancel a specific tasklet by name pattern.
-   * Returns the number of tasklets cancelled.
+   * Notify multiple operations that a Write Concern level has been achieved.
+   * Useful for batch operations.
+   *
+   * @param opIds - Array of operation IDs
+   * @param level - Write Concern level that was achieved
    */
-  cancel(namePattern) {
-    let cancelled = 0;
-    const pattern = typeof namePattern === "string" ? new RegExp(`^${namePattern}`) : namePattern;
-    for (const [id, state] of this.activeTasklets) {
-      if (pattern.test(state.tasklet.name)) {
-        this.cancelTasklet(id, state);
-        cancelled++;
-      }
+  notifyLevelBatch(opIds, level) {
+    for (const opId of opIds) {
+      this.notifyLevel(opId, level);
     }
-    return cancelled;
   }
   /**
-   * Cancel all running tasklets.
+   * Check if an operation is still pending.
+   *
+   * @param opId - Operation ID
+   * @returns true if operation is pending
    */
-  cancelAll() {
-    let cancelled = 0;
-    for (const [id, state] of this.activeTasklets) {
-      this.cancelTasklet(id, state);
-      cancelled++;
+  isPending(opId) {
+    return this.pending.has(opId);
+  }
+  /**
+   * Get the target Write Concern level for a pending operation.
+   *
+   * @param opId - Operation ID
+   * @returns Target Write Concern level or undefined if not pending
+   */
+  getTargetLevel(opId) {
+    return this.pending.get(opId)?.writeConcern;
+  }
+  /**
+   * Get the highest achieved level for a pending operation.
+   *
+   * @param opId - Operation ID
+   * @returns Highest achieved level or undefined if not pending
+   */
+  getAchievedLevel(opId) {
+    const pending = this.pending.get(opId);
+    if (!pending) return void 0;
+    return getHighestWriteConcernLevel(pending.achievedLevels);
+  }
+  /**
+   * Resolve a pending write with success.
+   */
+  resolvePending(opId, achievedLevel) {
+    const pending = this.pending.get(opId);
+    if (!pending) return;
+    if (pending.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
     }
-    return cancelled;
+    const latencyMs = Date.now() - pending.timestamp;
+    const result = {
+      success: true,
+      opId,
+      achievedLevel,
+      latencyMs
+    };
+    pending.resolve(result);
+    this.pending.delete(opId);
+    logger.debug(
+      { opId, achievedLevel, latencyMs },
+      "Write resolved successfully"
+    );
+    this.emit("resolved", result);
   }
   /**
-   * Get scheduler statistics.
+   * Handle timeout for a pending write.
    */
-  getStats() {
-    return {
-      totalScheduled: this.totalScheduled,
-      activeTasklets: this.activeTasklets.size,
-      completedTasklets: this.completedTasklets,
-      cancelledTasklets: this.cancelledTasklets,
-      totalIterations: this.totalIterations,
-      avgIterationsPerTasklet: this.completedTasklets > 0 ? this.totalIterations / this.completedTasklets : 0,
-      singleIterationCompletions: this.singleIterationCompletions,
-      totalExecutionTimeMs: this.totalExecutionTimeMs
+  handleTimeout(opId) {
+    const pending = this.pending.get(opId);
+    if (!pending) return;
+    const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
+    const latencyMs = Date.now() - pending.timestamp;
+    const result = {
+      success: false,
+      opId,
+      achievedLevel: highestAchieved,
+      latencyMs,
+      error: `Timeout: achieved ${highestAchieved}, requested ${pending.writeConcern}`
     };
+    pending.resolve(result);
+    this.pending.delete(opId);
+    logger.warn(
+      { opId, requested: pending.writeConcern, achieved: highestAchieved, latencyMs },
+      "Write timed out"
+    );
+    this.emit("timeout", {
+      opId,
+      requested: pending.writeConcern,
+      achieved: highestAchieved,
+      latencyMs
+    });
   }
   /**
-   * Reset statistics.
+   * Fail a pending write with an error.
+   *
+   * @param opId - Operation ID
+   * @param error - Error message
    */
-  resetStats() {
-    this.totalScheduled = 0;
-    this.completedTasklets = 0;
-    this.cancelledTasklets = 0;
-    this.totalIterations = 0;
-    this.singleIterationCompletions = 0;
-    this.totalExecutionTimeMs = 0;
+  failPending(opId, error) {
+    const pending = this.pending.get(opId);
+    if (!pending) return;
+    if (pending.timeoutHandle) {
+      clearTimeout(pending.timeoutHandle);
+    }
+    const latencyMs = Date.now() - pending.timestamp;
+    const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
+    const result = {
+      success: false,
+      opId,
+      achievedLevel: highestAchieved,
+      latencyMs,
+      error
+    };
+    pending.resolve(result);
+    this.pending.delete(opId);
+    logger.error({ opId, error, latencyMs }, "Write failed");
+    this.emit("failed", result);
   }
   /**
-   * Shutdown the scheduler.
-   * Cancels all running tasklets and stops the tick timer.
+   * Get pending writes statistics.
    */
-  shutdown() {
-    this.isShuttingDown = true;
-    this.cancelAll();
-    this.stopScheduler();
+  getStats() {
+    const byLevel = {
+      [WriteConcern.FIRE_AND_FORGET]: 0,
+      [WriteConcern.MEMORY]: 0,
+      [WriteConcern.APPLIED]: 0,
+      [WriteConcern.REPLICATED]: 0,
+      [WriteConcern.PERSISTED]: 0
+    };
+    for (const pending of this.pending.values()) {
+      byLevel[pending.writeConcern]++;
+    }
+    return { pending: this.pending.size, byLevel };
   }
   /**
-   * Check if scheduler is running.
+   * Get all pending operation IDs.
    */
-  get running() {
-    return this.isRunning;
+  getPendingIds() {
+    return Array.from(this.pending.keys());
   }
   /**
-   * Get number of active tasklets.
+   * Clear all pending writes (for shutdown).
+   * Rejects all pending promises with an error.
    */
-  get activeCount() {
-    return this.activeTasklets.size;
-  }
-  startScheduler() {
-    if (this.isRunning) return;
-    this.isRunning = true;
-    this.scheduleTick();
-  }
-  stopScheduler() {
-    this.isRunning = false;
-    if (this.tickTimer) {
-      clearImmediate(this.tickTimer);
-      this.tickTimer = null;
-    }
-  }
-  scheduleTick() {
-    if (!this.isRunning) return;
-    this.tickTimer = setImmediate(() => {
-      this.tick();
-    });
-  }
-  tick() {
-    if (!this.isRunning || this.activeTasklets.size === 0) {
-      this.stopScheduler();
-      return;
-    }
-    const tickStart = Date.now();
-    const taskletIds = Array.from(this.activeTasklets.keys());
-    for (const id of taskletIds) {
-      const state = this.activeTasklets.get(id);
-      if (!state) continue;
-      try {
-        const iterationStart = Date.now();
-        const result = state.tasklet.call();
-        const iterationTime = Date.now() - iterationStart;
-        state.iterations++;
-        state.lastProgressTime = Date.now();
-        if (this.config.metricsEnabled) {
-          this.totalIterations++;
-          this.totalExecutionTimeMs += iterationTime;
-        }
-        if (result === "DONE") {
-          this.completeTasklet(id, state);
-        } else if (result === "NO_PROGRESS") {
-        }
-      } catch (error) {
-        this.failTasklet(id, state, error);
-      }
-      if (Date.now() - tickStart > this.config.defaultTimeBudgetMs * 2) {
-        break;
+  clear() {
+    const count = this.pending.size;
+    for (const pending of this.pending.values()) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
       }
+      pending.reject(new Error("WriteAckManager cleared"));
     }
-    if (this.activeTasklets.size > 0) {
-      this.scheduleTick();
-    } else {
-      this.stopScheduler();
-    }
-  }
-  completeTasklet(id, state) {
-    this.activeTasklets.delete(id);
-    this.completedTasklets++;
-    if (state.iterations === 1) {
-      this.singleIterationCompletions++;
-    }
-    try {
-      const result = state.tasklet.getResult();
-      state.resolve(result);
-    } catch (error) {
-      state.reject(error);
+    this.pending.clear();
+    if (count > 0) {
+      logger.info({ count }, "WriteAckManager cleared");
     }
   }
-  failTasklet(id, state, error) {
-    this.activeTasklets.delete(id);
-    state.reject(error);
-  }
-  cancelTasklet(id, state) {
-    this.activeTasklets.delete(id);
-    this.cancelledTasklets++;
-    if (state.tasklet.onCancel) {
-      try {
-        state.tasklet.onCancel();
-      } catch {
+  /**
+   * Graceful shutdown - resolves all pending writes with their current achieved level.
+   */
+  shutdown() {
+    const count = this.pending.size;
+    for (const [opId, pending] of this.pending.entries()) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
       }
+      const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
+      const latencyMs = Date.now() - pending.timestamp;
+      const result = {
+        success: highestAchieved === pending.writeConcern,
+        opId,
+        achievedLevel: highestAchieved,
+        latencyMs,
+        error: highestAchieved !== pending.writeConcern ? `Shutdown: achieved ${highestAchieved}, requested ${pending.writeConcern}` : void 0
+      };
+      pending.resolve(result);
+    }
+    this.pending.clear();
+    if (count > 0) {
+      logger.info({ count }, "WriteAckManager shutdown");
     }
-    state.reject(new Error(`Tasklet ${state.tasklet.name} was cancelled`));
   }
 };
 
-// src/tasklet/tasklets/IteratorTasklet.ts
-var DEFAULT_CONFIG5 = {
-  timeBudgetMs: 5,
-  maxItemsPerIteration: 1e3
+// src/cluster/ReplicationPipeline.ts
+import { EventEmitter as EventEmitter8 } from "events";
+import {
+  ConsistencyLevel,
+  DEFAULT_REPLICATION_CONFIG
+} from "@topgunbuild/core";
+
+// src/cluster/LagTracker.ts
+var DEFAULT_LAG_TRACKER_CONFIG = {
+  historySize: 100,
+  laggyThresholdMs: 5e3,
+  unhealthyThresholdMs: 3e4
 };
-var IteratorTasklet = class {
-  constructor(iterator, config) {
-    this.itemsProcessed = 0;
-    this.isDone = false;
-    this.iterator = iterator;
-    this.config = { ...DEFAULT_CONFIG5, ...config };
+var LagTracker = class {
+  constructor(config = {}) {
+    this.lagByNode = /* @__PURE__ */ new Map();
+    this.config = {
+      ...DEFAULT_LAG_TRACKER_CONFIG,
+      ...config
+    };
   }
   /**
-   * Execute one chunk of iteration.
+   * Update lag measurement for a node
    */
-  call() {
-    if (this.isDone) {
-      return "DONE";
+  update(nodeId, lagMs) {
+    let info = this.lagByNode.get(nodeId);
+    if (!info) {
+      info = {
+        current: 0,
+        history: [],
+        lastUpdate: Date.now(),
+        pendingOps: 0
+      };
+      this.lagByNode.set(nodeId, info);
     }
-    const deadline = Date.now() + this.config.timeBudgetMs;
-    let processedThisIteration = 0;
-    while (Date.now() < deadline && processedThisIteration < this.config.maxItemsPerIteration) {
-      const { value, done } = this.iterator.next();
-      if (done) {
-        this.isDone = true;
-        return "DONE";
-      }
-      this.processItem(value);
-      this.itemsProcessed++;
-      processedThisIteration++;
+    info.current = lagMs;
+    info.history.push(lagMs);
+    if (info.history.length > this.config.historySize) {
+      info.history.shift();
     }
-    return "MADE_PROGRESS";
+    info.lastUpdate = Date.now();
   }
   /**
-   * Called when tasklet is cancelled.
+   * Record acknowledgment from a node (lag effectively becomes 0)
    */
-  onCancel() {
+  recordAck(nodeId) {
+    const info = this.lagByNode.get(nodeId);
+    if (info) {
+      info.current = 0;
+      info.lastUpdate = Date.now();
+      if (info.pendingOps > 0) {
+        info.pendingOps--;
+      }
+    }
   }
   /**
-   * Get number of items processed so far.
+   * Increment pending operations counter for a node
    */
-  get processed() {
-    return this.itemsProcessed;
-  }
-};
-var FilterTasklet = class extends IteratorTasklet {
-  constructor(name, iterator, predicate, config) {
-    super(iterator, config);
-    this.results = [];
-    this.name = name;
-    this.predicate = predicate;
-  }
-  processItem(item) {
-    if (this.predicate(item)) {
-      this.results.push(item);
+  incrementPending(nodeId) {
+    let info = this.lagByNode.get(nodeId);
+    if (!info) {
+      info = {
+        current: 0,
+        history: [],
+        lastUpdate: Date.now(),
+        pendingOps: 0
+      };
+      this.lagByNode.set(nodeId, info);
     }
+    info.pendingOps++;
   }
-  getResult() {
-    return this.results;
+  /**
+   * Get lag statistics for a specific node
+   */
+  getLag(nodeId) {
+    const info = this.lagByNode.get(nodeId);
+    if (!info || info.history.length === 0) {
+      return { current: 0, avg: 0, max: 0, percentile99: 0 };
+    }
+    const sorted = [...info.history].sort((a, b) => a - b);
+    const avg = sorted.reduce((a, b) => a + b, 0) / sorted.length;
+    const max = sorted[sorted.length - 1] || 0;
+    const p99Index = Math.floor(sorted.length * 0.99);
+    const percentile99 = sorted[p99Index] || max;
+    return {
+      current: info.current,
+      avg: Math.round(avg * 100) / 100,
+      // Round to 2 decimal places
+      max,
+      percentile99
+    };
   }
-};
-var MapTasklet = class extends IteratorTasklet {
-  constructor(name, iterator, mapper, config) {
-    super(iterator, config);
-    this.results = [];
-    this.name = name;
-    this.mapper = mapper;
+  /**
+   * Get pending operations count for a node
+   */
+  getPendingOps(nodeId) {
+    const info = this.lagByNode.get(nodeId);
+    return info?.pendingOps ?? 0;
   }
-  processItem(item) {
-    this.results.push(this.mapper(item));
+  /**
+   * Get overall replication health status
+   */
+  getHealth() {
+    const unhealthyNodes = [];
+    const laggyNodes = [];
+    let totalLag = 0;
+    let nodeCount = 0;
+    const now = Date.now();
+    for (const [nodeId, info] of this.lagByNode) {
+      const timeSinceUpdate = now - info.lastUpdate;
+      if (timeSinceUpdate > this.config.unhealthyThresholdMs) {
+        unhealthyNodes.push(nodeId);
+      } else if (info.current > this.config.laggyThresholdMs) {
+        laggyNodes.push(nodeId);
+      }
+      totalLag += info.current;
+      nodeCount++;
+    }
+    const avgLagMs = nodeCount > 0 ? totalLag / nodeCount : 0;
+    return {
+      healthy: unhealthyNodes.length === 0,
+      unhealthyNodes,
+      laggyNodes,
+      avgLagMs: Math.round(avgLagMs * 100) / 100
+    };
   }
-  getResult() {
-    return this.results;
+  /**
+   * Get average lag across all tracked nodes
+   */
+  getAverageLag() {
+    let total = 0;
+    let count = 0;
+    for (const info of this.lagByNode.values()) {
+      total += info.current;
+      count++;
+    }
+    return count > 0 ? total / count : 0;
   }
-};
-var ForEachTasklet = class extends IteratorTasklet {
-  constructor(name, iterator, action, config) {
-    super(iterator, config);
-    this.name = name;
-    this.action = action;
+  /**
+   * Check if a specific node is considered healthy
+   */
+  isNodeHealthy(nodeId) {
+    const info = this.lagByNode.get(nodeId);
+    if (!info) return true;
+    const timeSinceUpdate = Date.now() - info.lastUpdate;
+    return timeSinceUpdate < this.config.unhealthyThresholdMs;
   }
-  processItem(item) {
-    this.action(item);
+  /**
+   * Check if a specific node is considered laggy
+   */
+  isNodeLaggy(nodeId) {
+    const info = this.lagByNode.get(nodeId);
+    if (!info) return false;
+    return info.current > this.config.laggyThresholdMs;
   }
-  getResult() {
-    return this.itemsProcessed;
+  /**
+   * Remove a node from tracking
+   */
+  removeNode(nodeId) {
+    this.lagByNode.delete(nodeId);
   }
-};
-var ReduceTasklet = class extends IteratorTasklet {
-  constructor(name, iterator, initialValue, reducer, config) {
-    super(iterator, config);
-    this.name = name;
-    this.accumulator = initialValue;
-    this.reducer = reducer;
+  /**
+   * Get all tracked node IDs
+   */
+  getTrackedNodes() {
+    return Array.from(this.lagByNode.keys());
   }
-  processItem(item) {
-    this.accumulator = this.reducer(this.accumulator, item);
+  /**
+   * Get raw lag info for a node (for advanced monitoring)
+   */
+  getRawLagInfo(nodeId) {
+    return this.lagByNode.get(nodeId);
   }
-  getResult() {
-    return this.accumulator;
+  /**
+   * Clear all tracking data
+   */
+  clear() {
+    this.lagByNode.clear();
+  }
+  /**
+   * Export metrics in Prometheus format
+   */
+  toPrometheusMetrics() {
+    const lines = [
+      "# HELP topgun_replication_lag_ms Current replication lag in milliseconds",
+      "# TYPE topgun_replication_lag_ms gauge"
+    ];
+    for (const [nodeId, info] of this.lagByNode) {
+      lines.push(`topgun_replication_lag_ms{node="${nodeId}"} ${info.current}`);
+    }
+    lines.push("");
+    lines.push("# HELP topgun_replication_pending_ops Pending replication operations");
+    lines.push("# TYPE topgun_replication_pending_ops gauge");
+    for (const [nodeId, info] of this.lagByNode) {
+      lines.push(`topgun_replication_pending_ops{node="${nodeId}"} ${info.pendingOps}`);
+    }
+    const health = this.getHealth();
+    lines.push("");
+    lines.push("# HELP topgun_replication_healthy Cluster replication health (1=healthy, 0=unhealthy)");
+    lines.push("# TYPE topgun_replication_healthy gauge");
+    lines.push(`topgun_replication_healthy ${health.healthy ? 1 : 0}`);
+    lines.push("");
+    lines.push("# HELP topgun_replication_avg_lag_ms Average replication lag across all nodes");
+    lines.push("# TYPE topgun_replication_avg_lag_ms gauge");
+    lines.push(`topgun_replication_avg_lag_ms ${health.avgLagMs}`);
+    return lines.join("\n");
   }
 };
 
-// src/ack/WriteAckManager.ts
-import { EventEmitter as EventEmitter4 } from "events";
-import {
-  WriteConcern,
-  DEFAULT_WRITE_CONCERN_TIMEOUT,
-  isWriteConcernAchieved,
-  getHighestWriteConcernLevel
-} from "@topgunbuild/core";
-var WriteAckManager = class extends EventEmitter4 {
-  constructor(config) {
+// src/cluster/ReplicationPipeline.ts
+var ReplicationTimeoutError = class extends Error {
+  constructor(opId, targetNodes, ackedNodes) {
+    super(
+      `Replication timeout for operation ${opId}. Expected: ${targetNodes.join(", ")}, Acked: ${ackedNodes.join(", ")}`
+    );
+    this.opId = opId;
+    this.targetNodes = targetNodes;
+    this.ackedNodes = ackedNodes;
+    this.name = "ReplicationTimeoutError";
+  }
+};
+var ReplicationPipeline = class extends EventEmitter8 {
+  constructor(clusterManager, partitionService, config = {}) {
     super();
-    this.pending = /* @__PURE__ */ new Map();
-    this.defaultTimeout = config?.defaultTimeout ?? DEFAULT_WRITE_CONCERN_TIMEOUT;
+    // Replication queues per node (for EVENTUAL mode)
+    this.replicationQueue = /* @__PURE__ */ new Map();
+    // Pending acknowledgments (for STRONG/QUORUM mode)
+    this.pendingAcks = /* @__PURE__ */ new Map();
+    // Queue processor timer
+    this.queueProcessorTimer = null;
+    // Operation applier callback (injected by ServerCoordinator)
+    this.operationApplier = null;
+    this.clusterManager = clusterManager;
+    this.partitionService = partitionService;
+    this.nodeId = clusterManager.config.nodeId;
+    this.config = {
+      ...DEFAULT_REPLICATION_CONFIG,
+      ...config
+    };
+    this.lagTracker = new LagTracker();
+    this.setupMessageHandlers();
+    this.startQueueProcessor();
   }
+  // ============================================
+  // Configuration
+  // ============================================
   /**
-   * Register a pending write operation.
-   * Returns a promise that resolves when target Write Concern is achieved.
-   *
-   * @param opId - Operation ID
-   * @param writeConcern - Target Write Concern level
-   * @param timeout - Optional timeout in ms (defaults to config or 5000ms)
-   * @returns Promise that resolves with WriteResult
+   * Set the operation applier callback
+   * This is called when replicated operations are received from other nodes
    */
-  registerPending(opId, writeConcern, timeout) {
-    if (writeConcern === WriteConcern.FIRE_AND_FORGET) {
-      return Promise.resolve({
-        success: true,
-        opId,
-        achievedLevel: WriteConcern.FIRE_AND_FORGET,
-        latencyMs: 0
-      });
+  setOperationApplier(applier) {
+    this.operationApplier = applier;
+  }
+  // ============================================
+  // Replication API
+  // ============================================
+  /**
+   * Replicate operation to backup nodes
+   */
+  async replicate(operation, opId, key, options = {}) {
+    const consistency = options.consistency ?? this.config.defaultConsistency;
+    const partitionId = this.partitionService.getPartitionId(key);
+    const backups = this.partitionService.getBackups(partitionId);
+    if (backups.length === 0) {
+      return { success: true, ackedBy: [this.nodeId] };
+    }
+    switch (consistency) {
+      case ConsistencyLevel.STRONG:
+        return this.replicateStrong(operation, opId, backups, options.timeout);
+      case ConsistencyLevel.QUORUM:
+        return this.replicateQuorum(operation, opId, backups, options.timeout);
+      case ConsistencyLevel.EVENTUAL:
+        return this.replicateEventual(operation, opId, backups);
     }
+  }
+  /**
+   * STRONG: Wait for all replicas to acknowledge
+   */
+  async replicateStrong(operation, opId, backups, timeout) {
+    const targetNodes = backups;
     return new Promise((resolve, reject) => {
-      const effectiveTimeout = timeout ?? this.defaultTimeout;
-      const timestamp = Date.now();
-      const pendingWrite = {
+      const pending = {
         opId,
-        writeConcern,
-        timestamp,
-        timeout: effectiveTimeout,
-        resolve,
-        reject,
-        achievedLevels: /* @__PURE__ */ new Set([WriteConcern.FIRE_AND_FORGET])
+        consistency: ConsistencyLevel.STRONG,
+        targetNodes,
+        ackedNodes: /* @__PURE__ */ new Set(),
+        resolve: () => resolve({
+          success: true,
+          ackedBy: [this.nodeId, ...targetNodes]
+        }),
+        reject: (error) => reject(error),
+        timeout: setTimeout(() => {
+          this.pendingAcks.delete(opId);
+          const ackedList = Array.from(pending.ackedNodes);
+          reject(new ReplicationTimeoutError(opId, targetNodes, ackedList));
+        }, timeout ?? this.config.ackTimeoutMs),
+        startTime: Date.now()
       };
-      pendingWrite.timeoutHandle = setTimeout(() => {
-        this.handleTimeout(opId);
-      }, effectiveTimeout);
-      this.pending.set(opId, pendingWrite);
-      logger.debug(
-        { opId, writeConcern, timeout: effectiveTimeout },
-        "Registered pending write"
-      );
-      if (writeConcern === WriteConcern.MEMORY) {
-        this.notifyLevel(opId, WriteConcern.MEMORY);
+      this.pendingAcks.set(opId, pending);
+      for (const nodeId of targetNodes) {
+        this.lagTracker.incrementPending(nodeId);
+      }
+      for (const nodeId of targetNodes) {
+        this.sendReplication(nodeId, operation, opId, ConsistencyLevel.STRONG);
       }
     });
   }
   /**
-   * Notify that a Write Concern level has been achieved for an operation.
-   *
-   * @param opId - Operation ID
-   * @param level - Write Concern level that was achieved
+   * QUORUM: Wait for majority of replicas
    */
-  notifyLevel(opId, level) {
-    const pending = this.pending.get(opId);
-    if (!pending) {
-      return;
+  async replicateQuorum(operation, opId, backups, timeout) {
+    const targetNodes = backups;
+    const quorumSize = Math.floor(targetNodes.length / 2) + 1;
+    return new Promise((resolve, reject) => {
+      const ackedNodes = /* @__PURE__ */ new Set();
+      const pending = {
+        opId,
+        consistency: ConsistencyLevel.QUORUM,
+        targetNodes,
+        ackedNodes,
+        resolve: () => {
+          const ackedSnapshot = Array.from(ackedNodes);
+          const ackedBy = [this.nodeId, ...ackedSnapshot];
+          resolve({ success: true, ackedBy });
+        },
+        reject: (error) => reject(error),
+        timeout: setTimeout(() => {
+          this.pendingAcks.delete(opId);
+          const ackedList = Array.from(ackedNodes);
+          reject(new ReplicationTimeoutError(opId, targetNodes, ackedList));
+        }, timeout ?? this.config.ackTimeoutMs),
+        startTime: Date.now()
+      };
+      this.pendingAcks.set(opId, pending);
+      for (const nodeId of targetNodes) {
+        this.lagTracker.incrementPending(nodeId);
+      }
+      for (const nodeId of targetNodes) {
+        this.sendReplication(nodeId, operation, opId, ConsistencyLevel.QUORUM);
+      }
+    });
+  }
+  /**
+   * EVENTUAL: Fire-and-forget with queue
+   */
+  async replicateEventual(operation, opId, backups) {
+    for (const nodeId of backups) {
+      this.enqueue(nodeId, {
+        opId,
+        operation,
+        consistency: ConsistencyLevel.EVENTUAL,
+        timestamp: Date.now(),
+        retryCount: 0
+      });
     }
-    pending.achievedLevels.add(level);
-    logger.debug(
-      { opId, level, target: pending.writeConcern },
-      "Write Concern level achieved"
-    );
-    if (isWriteConcernAchieved(pending.achievedLevels, pending.writeConcern)) {
-      this.resolvePending(opId, level);
+    return { success: true, ackedBy: [this.nodeId] };
+  }
+  // ============================================
+  // Queue Management
+  // ============================================
+  /**
+   * Add task to replication queue
+   */
+  enqueue(nodeId, task) {
+    let queue = this.replicationQueue.get(nodeId);
+    if (!queue) {
+      queue = [];
+      this.replicationQueue.set(nodeId, queue);
     }
+    if (queue.length >= this.config.queueSizeLimit) {
+      this.emit("queueOverflow", nodeId);
+      logger.warn({ nodeId, queueSize: queue.length }, "Replication queue overflow, dropping oldest");
+      queue.shift();
+    }
+    queue.push(task);
+    this.lagTracker.incrementPending(nodeId);
   }
   /**
-   * Notify multiple operations that a Write Concern level has been achieved.
-   * Useful for batch operations.
-   *
-   * @param opIds - Array of operation IDs
-   * @param level - Write Concern level that was achieved
+   * Start queue processor
    */
-  notifyLevelBatch(opIds, level) {
-    for (const opId of opIds) {
-      this.notifyLevel(opId, level);
+  startQueueProcessor() {
+    if (this.queueProcessorTimer) return;
+    this.queueProcessorTimer = setInterval(() => {
+      for (const nodeId of this.replicationQueue.keys()) {
+        this.processQueue(nodeId).catch((err) => {
+          logger.error({ nodeId, error: err }, "Error processing replication queue");
+          this.emit("error", err);
+        });
+      }
+    }, this.config.batchIntervalMs);
+  }
+  /**
+   * Stop queue processor
+   */
+  stopQueueProcessor() {
+    if (this.queueProcessorTimer) {
+      clearInterval(this.queueProcessorTimer);
+      this.queueProcessorTimer = null;
     }
   }
   /**
-   * Check if an operation is still pending.
-   *
-   * @param opId - Operation ID
-   * @returns true if operation is pending
+   * Process replication queue for a node
    */
-  isPending(opId) {
-    return this.pending.has(opId);
+  async processQueue(nodeId) {
+    const queue = this.replicationQueue.get(nodeId);
+    if (!queue || queue.length === 0) return;
+    const batch = queue.splice(0, this.config.batchSize);
+    try {
+      this.clusterManager.send(nodeId, "OP_FORWARD", {
+        _replication: {
+          type: "REPLICATION_BATCH",
+          payload: {
+            operations: batch.map((t) => t.operation),
+            opIds: batch.map((t) => t.opId)
+          }
+        }
+      });
+      const oldestTimestamp = Math.min(...batch.map((t) => t.timestamp));
+      this.lagTracker.update(nodeId, Date.now() - oldestTimestamp);
+      logger.debug({ nodeId, batchSize: batch.length }, "Sent replication batch");
+    } catch (error) {
+      for (const task of batch) {
+        task.retryCount++;
+        if (task.retryCount <= this.config.maxRetries) {
+          queue.unshift(task);
+        } else {
+          logger.warn({ nodeId, opId: task.opId, retries: task.retryCount }, "Replication task exceeded max retries");
+          this.emit("replicationFailed", task.opId, new Error("Max retries exceeded"));
+        }
+      }
+    }
   }
+  // ============================================
+  // Message Handling
+  // ============================================
   /**
-   * Get the target Write Concern level for a pending operation.
-   *
-   * @param opId - Operation ID
-   * @returns Target Write Concern level or undefined if not pending
+   * Send replication message to a node
    */
-  getTargetLevel(opId) {
-    return this.pending.get(opId)?.writeConcern;
+  sendReplication(nodeId, operation, opId, consistency) {
+    this.clusterManager.send(nodeId, "OP_FORWARD", {
+      _replication: {
+        type: "REPLICATION",
+        payload: {
+          opId,
+          operation,
+          consistency
+        }
+      }
+    });
   }
   /**
-   * Get the highest achieved level for a pending operation.
-   *
-   * @param opId - Operation ID
-   * @returns Highest achieved level or undefined if not pending
+   * Setup cluster message handlers
    */
-  getAchievedLevel(opId) {
-    const pending = this.pending.get(opId);
-    if (!pending) return void 0;
-    return getHighestWriteConcernLevel(pending.achievedLevels);
+  setupMessageHandlers() {
+    this.clusterManager.on("message", (msg) => {
+      if (msg.payload?._replication) {
+        const replication = msg.payload._replication;
+        switch (replication.type) {
+          case "REPLICATION":
+            this.handleReplication(msg.senderId, replication.payload);
+            break;
+          case "REPLICATION_BATCH":
+            this.handleReplicationBatch(msg.senderId, replication.payload);
+            break;
+          case "REPLICATION_ACK":
+            this.handleReplicationAck(msg.senderId, replication.payload);
+            break;
+          case "REPLICATION_BATCH_ACK":
+            this.handleReplicationBatchAck(msg.senderId, replication.payload);
+            break;
+        }
+      }
+    });
   }
   /**
-   * Resolve a pending write with success.
+   * Handle incoming replication request (on backup node)
    */
-  resolvePending(opId, achievedLevel) {
-    const pending = this.pending.get(opId);
-    if (!pending) return;
-    if (pending.timeoutHandle) {
-      clearTimeout(pending.timeoutHandle);
+  async handleReplication(sourceNode, payload) {
+    const { opId, operation, consistency } = payload;
+    logger.debug({ sourceNode, opId, consistency }, "Received replication");
+    let success = true;
+    if (this.operationApplier) {
+      try {
+        success = await this.operationApplier(operation, opId, sourceNode);
+      } catch (error) {
+        logger.error({ sourceNode, opId, error }, "Failed to apply replicated operation");
+        success = false;
+      }
+    } else {
+      logger.warn({ sourceNode, opId }, "No operation applier set, operation not applied");
+    }
+    if (consistency === ConsistencyLevel.STRONG || consistency === ConsistencyLevel.QUORUM) {
+      this.clusterManager.send(sourceNode, "OP_FORWARD", {
+        _replication: {
+          type: "REPLICATION_ACK",
+          payload: {
+            opId,
+            success,
+            timestamp: Date.now()
+          }
+        }
+      });
     }
-    const latencyMs = Date.now() - pending.timestamp;
-    const result = {
-      success: true,
-      opId,
-      achievedLevel,
-      latencyMs
-    };
-    pending.resolve(result);
-    this.pending.delete(opId);
-    logger.debug(
-      { opId, achievedLevel, latencyMs },
-      "Write resolved successfully"
-    );
-    this.emit("resolved", result);
   }
   /**
-   * Handle timeout for a pending write.
+   * Handle incoming batch replication (on backup node)
    */
-  handleTimeout(opId) {
-    const pending = this.pending.get(opId);
-    if (!pending) return;
-    const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
-    const latencyMs = Date.now() - pending.timestamp;
-    const result = {
-      success: false,
-      opId,
-      achievedLevel: highestAchieved,
-      latencyMs,
-      error: `Timeout: achieved ${highestAchieved}, requested ${pending.writeConcern}`
-    };
-    pending.resolve(result);
-    this.pending.delete(opId);
-    logger.warn(
-      { opId, requested: pending.writeConcern, achieved: highestAchieved, latencyMs },
-      "Write timed out"
-    );
-    this.emit("timeout", {
-      opId,
-      requested: pending.writeConcern,
-      achieved: highestAchieved,
-      latencyMs
+  async handleReplicationBatch(sourceNode, payload) {
+    const { operations, opIds } = payload;
+    logger.debug({ sourceNode, count: operations.length }, "Received replication batch");
+    let allSuccess = true;
+    if (this.operationApplier) {
+      for (let i = 0; i < operations.length; i++) {
+        try {
+          const success = await this.operationApplier(operations[i], opIds[i], sourceNode);
+          if (!success) {
+            allSuccess = false;
+          }
+        } catch (error) {
+          logger.error({ sourceNode, opId: opIds[i], error }, "Failed to apply replicated operation in batch");
+          allSuccess = false;
+        }
+      }
+    } else {
+      logger.warn({ sourceNode, count: operations.length }, "No operation applier set, batch not applied");
+    }
+    this.clusterManager.send(sourceNode, "OP_FORWARD", {
+      _replication: {
+        type: "REPLICATION_BATCH_ACK",
+        payload: {
+          opIds,
+          success: allSuccess,
+          timestamp: Date.now()
+        }
+      }
     });
   }
   /**
-   * Fail a pending write with an error.
-   *
-   * @param opId - Operation ID
-   * @param error - Error message
+   * Handle replication acknowledgment (on owner node)
+   */
+  handleReplicationAck(sourceNode, payload) {
+    const { opId, success } = payload;
+    this.lagTracker.recordAck(sourceNode);
+    const pending = this.pendingAcks.get(opId);
+    if (!pending) return;
+    if (!success) {
+      logger.warn({ sourceNode, opId }, "Replication rejected by backup");
+      return;
+    }
+    pending.ackedNodes.add(sourceNode);
+    const lag = Date.now() - pending.startTime;
+    this.lagTracker.update(sourceNode, lag);
+    const ackedCount = pending.ackedNodes.size;
+    const targetCount = pending.targetNodes.length;
+    switch (pending.consistency) {
+      case ConsistencyLevel.STRONG:
+        if (ackedCount === targetCount) {
+          clearTimeout(pending.timeout);
+          this.pendingAcks.delete(opId);
+          pending.resolve();
+          this.emit("replicationComplete", opId, [this.nodeId, ...pending.ackedNodes]);
+        }
+        break;
+      case ConsistencyLevel.QUORUM:
+        const quorumSize = Math.floor(targetCount / 2) + 1;
+        if (ackedCount >= quorumSize) {
+          clearTimeout(pending.timeout);
+          this.pendingAcks.delete(opId);
+          pending.resolve();
+          this.emit("replicationComplete", opId, [this.nodeId, ...pending.ackedNodes]);
+        }
+        break;
+    }
+  }
+  /**
+   * Handle batch acknowledgment (on owner node)
+   */
+  handleReplicationBatchAck(sourceNode, payload) {
+    const { success } = payload;
+    this.lagTracker.recordAck(sourceNode);
+    if (!success) {
+      logger.warn({ sourceNode, count: payload.opIds.length }, "Batch replication rejected");
+    }
+  }
+  // ============================================
+  // Status and Metrics
+  // ============================================
+  /**
+   * Get replication lag for a specific node
    */
-  failPending(opId, error) {
-    const pending = this.pending.get(opId);
-    if (!pending) return;
-    if (pending.timeoutHandle) {
-      clearTimeout(pending.timeoutHandle);
-    }
-    const latencyMs = Date.now() - pending.timestamp;
-    const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
-    const result = {
-      success: false,
-      opId,
-      achievedLevel: highestAchieved,
-      latencyMs,
-      error
-    };
-    pending.resolve(result);
-    this.pending.delete(opId);
-    logger.error({ opId, error, latencyMs }, "Write failed");
-    this.emit("failed", result);
+  getLag(nodeId) {
+    return this.lagTracker.getLag(nodeId);
   }
   /**
-   * Get pending writes statistics.
+   * Get overall replication health
    */
-  getStats() {
-    const byLevel = {
-      [WriteConcern.FIRE_AND_FORGET]: 0,
-      [WriteConcern.MEMORY]: 0,
-      [WriteConcern.APPLIED]: 0,
-      [WriteConcern.REPLICATED]: 0,
-      [WriteConcern.PERSISTED]: 0
-    };
-    for (const pending of this.pending.values()) {
-      byLevel[pending.writeConcern]++;
-    }
-    return { pending: this.pending.size, byLevel };
+  getHealth() {
+    return this.lagTracker.getHealth();
   }
   /**
-   * Get all pending operation IDs.
+   * Get queue size for a specific node
    */
-  getPendingIds() {
-    return Array.from(this.pending.keys());
+  getQueueSize(nodeId) {
+    return this.replicationQueue.get(nodeId)?.length ?? 0;
   }
   /**
-   * Clear all pending writes (for shutdown).
-   * Rejects all pending promises with an error.
+   * Get total pending operations across all nodes
    */
-  clear() {
-    const count = this.pending.size;
-    for (const pending of this.pending.values()) {
-      if (pending.timeoutHandle) {
-        clearTimeout(pending.timeoutHandle);
-      }
-      pending.reject(new Error("WriteAckManager cleared"));
-    }
-    this.pending.clear();
-    if (count > 0) {
-      logger.info({ count }, "WriteAckManager cleared");
+  getTotalPending() {
+    let total = 0;
+    for (const queue of this.replicationQueue.values()) {
+      total += queue.length;
     }
+    return total + this.pendingAcks.size;
   }
   /**
-   * Graceful shutdown - resolves all pending writes with their current achieved level.
+   * Check if a node is considered synced (low lag)
    */
-  shutdown() {
-    const count = this.pending.size;
-    for (const [opId, pending] of this.pending.entries()) {
-      if (pending.timeoutHandle) {
-        clearTimeout(pending.timeoutHandle);
-      }
-      const highestAchieved = getHighestWriteConcernLevel(pending.achievedLevels);
-      const latencyMs = Date.now() - pending.timestamp;
-      const result = {
-        success: highestAchieved === pending.writeConcern,
-        opId,
-        achievedLevel: highestAchieved,
-        latencyMs,
-        error: highestAchieved !== pending.writeConcern ? `Shutdown: achieved ${highestAchieved}, requested ${pending.writeConcern}` : void 0
-      };
-      pending.resolve(result);
+  isSynced(nodeId, maxLagMs = 1e3) {
+    const lag = this.lagTracker.getLag(nodeId);
+    return lag.current < maxLagMs;
+  }
+  /**
+   * Get LagTracker for advanced monitoring
+   */
+  getLagTracker() {
+    return this.lagTracker;
+  }
+  /**
+   * Export metrics in Prometheus format
+   */
+  toPrometheusMetrics() {
+    const lines = [];
+    lines.push("# HELP topgun_replication_queue_size Pending operations in replication queue");
+    lines.push("# TYPE topgun_replication_queue_size gauge");
+    for (const [nodeId, queue] of this.replicationQueue) {
+      lines.push(`topgun_replication_queue_size{node="${nodeId}"} ${queue.length}`);
     }
-    this.pending.clear();
-    if (count > 0) {
-      logger.info({ count }, "WriteAckManager shutdown");
+    lines.push("");
+    lines.push("# HELP topgun_replication_pending_acks Pending synchronous acknowledgments");
+    lines.push("# TYPE topgun_replication_pending_acks gauge");
+    lines.push(`topgun_replication_pending_acks ${this.pendingAcks.size}`);
+    lines.push("");
+    lines.push(this.lagTracker.toPrometheusMetrics());
+    return lines.join("\n");
+  }
+  /**
+   * Cleanup resources
+   */
+  close() {
+    this.stopQueueProcessor();
+    for (const [opId, pending] of this.pendingAcks) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("ReplicationPipeline closed"));
     }
+    this.pendingAcks.clear();
+    this.replicationQueue.clear();
+    this.lagTracker.clear();
   }
 };
 
@@ -4741,6 +6573,22 @@ var ServerCoordinator = class {
         tls: config.clusterTls
       });
       this.partitionService = new PartitionService(this.cluster);
+      if (config.replicationEnabled !== false) {
+        this.replicationPipeline = new ReplicationPipeline(
+          this.cluster,
+          this.partitionService,
+          {
+            ...DEFAULT_REPLICATION_CONFIG2,
+            defaultConsistency: config.defaultConsistency ?? ConsistencyLevel2.EVENTUAL,
+            ...config.replicationConfig
+          }
+        );
+        this.replicationPipeline.setOperationApplier(this.applyReplicatedOperation.bind(this));
+        logger.info({ nodeId: config.nodeId }, "ReplicationPipeline initialized");
+      }
+      this.partitionService.on("rebalanced", (partitionMap, changes) => {
+        this.broadcastPartitionMap(partitionMap);
+      });
       this.lockManager = new LockManager();
       this.lockManager.on("lockGranted", (evt) => this.handleLockGranted(evt));
       this.topicManager = new TopicManager({
@@ -4857,7 +6705,7 @@ var ServerCoordinator = class {
     this.metricsService.destroy();
     this.wss.close();
     logger.info(`Closing ${this.clients.size} client connections...`);
-    const shutdownMsg = serialize3({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
+    const shutdownMsg = serialize4({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.clients.values()) {
       try {
         if (client.socket.readyState === WebSocket3.OPEN) {
@@ -4879,6 +6727,9 @@ var ServerCoordinator = class {
       await this.workerPool.shutdown(5e3);
       logger.info("Worker pool shutdown complete.");
     }
+    if (this.replicationPipeline) {
+      this.replicationPipeline.close();
+    }
     if (this.cluster) {
       this.cluster.stop();
     }
@@ -5026,7 +6877,7 @@ var ServerCoordinator = class {
       this.clients.delete(clientId);
       this.metricsService.setConnectedClients(this.clients.size);
     });
-    ws.send(serialize3({ type: "AUTH_REQUIRED" }));
+    ws.send(serialize4({ type: "AUTH_REQUIRED" }));
   }
   async handleMessage(client, rawMessage) {
     const parseResult = MessageSchema.safeParse(rawMessage);
@@ -5436,6 +7287,23 @@ var ServerCoordinator = class {
         }
         break;
       }
+      // ============ Phase 4: Partition Map Request Handler ============
+      case "PARTITION_MAP_REQUEST": {
+        const clientVersion = message.payload?.currentVersion ?? 0;
+        const currentMap = this.partitionService.getPartitionMap();
+        if (clientVersion < currentMap.version) {
+          client.writer.write({
+            type: "PARTITION_MAP",
+            payload: currentMap
+          });
+          logger.debug({
+            clientId: client.id,
+            clientVersion,
+            serverVersion: currentMap.version
+          }, "Sent partition map to client");
+        }
+        break;
+      }
       // ============ ORMap Sync Message Handlers ============
       case "ORMAP_SYNC_INIT": {
         if (!this.securityManager.checkPermission(client.principal, message.mapName, "READ")) {
@@ -5639,6 +7507,28 @@ var ServerCoordinator = class {
       client.lastActiveHlc = this.hlc.now();
     }
   }
+  // ============ Phase 4: Partition Map Broadcast ============
+  /**
+   * Broadcast partition map to all connected and authenticated clients.
+   * Called when partition topology changes (node join/leave/failover).
+   */
+  broadcastPartitionMap(partitionMap) {
+    const message = {
+      type: "PARTITION_MAP",
+      payload: partitionMap
+    };
+    let broadcastCount = 0;
+    for (const client of this.clients.values()) {
+      if (client.isAuthenticated && client.socket.readyState === WebSocket3.OPEN) {
+        client.writer.write(message);
+        broadcastCount++;
+      }
+    }
+    logger.info({
+      version: partitionMap.version,
+      clientCount: broadcastCount
+    }, "Broadcast partition map to clients");
+  }
   broadcast(message, excludeClientId) {
     const isServerEvent = message.type === "SERVER_EVENT";
     if (isServerEvent) {
@@ -5669,7 +7559,7 @@ var ServerCoordinator = class {
         client.writer.write({ ...message, payload: newPayload });
       }
     } else {
-      const msgData = serialize3(message);
+      const msgData = serialize4(message);
       for (const [id, client] of this.clients) {
         if (id !== excludeClientId && client.socket.readyState === 1) {
           client.writer.writeRaw(msgData);
@@ -5747,7 +7637,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = serialize3(batchMessage);
+      const serializedBatch = serialize4(batchMessage);
       for (const client of clients) {
         try {
           client.writer.writeRaw(serializedBatch);
@@ -5832,7 +7722,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = serialize3(batchMessage);
+      const serializedBatch = serialize4(batchMessage);
       for (const client of clients) {
         sendPromises.push(new Promise((resolve, reject) => {
           try {
@@ -6117,6 +8007,26 @@ var ServerCoordinator = class {
       }
     }
   }
+  /**
+   * Apply replicated operation from another node (callback for ReplicationPipeline)
+   * This is called when we receive a replicated operation as a backup node
+   */
+  async applyReplicatedOperation(operation, opId, sourceNode) {
+    try {
+      const op = operation;
+      logger.debug({ sourceNode, opId, mapName: op.mapName, key: op.key }, "Applying replicated operation");
+      const { eventPayload } = this.applyOpToMap(op);
+      this.broadcast({
+        type: "SERVER_EVENT",
+        payload: eventPayload,
+        timestamp: this.hlc.now()
+      });
+      return true;
+    } catch (error) {
+      logger.error({ sourceNode, opId, error }, "Failed to apply replicated operation");
+      return false;
+    }
+  }
   /**
    * Build OpContext for interceptors.
    */
@@ -6205,6 +8115,12 @@ var ServerCoordinator = class {
       throw err;
     }
     const { eventPayload } = this.applyOpToMap(op);
+    if (this.replicationPipeline && !fromCluster) {
+      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)");
+      });
+    }
     this.broadcast({
       type: "SERVER_EVENT",
       payload: eventPayload,
@@ -6327,6 +8243,12 @@ var ServerCoordinator = class {
       throw err;
     }
     const { eventPayload } = this.applyOpToMap(op);
+    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 }, "Batch replication failed (non-fatal)");
+      });
+    }
     batchedEvents.push(eventPayload);
     this.broadcastToCluster(eventPayload);
     this.runAfterInterceptors(op, context);
@@ -7274,18 +9196,403 @@ function logNativeStatus() {
     `  - SharedArrayBuffer: ${status.sharedArrayBuffer ? "available" : "unavailable"}`
   );
 }
+
+// src/cluster/ClusterCoordinator.ts
+import { EventEmitter as EventEmitter9 } from "events";
+import {
+  DEFAULT_MIGRATION_CONFIG as DEFAULT_MIGRATION_CONFIG3,
+  DEFAULT_REPLICATION_CONFIG as DEFAULT_REPLICATION_CONFIG3
+} from "@topgunbuild/core";
+var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
+  gradualRebalancing: true,
+  migration: DEFAULT_MIGRATION_CONFIG3,
+  replication: DEFAULT_REPLICATION_CONFIG3,
+  replicationEnabled: true
+};
+var ClusterCoordinator = class extends EventEmitter9 {
+  constructor(config) {
+    super();
+    this.replicationPipeline = null;
+    // State
+    this.started = false;
+    this.actualPort = 0;
+    this.config = {
+      ...DEFAULT_CLUSTER_COORDINATOR_CONFIG,
+      ...config
+    };
+    this.clusterManager = new ClusterManager(this.config.cluster);
+    this.lagTracker = new LagTracker();
+    const partitionServiceConfig = {
+      gradualRebalancing: this.config.gradualRebalancing,
+      migration: this.config.migration
+    };
+    this.partitionService = new PartitionService(this.clusterManager, partitionServiceConfig);
+    if (this.config.replicationEnabled) {
+      this.replicationPipeline = new ReplicationPipeline(
+        this.clusterManager,
+        this.partitionService,
+        this.config.replication
+      );
+    }
+    this.setupEventHandlers();
+  }
+  // ============================================
+  // Lifecycle Methods
+  // ============================================
+  /**
+   * Start the cluster coordinator
+   */
+  async start() {
+    if (this.started) {
+      return this.actualPort;
+    }
+    logger.info({ nodeId: this.config.cluster.nodeId }, "Starting ClusterCoordinator");
+    this.actualPort = await this.clusterManager.start();
+    const migrationManager = this.partitionService.getMigrationManager();
+    if (migrationManager && this.config.dataCollector) {
+      migrationManager.setDataCollector(this.config.dataCollector);
+    }
+    if (migrationManager && this.config.dataStorer) {
+      migrationManager.setDataStorer(this.config.dataStorer);
+    }
+    this.started = true;
+    this.emit("started");
+    logger.info({ nodeId: this.config.cluster.nodeId, port: this.actualPort }, "ClusterCoordinator started");
+    return this.actualPort;
+  }
+  /**
+   * Stop the cluster coordinator
+   */
+  async stop() {
+    if (!this.started) return;
+    logger.info({ nodeId: this.config.cluster.nodeId }, "Stopping ClusterCoordinator");
+    await this.partitionService.cancelMigrations();
+    this.replicationPipeline?.close();
+    this.clusterManager.stop();
+    this.started = false;
+    this.emit("stopped");
+    logger.info({ nodeId: this.config.cluster.nodeId }, "ClusterCoordinator stopped");
+  }
+  // ============================================
+  // Cluster Information
+  // ============================================
+  /**
+   * Get local node ID
+   */
+  getNodeId() {
+    return this.config.cluster.nodeId;
+  }
+  /**
+   * Get cluster port
+   */
+  getPort() {
+    return this.actualPort;
+  }
+  /**
+   * Get all cluster members
+   */
+  getMembers() {
+    return this.clusterManager.getMembers();
+  }
+  /**
+   * Check if this is the local node
+   */
+  isLocal(nodeId) {
+    return this.clusterManager.isLocal(nodeId);
+  }
+  /**
+   * Check if coordinator is started
+   */
+  isStarted() {
+    return this.started;
+  }
+  // ============================================
+  // Partition Operations
+  // ============================================
+  /**
+   * Get current partition map
+   */
+  getPartitionMap() {
+    return this.partitionService.getPartitionMap();
+  }
+  /**
+   * Get partition map version
+   */
+  getPartitionMapVersion() {
+    return this.partitionService.getMapVersion();
+  }
+  /**
+   * Get partition ID for a key
+   */
+  getPartitionId(key) {
+    return this.partitionService.getPartitionId(key);
+  }
+  /**
+   * Get owner node for a key
+   */
+  getOwner(key) {
+    return this.partitionService.getOwner(key);
+  }
+  /**
+   * Check if this node owns the key
+   */
+  isLocalOwner(key) {
+    return this.partitionService.isLocalOwner(key);
+  }
+  /**
+   * Check if this node is a backup for the key
+   */
+  isLocalBackup(key) {
+    return this.partitionService.isLocalBackup(key);
+  }
+  /**
+   * Get backup nodes for a partition
+   */
+  getBackups(partitionId) {
+    return this.partitionService.getBackups(partitionId);
+  }
+  /**
+   * Check if partition is currently migrating
+   */
+  isMigrating(partitionId) {
+    return this.partitionService.isMigrating(partitionId);
+  }
+  /**
+   * Check if any rebalancing is in progress
+   */
+  isRebalancing() {
+    return this.partitionService.isRebalancing();
+  }
+  // ============================================
+  // Migration Operations
+  // ============================================
+  /**
+   * Get migration status
+   */
+  getMigrationStatus() {
+    return this.partitionService.getMigrationStatus();
+  }
+  /**
+   * Get migration metrics
+   */
+  getMigrationMetrics() {
+    return this.partitionService.getMigrationManager()?.getMetrics() ?? null;
+  }
+  /**
+   * Cancel all active migrations
+   */
+  async cancelMigrations() {
+    await this.partitionService.cancelMigrations();
+  }
+  /**
+   * Set data collector for migrations
+   */
+  setDataCollector(collector) {
+    const migrationManager = this.partitionService.getMigrationManager();
+    if (migrationManager) {
+      migrationManager.setDataCollector(collector);
+    }
+  }
+  /**
+   * Set data storer for incoming migrations
+   */
+  setDataStorer(storer) {
+    const migrationManager = this.partitionService.getMigrationManager();
+    if (migrationManager) {
+      migrationManager.setDataStorer(storer);
+    }
+  }
+  // ============================================
+  // Replication Operations
+  // ============================================
+  /**
+   * Replicate an operation to backup nodes
+   */
+  async replicate(operation, opId, key, options = {}) {
+    if (!this.replicationPipeline) {
+      return { success: true, ackedBy: [] };
+    }
+    return this.replicationPipeline.replicate(operation, opId, key, options);
+  }
+  /**
+   * Get replication health status
+   */
+  getReplicationHealth() {
+    return this.lagTracker.getHealth();
+  }
+  /**
+   * Get replication lag for a specific node
+   */
+  getReplicationLag(nodeId) {
+    return this.lagTracker.getLag(nodeId);
+  }
+  /**
+   * Check if a node is healthy for replication
+   */
+  isNodeHealthy(nodeId) {
+    return this.lagTracker.isNodeHealthy(nodeId);
+  }
+  /**
+   * Check if a node is laggy
+   */
+  isNodeLaggy(nodeId) {
+    return this.lagTracker.isNodeLaggy(nodeId);
+  }
+  // ============================================
+  // Cluster Communication
+  // ============================================
+  /**
+   * Send message to a specific node
+   */
+  send(nodeId, message) {
+    this.clusterManager.sendToNode(nodeId, message);
+  }
+  /**
+   * Broadcast message to all nodes
+   */
+  broadcast(message) {
+    for (const nodeId of this.clusterManager.getMembers()) {
+      if (!this.clusterManager.isLocal(nodeId)) {
+        this.clusterManager.sendToNode(nodeId, message);
+      }
+    }
+  }
+  // ============================================
+  // Component Access
+  // ============================================
+  /**
+   * Get underlying ClusterManager
+   */
+  getClusterManager() {
+    return this.clusterManager;
+  }
+  /**
+   * Get underlying PartitionService
+   */
+  getPartitionService() {
+    return this.partitionService;
+  }
+  /**
+   * Get underlying ReplicationPipeline
+   */
+  getReplicationPipeline() {
+    return this.replicationPipeline;
+  }
+  /**
+   * Get underlying LagTracker
+   */
+  getLagTracker() {
+    return this.lagTracker;
+  }
+  // ============================================
+  // Metrics Export
+  // ============================================
+  /**
+   * Get all metrics in Prometheus format
+   */
+  getPrometheusMetrics() {
+    const lines = [];
+    lines.push("# HELP topgun_cluster_members Number of cluster members");
+    lines.push("# TYPE topgun_cluster_members gauge");
+    lines.push(`topgun_cluster_members ${this.clusterManager.getMembers().length}`);
+    lines.push("");
+    lines.push("# HELP topgun_cluster_started Cluster started status (1=started, 0=stopped)");
+    lines.push("# TYPE topgun_cluster_started gauge");
+    lines.push(`topgun_cluster_started ${this.started ? 1 : 0}`);
+    lines.push("");
+    lines.push("# HELP topgun_partition_map_version Current partition map version");
+    lines.push("# TYPE topgun_partition_map_version gauge");
+    lines.push(`topgun_partition_map_version ${this.partitionService.getMapVersion()}`);
+    const migrationMetrics = this.getMigrationMetrics();
+    if (migrationMetrics) {
+      lines.push("");
+      lines.push("# HELP topgun_migrations_started Total migrations started");
+      lines.push("# TYPE topgun_migrations_started counter");
+      lines.push(`topgun_migrations_started ${migrationMetrics.migrationsStarted}`);
+      lines.push("");
+      lines.push("# HELP topgun_migrations_completed Total migrations completed");
+      lines.push("# TYPE topgun_migrations_completed counter");
+      lines.push(`topgun_migrations_completed ${migrationMetrics.migrationsCompleted}`);
+      lines.push("");
+      lines.push("# HELP topgun_migrations_failed Total migrations failed");
+      lines.push("# TYPE topgun_migrations_failed counter");
+      lines.push(`topgun_migrations_failed ${migrationMetrics.migrationsFailed}`);
+      lines.push("");
+      lines.push("# HELP topgun_migrations_active Currently active migrations");
+      lines.push("# TYPE topgun_migrations_active gauge");
+      lines.push(`topgun_migrations_active ${migrationMetrics.activeMigrations}`);
+      lines.push("");
+      lines.push("# HELP topgun_migrations_queued Queued migrations");
+      lines.push("# TYPE topgun_migrations_queued gauge");
+      lines.push(`topgun_migrations_queued ${migrationMetrics.queuedMigrations}`);
+    }
+    lines.push("");
+    lines.push(this.lagTracker.toPrometheusMetrics());
+    return lines.join("\n");
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  setupEventHandlers() {
+    this.clusterManager.on("memberJoined", (nodeId) => {
+      logger.info({ nodeId }, "Cluster member joined");
+      this.emit("member:joined", nodeId);
+    });
+    this.clusterManager.on("memberLeft", (nodeId) => {
+      logger.info({ nodeId }, "Cluster member left");
+      this.lagTracker.removeNode(nodeId);
+      this.emit("member:left", nodeId);
+    });
+    this.partitionService.on("rebalanced", (map, changes) => {
+      logger.info({ version: map.version, changesCount: changes.length }, "Partition map rebalanced");
+      this.emit("partition:rebalanced", map, changes);
+    });
+    this.partitionService.on("partitionMoved", (info) => {
+      this.emit("partition:moved", info);
+    });
+    const migrationManager = this.partitionService.getMigrationManager();
+    if (migrationManager) {
+      migrationManager.on("migrationStarted", (partitionId, targetNode) => {
+        this.emit("migration:started", partitionId, targetNode);
+      });
+      migrationManager.on("migrationComplete", (partitionId) => {
+        this.emit("migration:completed", partitionId);
+      });
+      migrationManager.on("migrationFailed", (partitionId, error) => {
+        this.emit("migration:failed", partitionId, error);
+      });
+    }
+    if (this.replicationPipeline) {
+      this.replicationPipeline.on("ackReceived", (nodeId) => {
+        this.lagTracker.recordAck(nodeId);
+      });
+      this.replicationPipeline.on("replicationSent", (nodeId) => {
+        this.lagTracker.incrementPending(nodeId);
+      });
+    }
+  }
+};
 export {
   BufferPool,
+  ClusterCoordinator,
+  ClusterManager,
   ConnectionRateLimiter,
+  DEFAULT_CLUSTER_COORDINATOR_CONFIG,
+  DEFAULT_LAG_TRACKER_CONFIG,
   FilterTasklet,
   ForEachTasklet,
   IteratorTasklet,
+  LagTracker,
+  LockManager,
   MapTasklet,
   MemoryServerAdapter,
+  MigrationManager,
   ObjectPool,
+  PartitionService,
   PostgresAdapter,
   RateLimitInterceptor,
   ReduceTasklet,
+  ReplicationPipeline,
   SecurityManager,
   ServerCoordinator,
   TaskletScheduler,