@topgunbuild/server 0.8.1 → 0.10.0

package/dist/index.js

@@ -105,8 +105,8 @@ module.exports = __toCommonJS(index_exports);
 var import_http = require("http");
 var import_https = require("https");
 var import_fs2 = require("fs");
-var import_ws3 = require("ws");
-var import_core20 = require("@topgunbuild/core");
+var import_ws5 = require("ws");
+var import_core22 = require("@topgunbuild/core");
 var jwt = __toESM(require("jsonwebtoken"));
 var crypto = __toESM(require("crypto"));
 
@@ -160,6 +160,10 @@ function matchesQuery(record, query) {
   return true;
 }
 function executeQuery(records, query) {
+  const result = executeQueryWithCursor(records, query);
+  return result.results;
+}
+function executeQueryWithCursor(records, query) {
   if (!query) {
     query = {};
   }
@@ -177,9 +181,13 @@ function executeQuery(records, query) {
       }
     }
   }
-  if (query.sort) {
+  const sort = query.sort || {};
+  const sortEntries = Object.entries(sort);
+  const sortField = sortEntries.length > 0 ? sortEntries[0][0] : "_key";
+  const sortDirection = sortEntries.length > 0 ? sortEntries[0][1] : "asc";
+  if (sortEntries.length > 0) {
     results.sort((a, b) => {
-      for (const [field, direction] of Object.entries(query.sort)) {
+      for (const [field, direction] of sortEntries) {
         const valA = a.record.value[field];
         const valB = b.record.value[field];
         if (valA < valB) return direction === "asc" ? -1 : 1;
@@ -188,16 +196,55 @@ function executeQuery(records, query) {
       return 0;
     });
   }
-  if (query.offset || query.limit) {
-    const offset = query.offset || 0;
-    const limit = query.limit || results.length;
-    results = results.slice(offset, offset + limit);
+  let cursorStatus = "none";
+  if (query.cursor) {
+    const cursorData = import_core.QueryCursor.decode(query.cursor);
+    if (!cursorData) {
+      cursorStatus = "invalid";
+    } else if (!import_core.QueryCursor.isValid(cursorData, query.predicate ?? query.where, sort)) {
+      if (Date.now() - cursorData.timestamp > import_core.DEFAULT_QUERY_CURSOR_MAX_AGE_MS) {
+        cursorStatus = "expired";
+      } else {
+        cursorStatus = "invalid";
+      }
+    } else {
+      cursorStatus = "valid";
+      results = results.filter((r) => {
+        const sortValue = r.record.value[sortField];
+        return import_core.QueryCursor.isAfterCursor(
+          { key: r.key, sortValue },
+          cursorData
+        );
+      });
+    }
+  }
+  const hasLimit = query.limit !== void 0 && query.limit > 0;
+  const totalBeforeLimit = results.length;
+  if (hasLimit) {
+    results = results.slice(0, query.limit);
+  }
+  const hasMore = hasLimit && totalBeforeLimit > query.limit;
+  let nextCursor;
+  if (hasMore && results.length > 0) {
+    const lastResult = results[results.length - 1];
+    const sortValue = lastResult.record.value[sortField];
+    nextCursor = import_core.QueryCursor.fromLastResult(
+      { key: lastResult.key, sortValue },
+      sort,
+      query.predicate ?? query.where
+    );
   }
-  return results.map((r) => ({ key: r.key, value: r.record.value }));
+  return {
+    results: results.map((r) => ({ key: r.key, value: r.record.value })),
+    nextCursor,
+    hasMore,
+    cursorStatus
+  };
 }
 
 // src/query/QueryRegistry.ts
 var import_core2 = require("@topgunbuild/core");
+var import_ws = require("ws");
 
 // src/utils/logger.ts
 var import_pino = __toESM(require("pino"));
@@ -386,6 +433,106 @@ var QueryRegistry = class {
       }
     }
   }
+  /**
+   * Set the ClusterManager for distributed subscriptions.
+   */
+  setClusterManager(clusterManager, nodeId) {
+    this.clusterManager = clusterManager;
+    this.nodeId = nodeId;
+  }
+  /**
+   * Set the callback for getting maps by name.
+   * Required for distributed subscriptions to return initial results.
+   */
+  setMapGetter(getter) {
+    this.getMap = getter;
+  }
+  /**
+   * Register a distributed subscription from a remote coordinator.
+   * Called when receiving CLUSTER_SUB_REGISTER message.
+   *
+   * @param subscriptionId - Unique subscription ID
+   * @param mapName - Map name to query
+   * @param query - Query predicate
+   * @param coordinatorNodeId - Node ID of the coordinator (receives updates)
+   * @returns Initial query results from this node
+   */
+  registerDistributed(subscriptionId, mapName, query, coordinatorNodeId) {
+    const dummySocket = {
+      readyState: 1,
+      send: () => {
+      }
+      // Updates go via cluster messages, not socket
+    };
+    let initialResults = [];
+    const previousResultKeys = /* @__PURE__ */ new Set();
+    if (this.getMap) {
+      const map = this.getMap(mapName);
+      if (map) {
+        const records = this.getMapRecords(map);
+        const queryResults = executeQuery(records, query);
+        initialResults = queryResults.map((r) => {
+          previousResultKeys.add(r.key);
+          return { key: r.key, value: r.value };
+        });
+      }
+    }
+    const sub = {
+      id: subscriptionId,
+      clientId: `cluster:${coordinatorNodeId}`,
+      mapName,
+      query,
+      socket: dummySocket,
+      previousResultKeys,
+      coordinatorNodeId,
+      isDistributed: true
+    };
+    this.register(sub);
+    logger.debug(
+      { subscriptionId, mapName, coordinatorNodeId, resultCount: initialResults.length },
+      "Distributed query subscription registered"
+    );
+    return initialResults;
+  }
+  /**
+   * Get a distributed subscription by ID.
+   * Returns undefined if not found or not distributed.
+   */
+  getDistributedSubscription(subscriptionId) {
+    for (const subs of this.subscriptions.values()) {
+      for (const sub of subs) {
+        if (sub.id === subscriptionId && sub.isDistributed) {
+          return sub;
+        }
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Unregister all distributed subscriptions where the given node was the coordinator.
+   * Called when a cluster node disconnects.
+   *
+   * @param coordinatorNodeId - Node ID of the disconnected coordinator
+   */
+  unregisterByCoordinator(coordinatorNodeId) {
+    const subscriptionsToRemove = [];
+    for (const subs of this.subscriptions.values()) {
+      for (const sub of subs) {
+        if (sub.isDistributed && sub.coordinatorNodeId === coordinatorNodeId) {
+          subscriptionsToRemove.push(sub.id);
+        }
+      }
+    }
+    for (const subId of subscriptionsToRemove) {
+      this.unregister(subId);
+    }
+    if (subscriptionsToRemove.length > 0) {
+      logger.debug(
+        { coordinatorNodeId, count: subscriptionsToRemove.length },
+        "Cleaned up distributed query subscriptions for disconnected coordinator"
+      );
+    }
+  }
   /**
    * Returns all active subscriptions for a specific map.
    * Used for subscription-based event routing to avoid broadcasting to all clients.
@@ -668,7 +815,9 @@ var QueryRegistry = class {
     return record.value;
   }
   sendUpdate(sub, key, value, type) {
-    if (sub.socket.readyState === 1) {
+    if (sub.isDistributed && sub.coordinatorNodeId && this.clusterManager) {
+      this.sendDistributedUpdate(sub, key, value, type);
+    } else if (sub.socket.readyState === import_ws.WebSocket.OPEN) {
       sub.socket.send((0, import_core2.serialize)({
         type: "QUERY_UPDATE",
         payload: {
@@ -680,6 +829,26 @@ var QueryRegistry = class {
       }));
     }
   }
+  /**
+   * Send update to remote coordinator node for a distributed subscription.
+   */
+  sendDistributedUpdate(sub, key, value, type) {
+    if (!this.clusterManager || !sub.coordinatorNodeId) return;
+    const changeType = type === "UPDATE" ? sub.previousResultKeys.has(key) ? "UPDATE" : "ENTER" : "LEAVE";
+    const payload = {
+      subscriptionId: sub.id,
+      sourceNodeId: this.nodeId || "unknown",
+      key,
+      value,
+      changeType,
+      timestamp: Date.now()
+    };
+    this.clusterManager.send(sub.coordinatorNodeId, "CLUSTER_SUB_UPDATE", payload);
+    logger.debug(
+      { subscriptionId: sub.id, key, changeType, coordinator: sub.coordinatorNodeId },
+      "Sent distributed query update"
+    );
+  }
   analyzeQueryFields(query) {
     const fields = /* @__PURE__ */ new Set();
     try {
@@ -818,7 +987,7 @@ var TopicManager = class {
 };
 
 // src/cluster/ClusterManager.ts
-var import_ws = require("ws");
+var import_ws2 = require("ws");
 var import_events2 = require("events");
 var dns = __toESM(require("dns"));
 var import_fs = require("fs");
@@ -1123,7 +1292,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
       if (this.config.tls?.enabled) {
         const tlsOptions = this.buildClusterTLSOptions();
         const httpsServer = https.createServer(tlsOptions);
-        this.server = new import_ws.WebSocketServer({ server: httpsServer });
+        this.server = new import_ws2.WebSocketServer({ server: httpsServer });
         httpsServer.listen(this.config.port, () => {
           const addr = httpsServer.address();
           this._actualPort = typeof addr === "object" && addr ? addr.port : this.config.port;
@@ -1131,7 +1300,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
           this.onServerReady(resolve);
         });
       } else {
-        this.server = new import_ws.WebSocketServer({ port: this.config.port });
+        this.server = new import_ws2.WebSocketServer({ port: this.config.port });
         this.server.on("listening", () => {
           const addr = this.server.address();
           this._actualPort = typeof addr === "object" && addr ? addr.port : this.config.port;
@@ -1211,7 +1380,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
   sendHeartbeatToAll() {
     for (const [nodeId, member] of this.members) {
       if (member.isSelf) continue;
-      if (member.socket && member.socket.readyState === import_ws.WebSocket.OPEN) {
+      if (member.socket && member.socket.readyState === import_ws2.WebSocket.OPEN) {
         this.send(nodeId, "HEARTBEAT", { timestamp: Date.now() });
       }
     }
@@ -1245,7 +1414,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
   broadcastMemberList() {
     for (const [nodeId, member] of this.members) {
       if (member.isSelf) continue;
-      if (member.socket && member.socket.readyState === import_ws.WebSocket.OPEN) {
+      if (member.socket && member.socket.readyState === import_ws2.WebSocket.OPEN) {
         this.sendMemberList(nodeId);
       }
     }
@@ -1270,7 +1439,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
     const member = this.members.get(nodeId);
     if (!member) return;
     logger.warn({ nodeId }, "Removing failed node from cluster");
-    if (member.socket && member.socket.readyState !== import_ws.WebSocket.CLOSED) {
+    if (member.socket && member.socket.readyState !== import_ws2.WebSocket.CLOSED) {
       try {
         member.socket.terminate();
       } catch (e) {
@@ -1344,9 +1513,9 @@ var ClusterManager = class extends import_events2.EventEmitter {
         if (this.config.tls.caCertPath) {
           wsOptions.ca = (0, import_fs.readFileSync)(this.config.tls.caCertPath);
         }
-        ws = new import_ws.WebSocket(`${protocol}${peerAddress}`, wsOptions);
+        ws = new import_ws2.WebSocket(`${protocol}${peerAddress}`, wsOptions);
       } else {
-        ws = new import_ws.WebSocket(`ws://${peerAddress}`);
+        ws = new import_ws2.WebSocket(`ws://${peerAddress}`);
       }
       ws.on("open", () => {
         this.pendingConnections.delete(peerAddress);
@@ -1433,7 +1602,7 @@ var ClusterManager = class extends import_events2.EventEmitter {
   }
   send(nodeId, type, payload) {
     const member = this.members.get(nodeId);
-    if (member && member.socket && member.socket.readyState === import_ws.WebSocket.OPEN) {
+    if (member && member.socket && member.socket.readyState === import_ws2.WebSocket.OPEN) {
       const msg = {
         type,
         senderId: this.config.nodeId,
@@ -2652,6 +2821,90 @@ var MetricsService = class {
       help: "Current connection rate per second",
       registers: [this.registry]
     });
+    this.distributedSearchTotal = new import_prom_client.Counter({
+      name: "topgun_distributed_search_total",
+      help: "Total number of distributed search requests",
+      labelNames: ["map", "status"],
+      registers: [this.registry]
+    });
+    this.distributedSearchDuration = new import_prom_client.Summary({
+      name: "topgun_distributed_search_duration_ms",
+      help: "Distribution of distributed search execution times in milliseconds",
+      labelNames: ["map"],
+      percentiles: [0.5, 0.9, 0.95, 0.99],
+      registers: [this.registry]
+    });
+    this.distributedSearchFailedNodes = new import_prom_client.Counter({
+      name: "topgun_distributed_search_failed_nodes_total",
+      help: "Total number of node failures during distributed search",
+      registers: [this.registry]
+    });
+    this.distributedSearchPartialResults = new import_prom_client.Counter({
+      name: "topgun_distributed_search_partial_results_total",
+      help: "Total number of searches that returned partial results due to node failures",
+      registers: [this.registry]
+    });
+    this.distributedSubTotal = new import_prom_client.Counter({
+      name: "topgun_distributed_sub_total",
+      help: "Total distributed subscriptions created",
+      labelNames: ["type", "status"],
+      registers: [this.registry]
+    });
+    this.distributedSubUnsubscribeTotal = new import_prom_client.Counter({
+      name: "topgun_distributed_sub_unsubscribe_total",
+      help: "Total unsubscriptions from distributed subscriptions",
+      labelNames: ["type"],
+      registers: [this.registry]
+    });
+    this.distributedSubActive = new import_prom_client.Gauge({
+      name: "topgun_distributed_sub_active",
+      help: "Currently active distributed subscriptions",
+      labelNames: ["type"],
+      registers: [this.registry]
+    });
+    this.distributedSubPendingAcks = new import_prom_client.Gauge({
+      name: "topgun_distributed_sub_pending_acks",
+      help: "Subscriptions waiting for ACKs from cluster nodes",
+      registers: [this.registry]
+    });
+    this.distributedSubUpdates = new import_prom_client.Counter({
+      name: "topgun_distributed_sub_updates_total",
+      help: "Delta updates processed for distributed subscriptions",
+      labelNames: ["direction", "change_type"],
+      registers: [this.registry]
+    });
+    this.distributedSubAckTotal = new import_prom_client.Counter({
+      name: "topgun_distributed_sub_ack_total",
+      help: "Node ACK responses for distributed subscriptions",
+      labelNames: ["status"],
+      registers: [this.registry]
+    });
+    this.distributedSubNodeDisconnect = new import_prom_client.Counter({
+      name: "topgun_distributed_sub_node_disconnect_total",
+      help: "Node disconnects affecting distributed subscriptions",
+      registers: [this.registry]
+    });
+    this.distributedSubRegistrationDuration = new import_prom_client.Histogram({
+      name: "topgun_distributed_sub_registration_duration_ms",
+      help: "Time to register subscription on all nodes",
+      labelNames: ["type"],
+      buckets: [10, 50, 100, 250, 500, 1e3, 2500],
+      registers: [this.registry]
+    });
+    this.distributedSubUpdateLatency = new import_prom_client.Histogram({
+      name: "topgun_distributed_sub_update_latency_ms",
+      help: "Latency from data change to client notification",
+      labelNames: ["type"],
+      buckets: [1, 5, 10, 25, 50, 100, 250],
+      registers: [this.registry]
+    });
+    this.distributedSubInitialResultsCount = new import_prom_client.Histogram({
+      name: "topgun_distributed_sub_initial_results_count",
+      help: "Initial result set size for distributed subscriptions",
+      labelNames: ["type"],
+      buckets: [0, 1, 5, 10, 25, 50, 100],
+      registers: [this.registry]
+    });
   }
   destroy() {
     this.registry.clear();
@@ -2762,6 +3015,115 @@ var MetricsService = class {
   setConnectionRatePerSecond(rate) {
     this.connectionRatePerSecond.set(rate);
   }
+  // === Distributed search metric methods (Phase 14) ===
+  /**
+   * Record a distributed search request.
+   * @param mapName - Name of the map being searched
+   * @param status - 'success', 'partial', or 'error'
+   */
+  incDistributedSearch(mapName, status) {
+    this.distributedSearchTotal.inc({ map: mapName, status });
+  }
+  /**
+   * Record the duration of a distributed search.
+   * @param mapName - Name of the map being searched
+   * @param durationMs - Duration in milliseconds
+   */
+  recordDistributedSearchDuration(mapName, durationMs) {
+    this.distributedSearchDuration.observe({ map: mapName }, durationMs);
+  }
+  /**
+   * Increment counter for failed nodes during distributed search.
+   * @param count - Number of nodes that failed (default 1)
+   */
+  incDistributedSearchFailedNodes(count = 1) {
+    this.distributedSearchFailedNodes.inc(count);
+  }
+  /**
+   * Increment counter for searches returning partial results.
+   */
+  incDistributedSearchPartialResults() {
+    this.distributedSearchPartialResults.inc();
+  }
+  // === Distributed subscription metric methods (Phase 14.2) ===
+  /**
+   * Record a distributed subscription creation.
+   * @param type - Subscription type (SEARCH or QUERY)
+   * @param status - Result status (success, failed, timeout)
+   */
+  incDistributedSub(type, status) {
+    this.distributedSubTotal.inc({ type, status });
+    if (status === "success") {
+      this.distributedSubActive.inc({ type });
+    }
+  }
+  /**
+   * Record a distributed subscription unsubscription.
+   * @param type - Subscription type (SEARCH or QUERY)
+   */
+  incDistributedSubUnsubscribe(type) {
+    this.distributedSubUnsubscribeTotal.inc({ type });
+  }
+  /**
+   * Decrement the active distributed subscriptions gauge.
+   * @param type - Subscription type (SEARCH or QUERY)
+   */
+  decDistributedSubActive(type) {
+    this.distributedSubActive.dec({ type });
+  }
+  /**
+   * Set the number of subscriptions waiting for ACKs.
+   * @param count - Number of pending ACKs
+   */
+  setDistributedSubPendingAcks(count) {
+    this.distributedSubPendingAcks.set(count);
+  }
+  /**
+   * Record a delta update for distributed subscriptions.
+   * @param direction - Direction of update (sent or received)
+   * @param changeType - Type of change (ENTER, UPDATE, LEAVE)
+   */
+  incDistributedSubUpdates(direction, changeType) {
+    this.distributedSubUpdates.inc({ direction, change_type: changeType });
+  }
+  /**
+   * Record node ACK responses.
+   * @param status - ACK status (success, failed, timeout)
+   * @param count - Number of ACKs to record (default 1)
+   */
+  incDistributedSubAck(status, count = 1) {
+    this.distributedSubAckTotal.inc({ status }, count);
+  }
+  /**
+   * Record a node disconnect affecting distributed subscriptions.
+   */
+  incDistributedSubNodeDisconnect() {
+    this.distributedSubNodeDisconnect.inc();
+  }
+  /**
+   * Record the time to register a subscription on all nodes.
+   * @param type - Subscription type (SEARCH or QUERY)
+   * @param durationMs - Duration in milliseconds
+   */
+  recordDistributedSubRegistration(type, durationMs) {
+    this.distributedSubRegistrationDuration.observe({ type }, durationMs);
+  }
+  /**
+   * Record the latency from data change to client notification.
+   * @param type - Subscription type (SEARCH or QUERY)
+   * @param latencyMs - Latency in milliseconds
+   */
+  recordDistributedSubUpdateLatency(type, latencyMs) {
+    this.distributedSubUpdateLatency.observe({ type }, latencyMs);
+  }
+  /**
+   * Record the initial result set size for a subscription.
+   * @param type - Subscription type (SEARCH or QUERY)
+   * @param count - Number of initial results
+   */
+  recordDistributedSubInitialResultsCount(type, count) {
+    this.distributedSubInitialResultsCount.observe({ type }, count);
+  }
   async getMetrics() {
     return this.registry.metrics();
   }
@@ -3292,7 +3654,7 @@ var BackpressureRegulator = class {
 };
 
 // src/utils/CoalescingWriter.ts
-var import_ws2 = require("ws");
+var import_ws3 = require("ws");
 var import_core5 = require("@topgunbuild/core");
 
 // src/memory/BufferPool.ts
@@ -3862,7 +4224,7 @@ var CoalescingWriter = class {
     }
     this.state = 2 /* FLUSHING */;
     try {
-      if (this.socket.readyState !== import_ws2.WebSocket.OPEN) {
+      if (this.socket.readyState !== import_ws3.WebSocket.OPEN) {
         this.queue = [];
         this.pendingBytes = 0;
         this.state = 0 /* IDLE */;
@@ -3935,7 +4297,7 @@ var CoalescingWriter = class {
    * Send a message immediately without batching.
    */
   sendImmediate(data) {
-    if (this.socket.readyState !== import_ws2.WebSocket.OPEN) {
+    if (this.socket.readyState !== import_ws3.WebSocket.OPEN) {
       return;
     }
     try {
@@ -7517,7 +7879,7 @@ var RepairScheduler = class extends import_events12.EventEmitter {
     this.processTimer = setInterval(() => {
       this.processRepairQueue();
     }, 1e3);
-    setTimeout(() => {
+    this.initialScanTimer = setTimeout(() => {
       this.scheduleFullScan();
     }, 6e4);
   }
@@ -7535,9 +7897,13 @@ var RepairScheduler = class extends import_events12.EventEmitter {
       clearInterval(this.processTimer);
       this.processTimer = void 0;
     }
+    if (this.initialScanTimer) {
+      clearTimeout(this.initialScanTimer);
+      this.initialScanTimer = void 0;
+    }
     this.repairQueue = [];
     this.activeRepairs.clear();
-    for (const [id, req] of this.pendingRequests) {
+    for (const [, req] of this.pendingRequests) {
       clearTimeout(req.timer);
       req.reject(new Error("Scheduler stopped"));
     }
@@ -9257,9 +9623,11 @@ var EventJournalService = class extends import_core18.EventJournalImpl {
 };
 
 // src/search/SearchCoordinator.ts
+var import_events13 = require("events");
 var import_core19 = require("@topgunbuild/core");
-var SearchCoordinator = class {
+var SearchCoordinator = class extends import_events13.EventEmitter {
   constructor() {
+    super();
     /** Map name → FullTextIndex */
     this.indexes = /* @__PURE__ */ new Map();
     /** Map name → FullTextIndexConfig (for reference) */
@@ -9284,6 +9652,13 @@ var SearchCoordinator = class {
     this.BATCH_INTERVAL = 16;
     logger.debug("SearchCoordinator initialized");
   }
+  /**
+   * Set the node ID for this server.
+   * Required for distributed subscriptions.
+   */
+  setNodeId(nodeId) {
+    this.nodeId = nodeId;
+  }
   /**
    * Set the callback for sending updates to clients.
    * Called by ServerCoordinator during initialization.
@@ -9585,9 +9960,112 @@ var SearchCoordinator = class {
   getSubscriptionCount() {
     return this.subscriptions.size;
   }
+  // ============================================
+  // Phase 14.2: Distributed Subscription Methods
+  // ============================================
+  /**
+   * Register a distributed subscription from a remote coordinator.
+   * Called when receiving CLUSTER_SUB_REGISTER message.
+   *
+   * @param subscriptionId - Unique subscription ID
+   * @param mapName - Map name to search
+   * @param query - Search query string
+   * @param options - Search options
+   * @param coordinatorNodeId - Node ID of the coordinator (receives updates)
+   * @returns Initial search results from this node
+   */
+  registerDistributedSubscription(subscriptionId, mapName, query, options, coordinatorNodeId) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Distributed subscription for map without FTS enabled");
+      return { results: [], totalHits: 0 };
+    }
+    const queryTerms = index.tokenizeQuery(query);
+    const searchResults = index.search(query, options);
+    const currentResults = /* @__PURE__ */ new Map();
+    const results = [];
+    for (const result of searchResults) {
+      const value = this.getDocumentValue ? this.getDocumentValue(mapName, result.docId) : void 0;
+      currentResults.set(result.docId, {
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+      results.push({
+        key: result.docId,
+        value,
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+    }
+    const subscription = {
+      id: subscriptionId,
+      clientId: `cluster:${coordinatorNodeId}`,
+      // Virtual client ID
+      mapName,
+      query,
+      queryTerms,
+      options: options || {},
+      currentResults,
+      // Distributed fields
+      coordinatorNodeId,
+      isDistributed: true
+    };
+    this.subscriptions.set(subscriptionId, subscription);
+    if (!this.subscriptionsByMap.has(mapName)) {
+      this.subscriptionsByMap.set(mapName, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByMap.get(mapName).add(subscriptionId);
+    if (!this.subscriptionsByClient.has(subscription.clientId)) {
+      this.subscriptionsByClient.set(subscription.clientId, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByClient.get(subscription.clientId).add(subscriptionId);
+    logger.debug(
+      { subscriptionId, mapName, query, coordinatorNodeId, resultCount: results.length },
+      "Distributed search subscription registered"
+    );
+    return {
+      results,
+      totalHits: results.length
+    };
+  }
+  /**
+   * Get a distributed subscription by ID.
+   * Returns undefined if not found or not distributed.
+   */
+  getDistributedSubscription(subscriptionId) {
+    const sub = this.subscriptions.get(subscriptionId);
+    if (sub?.isDistributed) {
+      return sub;
+    }
+    return void 0;
+  }
+  /**
+   * Unsubscribe all distributed subscriptions where the given node was the coordinator.
+   * Called when a cluster node disconnects.
+   *
+   * @param coordinatorNodeId - Node ID of the disconnected coordinator
+   */
+  unsubscribeByCoordinator(coordinatorNodeId) {
+    const subscriptionsToRemove = [];
+    for (const [subId, sub] of this.subscriptions) {
+      if (sub.isDistributed && sub.coordinatorNodeId === coordinatorNodeId) {
+        subscriptionsToRemove.push(subId);
+      }
+    }
+    for (const subId of subscriptionsToRemove) {
+      this.unsubscribe(subId);
+    }
+    if (subscriptionsToRemove.length > 0) {
+      logger.debug(
+        { coordinatorNodeId, count: subscriptionsToRemove.length },
+        "Cleaned up distributed subscriptions for disconnected coordinator"
+      );
+    }
+  }
   /**
    * Notify subscribers about a document change.
    * Computes delta (ENTER/UPDATE/LEAVE) for each affected subscription.
+   * For distributed subscriptions, emits 'distributedUpdate' event instead of sending to client.
    *
    * @param mapName - Name of the map that changed
    * @param key - Document key that changed
@@ -9595,9 +10073,6 @@ var SearchCoordinator = class {
    * @param changeType - Type of change
    */
   notifySubscribers(mapName, key, value, changeType) {
-    if (!this.sendUpdate) {
-      return;
-    }
     const subscriptionIds = this.subscriptionsByMap.get(mapName);
     if (!subscriptionIds || subscriptionIds.size === 0) {
       return;
@@ -9638,18 +10113,50 @@ var SearchCoordinator = class {
       }
       logger.debug({ subId, key, wasInResults, isInResults, updateType, newScore }, "Update decision");
       if (updateType) {
-        this.sendUpdate(
-          sub.clientId,
-          subId,
-          key,
-          value,
-          newScore,
-          matchedTerms,
-          updateType
-        );
+        if (sub.isDistributed && sub.coordinatorNodeId) {
+          this.sendDistributedUpdate(sub, key, value, newScore, matchedTerms, updateType);
+        } else if (this.sendUpdate) {
+          this.sendUpdate(
+            sub.clientId,
+            subId,
+            key,
+            value,
+            newScore,
+            matchedTerms,
+            updateType
+          );
+        }
       }
     }
   }
+  /**
+   * Send update to remote coordinator node for a distributed subscription.
+   * Emits 'distributedUpdate' event with ClusterSubUpdatePayload.
+   *
+   * @param sub - The distributed subscription
+   * @param key - Document key
+   * @param value - Document value
+   * @param score - Search score
+   * @param matchedTerms - Matched search terms
+   * @param changeType - Change type (ENTER/UPDATE/LEAVE)
+   */
+  sendDistributedUpdate(sub, key, value, score, matchedTerms, changeType) {
+    const payload = {
+      subscriptionId: sub.id,
+      sourceNodeId: this.nodeId || "unknown",
+      key,
+      value,
+      score,
+      matchedTerms,
+      changeType,
+      timestamp: Date.now()
+    };
+    this.emit("distributedUpdate", payload);
+    logger.debug(
+      { subscriptionId: sub.id, key, changeType, coordinator: sub.coordinatorNodeId },
+      "Emitted distributed update"
+    );
+  }
   /**
    * Score a single document against a subscription's query.
    *
@@ -9804,37 +10311,1205 @@ var SearchCoordinator = class {
   }
 };
 
-// src/ServerCoordinator.ts
-var GC_INTERVAL_MS = 60 * 60 * 1e3;
-var GC_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
-var CLIENT_HEARTBEAT_TIMEOUT_MS = 2e4;
-var CLIENT_HEARTBEAT_CHECK_INTERVAL_MS = 5e3;
-var ServerCoordinator = class {
-  constructor(config) {
-    this.clients = /* @__PURE__ */ new Map();
-    // Interceptors
-    this.interceptors = [];
-    // In-memory storage (partitioned later)
-    this.maps = /* @__PURE__ */ new Map();
-    this.pendingClusterQueries = /* @__PURE__ */ new Map();
-    // GC Consensus State
-    this.gcReports = /* @__PURE__ */ new Map();
-    // Track map loading state to avoid returning empty results during async load
-    this.mapLoadingPromises = /* @__PURE__ */ new Map();
-    // Track pending batch operations for testing purposes
-    this.pendingBatchOperations = /* @__PURE__ */ new Set();
-    this.journalSubscriptions = /* @__PURE__ */ new Map();
-    this._actualPort = 0;
-    this._actualClusterPort = 0;
-    this._readyPromise = new Promise((resolve) => {
-      this._readyResolve = resolve;
-    });
-    this._nodeId = config.nodeId;
-    this.hlc = new import_core20.HLC(config.nodeId);
-    this.storage = config.storage;
-    const rawSecret = config.jwtSecret || process.env.JWT_SECRET || "topgun-secret-dev";
-    this.jwtSecret = rawSecret.replace(/\\n/g, "\n");
-    this.queryRegistry = new QueryRegistry();
+// src/search/ClusterSearchCoordinator.ts
+var import_events14 = require("events");
+var import_core20 = require("@topgunbuild/core");
+var DEFAULT_CONFIG6 = {
+  rrfK: 60,
+  defaultTimeoutMs: 5e3,
+  defaultMinResponses: 0
+};
+var ClusterSearchCoordinator = class extends import_events14.EventEmitter {
+  constructor(clusterManager, partitionService, localSearchCoordinator, config, metricsService) {
+    super();
+    /** Pending requests awaiting responses */
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.clusterManager = clusterManager;
+    this.partitionService = partitionService;
+    this.localSearchCoordinator = localSearchCoordinator;
+    this.config = { ...DEFAULT_CONFIG6, ...config };
+    this.rrf = new import_core20.ReciprocalRankFusion({ k: this.config.rrfK });
+    this.metricsService = metricsService;
+    this.clusterManager.on("message", this.handleClusterMessage.bind(this));
+  }
+  /**
+   * Execute a distributed search across the cluster.
+   *
+   * @param mapName - Name of the map to search
+   * @param query - Search query text
+   * @param options - Search options
+   * @returns Promise resolving to merged search results
+   */
+  async search(mapName, query, options = { limit: 10 }) {
+    const startTime = performance.now();
+    const requestId = this.generateRequestId();
+    const timeoutMs = options.timeoutMs ?? this.config.defaultTimeoutMs;
+    const allNodes = new Set(this.clusterManager.getMembers());
+    const myNodeId = this.clusterManager.config.nodeId;
+    if (allNodes.size === 1 && allNodes.has(myNodeId)) {
+      return this.executeLocalSearch(mapName, query, options, startTime);
+    }
+    const perNodeLimit = this.calculatePerNodeLimit(options.limit, options.cursor);
+    let cursorData = null;
+    if (options.cursor) {
+      cursorData = import_core20.SearchCursor.decode(options.cursor);
+      if (cursorData && !import_core20.SearchCursor.isValid(cursorData, query)) {
+        cursorData = null;
+        logger.warn({ requestId }, "Invalid or expired cursor, ignoring");
+      }
+    }
+    const promise = new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.resolvePartialResults(requestId);
+      }, timeoutMs);
+      this.pendingRequests.set(requestId, {
+        resolve,
+        reject,
+        responses: /* @__PURE__ */ new Map(),
+        expectedNodes: allNodes,
+        startTime,
+        timeoutHandle,
+        options,
+        mapName,
+        query
+      });
+    });
+    const payload = {
+      requestId,
+      mapName,
+      query,
+      options: {
+        limit: perNodeLimit,
+        minScore: options.minScore,
+        boost: options.boost,
+        includeMatchedTerms: true,
+        // Add cursor position if available
+        ...cursorData ? {
+          afterScore: cursorData.nodeScores[myNodeId],
+          afterKey: cursorData.nodeKeys[myNodeId]
+        } : {}
+      },
+      timeoutMs
+    };
+    for (const nodeId of allNodes) {
+      if (nodeId === myNodeId) {
+        this.executeLocalAndRespond(requestId, mapName, query, perNodeLimit, cursorData);
+      } else {
+        this.clusterManager.send(nodeId, "CLUSTER_SEARCH_REQ", payload);
+      }
+    }
+    return promise;
+  }
+  /**
+   * Handle incoming cluster messages.
+   */
+  handleClusterMessage(msg) {
+    switch (msg.type) {
+      case "CLUSTER_SEARCH_REQ":
+        this.handleSearchRequest(msg.senderId, msg.payload);
+        break;
+      case "CLUSTER_SEARCH_RESP":
+        this.handleSearchResponse(msg.senderId, msg.payload);
+        break;
+    }
+  }
+  /**
+   * Handle incoming search request from another node.
+   */
+  async handleSearchRequest(senderId, rawPayload) {
+    const startTime = performance.now();
+    const myNodeId = this.clusterManager.config.nodeId;
+    const parsed = import_core20.ClusterSearchReqPayloadSchema.safeParse(rawPayload);
+    if (!parsed.success) {
+      logger.warn(
+        { senderId, error: parsed.error.message },
+        "Invalid cluster search request payload"
+      );
+      this.clusterManager.send(senderId, "CLUSTER_SEARCH_RESP", {
+        requestId: rawPayload?.requestId ?? "unknown",
+        nodeId: myNodeId,
+        results: [],
+        totalHits: 0,
+        executionTimeMs: performance.now() - startTime,
+        error: "Invalid request payload"
+      });
+      return;
+    }
+    const payload = parsed.data;
+    try {
+      const localResult = this.localSearchCoordinator.search(
+        payload.mapName,
+        payload.query,
+        {
+          limit: payload.options.limit,
+          minScore: payload.options.minScore,
+          boost: payload.options.boost
+        }
+      );
+      let results = localResult.results;
+      if (payload.options.afterScore !== void 0) {
+        results = results.filter((r) => {
+          if (r.score < payload.options.afterScore) {
+            return true;
+          }
+          if (r.score === payload.options.afterScore && payload.options.afterKey) {
+            return r.key > payload.options.afterKey;
+          }
+          return false;
+        });
+      }
+      const response = {
+        requestId: payload.requestId,
+        nodeId: myNodeId,
+        results: results.map((r) => ({
+          key: r.key,
+          value: r.value,
+          score: r.score,
+          matchedTerms: r.matchedTerms
+        })),
+        totalHits: localResult.totalCount ?? results.length,
+        executionTimeMs: performance.now() - startTime
+      };
+      this.clusterManager.send(senderId, "CLUSTER_SEARCH_RESP", response);
+    } catch (error) {
+      this.clusterManager.send(senderId, "CLUSTER_SEARCH_RESP", {
+        requestId: payload.requestId,
+        nodeId: myNodeId,
+        results: [],
+        totalHits: 0,
+        executionTimeMs: performance.now() - startTime,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Handle search response from a node.
+   */
+  handleSearchResponse(_senderId, rawPayload) {
+    const parsed = import_core20.ClusterSearchRespPayloadSchema.safeParse(rawPayload);
+    if (!parsed.success) {
+      logger.warn(
+        { error: parsed.error.message },
+        "Invalid cluster search response payload"
+      );
+      return;
+    }
+    const payload = parsed.data;
+    const pending = this.pendingRequests.get(payload.requestId);
+    if (!pending) {
+      logger.warn({ requestId: payload.requestId }, "Received response for unknown request");
+      return;
+    }
+    pending.responses.set(payload.nodeId, payload);
+    const minResponses = pending.options.minResponses ?? this.config.defaultMinResponses;
+    const requiredResponses = minResponses > 0 ? minResponses : pending.expectedNodes.size;
+    if (pending.responses.size >= requiredResponses) {
+      clearTimeout(pending.timeoutHandle);
+      this.mergeAndResolve(payload.requestId);
+    }
+  }
+  /**
+   * Merge results from all nodes using RRF and resolve the promise.
+   */
+  mergeAndResolve(requestId) {
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    const resultSets = [];
+    const respondedNodes = [];
+    const failedNodes = [];
+    let totalHits = 0;
+    const resultsWithNodes = [];
+    for (const [nodeId, response] of pending.responses) {
+      if (response.error) {
+        failedNodes.push(nodeId);
+        logger.warn({ nodeId, error: response.error }, "Node returned error for search");
+      } else {
+        respondedNodes.push(nodeId);
+        totalHits += response.totalHits;
+        const rankedResults = response.results.map((r) => ({
+          docId: r.key,
+          score: r.score,
+          source: nodeId
+        }));
+        resultSets.push(rankedResults);
+        for (const r of response.results) {
+          resultsWithNodes.push({
+            key: r.key,
+            score: r.score,
+            nodeId,
+            value: r.value,
+            matchedTerms: r.matchedTerms || []
+          });
+        }
+      }
+    }
+    for (const nodeId of pending.expectedNodes) {
+      if (!pending.responses.has(nodeId)) {
+        failedNodes.push(nodeId);
+      }
+    }
+    const merged = this.rrf.merge(resultSets);
+    const limit = pending.options.limit;
+    const results = [];
+    const cursorResults = [];
+    for (const mergedResult of merged.slice(0, limit)) {
+      const original = resultsWithNodes.find((r) => r.key === mergedResult.docId);
+      if (original) {
+        results.push({
+          key: original.key,
+          value: original.value,
+          score: mergedResult.score,
+          // Use RRF score
+          matchedTerms: original.matchedTerms
+        });
+        cursorResults.push({
+          key: original.key,
+          score: original.score,
+          // Use original score for cursor
+          nodeId: original.nodeId
+        });
+      }
+    }
+    let nextCursor;
+    if (merged.length > limit && cursorResults.length > 0) {
+      nextCursor = import_core20.SearchCursor.fromResults(cursorResults, pending.query);
+    }
+    const executionTimeMs = performance.now() - pending.startTime;
+    if (this.metricsService) {
+      const status = failedNodes.length === 0 ? "success" : respondedNodes.length === 0 ? "error" : "partial";
+      this.metricsService.incDistributedSearch(pending.mapName, status);
+      this.metricsService.recordDistributedSearchDuration(pending.mapName, executionTimeMs);
+      if (failedNodes.length > 0) {
+        this.metricsService.incDistributedSearchFailedNodes(failedNodes.length);
+        if (respondedNodes.length > 0) {
+          this.metricsService.incDistributedSearchPartialResults();
+        }
+      }
+    }
+    pending.resolve({
+      results,
+      totalHits,
+      nextCursor,
+      respondedNodes,
+      failedNodes,
+      executionTimeMs
+    });
+    this.pendingRequests.delete(requestId);
+    logger.debug({
+      requestId,
+      mapName: pending.mapName,
+      query: pending.query,
+      resultCount: results.length,
+      totalHits,
+      respondedNodes: respondedNodes.length,
+      failedNodes: failedNodes.length,
+      executionTimeMs
+    }, "Distributed search completed");
+  }
+  /**
+   * Resolve with partial results when timeout occurs.
+   */
+  resolvePartialResults(requestId) {
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    logger.warn(
+      {
+        requestId,
+        received: pending.responses.size,
+        expected: pending.expectedNodes.size
+      },
+      "Search request timed out, returning partial results"
+    );
+    this.mergeAndResolve(requestId);
+  }
+  /**
+   * Execute local search and add response to pending request.
+   */
+  async executeLocalAndRespond(requestId, mapName, query, limit, cursorData) {
+    const startTime = performance.now();
+    const myNodeId = this.clusterManager.config.nodeId;
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    try {
+      const localResult = this.localSearchCoordinator.search(mapName, query, {
+        limit,
+        minScore: pending.options.minScore,
+        boost: pending.options.boost
+      });
+      let results = localResult.results;
+      if (cursorData) {
+        const position = import_core20.SearchCursor.getNodePosition(cursorData, myNodeId);
+        if (position) {
+          results = results.filter((r) => {
+            if (r.score < position.afterScore) {
+              return true;
+            }
+            if (r.score === position.afterScore) {
+              return r.key > position.afterKey;
+            }
+            return false;
+          });
+        }
+      }
+      const response = {
+        requestId,
+        nodeId: myNodeId,
+        results: results.map((r) => ({
+          key: r.key,
+          value: r.value,
+          score: r.score,
+          matchedTerms: r.matchedTerms
+        })),
+        totalHits: localResult.totalCount ?? results.length,
+        executionTimeMs: performance.now() - startTime
+      };
+      this.handleSearchResponse(myNodeId, response);
+    } catch (error) {
+      this.handleSearchResponse(myNodeId, {
+        requestId,
+        nodeId: myNodeId,
+        results: [],
+        totalHits: 0,
+        executionTimeMs: performance.now() - startTime,
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  /**
+   * Execute search locally only (single-node optimization).
+   */
+  async executeLocalSearch(mapName, query, options, startTime) {
+    const myNodeId = this.clusterManager.config.nodeId;
+    const localResult = this.localSearchCoordinator.search(mapName, query, {
+      limit: options.limit,
+      minScore: options.minScore,
+      boost: options.boost
+    });
+    let results = localResult.results;
+    if (options.cursor) {
+      const cursorData = import_core20.SearchCursor.decode(options.cursor);
+      if (cursorData && import_core20.SearchCursor.isValid(cursorData, query)) {
+        const position = import_core20.SearchCursor.getNodePosition(cursorData, myNodeId);
+        if (position) {
+          results = results.filter((r) => {
+            if (r.score < position.afterScore) {
+              return true;
+            }
+            if (r.score === position.afterScore) {
+              return r.key > position.afterKey;
+            }
+            return false;
+          });
+        }
+      }
+    }
+    results = results.slice(0, options.limit);
+    const totalCount = localResult.totalCount ?? localResult.results.length;
+    let nextCursor;
+    if (totalCount > options.limit && results.length > 0) {
+      const lastResult = results[results.length - 1];
+      nextCursor = import_core20.SearchCursor.fromResults(
+        [{ key: lastResult.key, score: lastResult.score, nodeId: myNodeId }],
+        query
+      );
+    }
+    const executionTimeMs = performance.now() - startTime;
+    if (this.metricsService) {
+      this.metricsService.incDistributedSearch(mapName, "success");
+      this.metricsService.recordDistributedSearchDuration(mapName, executionTimeMs);
+    }
+    return {
+      results,
+      totalHits: localResult.totalCount ?? results.length,
+      nextCursor,
+      respondedNodes: [myNodeId],
+      failedNodes: [],
+      executionTimeMs
+    };
+  }
+  /**
+   * Calculate per-node limit for distributed query.
+   *
+   * For quality RRF merge, each node should return more than the final limit.
+   * Rule of thumb: 2x limit for good merge quality.
+   */
+  calculatePerNodeLimit(limit, cursor) {
+    if (cursor) {
+      return limit;
+    }
+    return Math.min(limit * 2, 1e3);
+  }
+  /**
+   * Generate unique request ID.
+   */
+  generateRequestId() {
+    return `search-${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+  }
+  /**
+   * Get RRF constant k.
+   */
+  getRrfK() {
+    return this.config.rrfK;
+  }
+  /**
+   * Clean up resources.
+   */
+  destroy() {
+    for (const [requestId, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeoutHandle);
+      pending.reject(new Error("ClusterSearchCoordinator destroyed"));
+    }
+    this.pendingRequests.clear();
+    this.removeAllListeners();
+  }
+};
+
+// src/subscriptions/DistributedSubscriptionCoordinator.ts
+var import_events15 = require("events");
+var import_core21 = require("@topgunbuild/core");
+var import_ws4 = require("ws");
+var DEFAULT_CONFIG7 = {
+  ackTimeoutMs: 5e3,
+  rrfK: 60
+};
+var DistributedSubscriptionCoordinator = class extends import_events15.EventEmitter {
+  constructor(clusterManager, queryRegistry, searchCoordinator, config, metricsService) {
+    super();
+    /**
+     * Active subscriptions where this node is coordinator.
+     * subscriptionId → SubscriptionState
+     */
+    this.subscriptions = /* @__PURE__ */ new Map();
+    /**
+     * Track which nodes have acknowledged subscription registration.
+     * subscriptionId → Set<nodeId>
+     */
+    this.nodeAcks = /* @__PURE__ */ new Map();
+    /**
+     * Pending ACK promises for subscription registration.
+     * subscriptionId → { resolve, reject, timeout, startTime }
+     */
+    this.pendingAcks = /* @__PURE__ */ new Map();
+    this.clusterManager = clusterManager;
+    this.localQueryRegistry = queryRegistry;
+    this.localSearchCoordinator = searchCoordinator;
+    this.config = { ...DEFAULT_CONFIG7, ...config };
+    this.rrf = new import_core21.ReciprocalRankFusion({ k: this.config.rrfK });
+    this.metricsService = metricsService;
+    this.clusterManager.on("message", this.handleClusterMessage.bind(this));
+    this.localSearchCoordinator.on("distributedUpdate", this.handleLocalSearchUpdate.bind(this));
+    this.clusterManager.on("memberLeft", this.handleMemberLeft.bind(this));
+    logger.debug("DistributedSubscriptionCoordinator initialized");
+  }
+  /**
+   * Create a new distributed search subscription.
+   *
+   * @param subscriptionId - Unique subscription ID
+   * @param clientSocket - Client WebSocket for sending updates
+   * @param mapName - Map name to search
+   * @param query - Search query string
+   * @param options - Search options
+   * @returns Promise resolving to initial results
+   */
+  async subscribeSearch(subscriptionId, clientSocket, mapName, query, options = {}) {
+    const myNodeId = this.clusterManager.config.nodeId;
+    const allNodes = new Set(this.clusterManager.getMembers());
+    logger.debug(
+      { subscriptionId, mapName, query, nodes: Array.from(allNodes) },
+      "Creating distributed search subscription"
+    );
+    const subscription = {
+      id: subscriptionId,
+      type: "SEARCH",
+      coordinatorNodeId: myNodeId,
+      clientSocket,
+      mapName,
+      searchQuery: query,
+      searchOptions: options,
+      registeredNodes: /* @__PURE__ */ new Set(),
+      pendingResults: /* @__PURE__ */ new Map(),
+      createdAt: Date.now(),
+      currentResults: /* @__PURE__ */ new Map()
+    };
+    this.subscriptions.set(subscriptionId, subscription);
+    this.nodeAcks.set(subscriptionId, /* @__PURE__ */ new Set());
+    const registerPayload = {
+      subscriptionId,
+      coordinatorNodeId: myNodeId,
+      mapName,
+      type: "SEARCH",
+      searchQuery: query,
+      searchOptions: {
+        limit: options.limit,
+        minScore: options.minScore,
+        boost: options.boost
+      }
+    };
+    const localResult = this.registerLocalSearchSubscription(subscription);
+    this.handleLocalAck(subscriptionId, myNodeId, localResult);
+    for (const nodeId of allNodes) {
+      if (nodeId !== myNodeId) {
+        this.clusterManager.send(nodeId, "CLUSTER_SUB_REGISTER", registerPayload);
+      }
+    }
+    return this.waitForAcks(subscriptionId, allNodes);
+  }
+  /**
+   * Create a new distributed query subscription.
+   *
+   * @param subscriptionId - Unique subscription ID
+   * @param clientSocket - Client WebSocket for sending updates
+   * @param mapName - Map name to query
+   * @param query - Query predicate
+   * @returns Promise resolving to initial results
+   */
+  async subscribeQuery(subscriptionId, clientSocket, mapName, query) {
+    const myNodeId = this.clusterManager.config.nodeId;
+    const allNodes = new Set(this.clusterManager.getMembers());
+    logger.debug(
+      { subscriptionId, mapName, nodes: Array.from(allNodes) },
+      "Creating distributed query subscription"
+    );
+    const subscription = {
+      id: subscriptionId,
+      type: "QUERY",
+      coordinatorNodeId: myNodeId,
+      clientSocket,
+      mapName,
+      queryPredicate: query,
+      registeredNodes: /* @__PURE__ */ new Set(),
+      pendingResults: /* @__PURE__ */ new Map(),
+      createdAt: Date.now(),
+      currentResults: /* @__PURE__ */ new Map()
+    };
+    this.subscriptions.set(subscriptionId, subscription);
+    this.nodeAcks.set(subscriptionId, /* @__PURE__ */ new Set());
+    const registerPayload = {
+      subscriptionId,
+      coordinatorNodeId: myNodeId,
+      mapName,
+      type: "QUERY",
+      queryPredicate: query
+    };
+    const localResults = this.registerLocalQuerySubscription(subscription);
+    this.handleLocalAck(subscriptionId, myNodeId, { results: localResults, totalHits: localResults.length });
+    for (const nodeId of allNodes) {
+      if (nodeId !== myNodeId) {
+        this.clusterManager.send(nodeId, "CLUSTER_SUB_REGISTER", registerPayload);
+      }
+    }
+    return this.waitForAcks(subscriptionId, allNodes);
+  }
+  /**
+   * Unsubscribe from a distributed subscription.
+   *
+   * @param subscriptionId - Subscription ID to unsubscribe
+   */
+  async unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      logger.warn({ subscriptionId }, "Attempt to unsubscribe from unknown subscription");
+      return;
+    }
+    logger.debug({ subscriptionId }, "Unsubscribing from distributed subscription");
+    const myNodeId = this.clusterManager.config.nodeId;
+    const payload = { subscriptionId };
+    for (const nodeId of subscription.registeredNodes) {
+      if (nodeId !== myNodeId) {
+        this.clusterManager.send(nodeId, "CLUSTER_SUB_UNREGISTER", payload);
+      }
+    }
+    this.unregisterLocalSubscription(subscription);
+    this.subscriptions.delete(subscriptionId);
+    this.nodeAcks.delete(subscriptionId);
+    const pendingAck = this.pendingAcks.get(subscriptionId);
+    if (pendingAck) {
+      clearTimeout(pendingAck.timeoutHandle);
+      this.pendingAcks.delete(subscriptionId);
+    }
+    this.metricsService?.incDistributedSubUnsubscribe(subscription.type);
+    this.metricsService?.decDistributedSubActive(subscription.type);
+    this.metricsService?.setDistributedSubPendingAcks(this.pendingAcks.size);
+  }
+  /**
+   * Handle client disconnect - unsubscribe all their subscriptions.
+   */
+  unsubscribeClient(clientSocket) {
+    const subscriptionsToRemove = [];
+    for (const [subId, sub] of this.subscriptions) {
+      if (sub.clientSocket === clientSocket) {
+        subscriptionsToRemove.push(subId);
+      }
+    }
+    for (const subId of subscriptionsToRemove) {
+      this.unsubscribe(subId);
+    }
+  }
+  /**
+   * Get active subscription count.
+   */
+  getActiveSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Handle incoming cluster messages with Zod validation.
+   */
+  handleClusterMessage(msg) {
+    switch (msg.type) {
+      case "CLUSTER_SUB_REGISTER": {
+        const parsed = import_core21.ClusterSubRegisterPayloadSchema.safeParse(msg.payload);
+        if (!parsed.success) {
+          logger.warn(
+            { senderId: msg.senderId, error: parsed.error.message },
+            "Invalid CLUSTER_SUB_REGISTER payload"
+          );
+          return;
+        }
+        this.handleSubRegister(msg.senderId, parsed.data);
+        break;
+      }
+      case "CLUSTER_SUB_ACK": {
+        const parsed = import_core21.ClusterSubAckPayloadSchema.safeParse(msg.payload);
+        if (!parsed.success) {
+          logger.warn(
+            { senderId: msg.senderId, error: parsed.error.message },
+            "Invalid CLUSTER_SUB_ACK payload"
+          );
+          return;
+        }
+        this.handleSubAck(msg.senderId, parsed.data);
+        break;
+      }
+      case "CLUSTER_SUB_UPDATE": {
+        const parsed = import_core21.ClusterSubUpdatePayloadSchema.safeParse(msg.payload);
+        if (!parsed.success) {
+          logger.warn(
+            { senderId: msg.senderId, error: parsed.error.message },
+            "Invalid CLUSTER_SUB_UPDATE payload"
+          );
+          return;
+        }
+        this.handleSubUpdate(msg.senderId, parsed.data);
+        break;
+      }
+      case "CLUSTER_SUB_UNREGISTER": {
+        const parsed = import_core21.ClusterSubUnregisterPayloadSchema.safeParse(msg.payload);
+        if (!parsed.success) {
+          logger.warn(
+            { senderId: msg.senderId, error: parsed.error.message },
+            "Invalid CLUSTER_SUB_UNREGISTER payload"
+          );
+          return;
+        }
+        this.handleSubUnregister(msg.senderId, parsed.data);
+        break;
+      }
+    }
+  }
+  /**
+   * Handle cluster node disconnect - cleanup subscriptions involving this node.
+   */
+  handleMemberLeft(nodeId) {
+    logger.debug({ nodeId }, "Handling member left for distributed subscriptions");
+    const subscriptionsToRemove = [];
+    const myNodeId = this.clusterManager.config.nodeId;
+    for (const [subId, subscription] of this.subscriptions) {
+      if (subscription.registeredNodes.has(nodeId)) {
+        subscription.registeredNodes.delete(nodeId);
+        for (const [key, result] of subscription.currentResults) {
+          if (result.sourceNode === nodeId) {
+            subscription.currentResults.delete(key);
+          }
+        }
+        logger.debug(
+          { subscriptionId: subId, nodeId, remainingNodes: subscription.registeredNodes.size },
+          "Removed disconnected node from subscription"
+        );
+      }
+    }
+    for (const [subId, pending] of this.pendingAcks) {
+      const acks = this.nodeAcks.get(subId);
+      if (acks && !acks.has(nodeId)) {
+        acks.add(nodeId);
+        this.checkAcksComplete(subId);
+      }
+    }
+    this.localSearchCoordinator.unsubscribeByCoordinator(nodeId);
+    this.localQueryRegistry.unregisterByCoordinator(nodeId);
+    this.metricsService?.incDistributedSubNodeDisconnect();
+  }
+  /**
+   * Handle CLUSTER_SUB_REGISTER from coordinator (we are a data node).
+   */
+  handleSubRegister(senderId, payload) {
+    const myNodeId = this.clusterManager.config.nodeId;
+    logger.debug(
+      { subscriptionId: payload.subscriptionId, coordinator: payload.coordinatorNodeId },
+      "Received distributed subscription registration"
+    );
+    let ackPayload;
+    try {
+      if (payload.type === "SEARCH") {
+        const result = this.localSearchCoordinator.registerDistributedSubscription(
+          payload.subscriptionId,
+          payload.mapName,
+          payload.searchQuery,
+          payload.searchOptions || {},
+          payload.coordinatorNodeId
+        );
+        ackPayload = {
+          subscriptionId: payload.subscriptionId,
+          nodeId: myNodeId,
+          success: true,
+          initialResults: result.results.map((r) => ({
+            key: r.key,
+            value: r.value,
+            score: r.score,
+            matchedTerms: r.matchedTerms
+          })),
+          totalHits: result.totalHits
+        };
+      } else {
+        const results = this.localQueryRegistry.registerDistributed(
+          payload.subscriptionId,
+          payload.mapName,
+          payload.queryPredicate,
+          payload.coordinatorNodeId
+        );
+        ackPayload = {
+          subscriptionId: payload.subscriptionId,
+          nodeId: myNodeId,
+          success: true,
+          initialResults: results.map((r) => ({
+            key: r.key,
+            value: r.value
+          })),
+          totalHits: results.length
+        };
+      }
+    } catch (error) {
+      logger.error(
+        { subscriptionId: payload.subscriptionId, error },
+        "Failed to register distributed subscription locally"
+      );
+      ackPayload = {
+        subscriptionId: payload.subscriptionId,
+        nodeId: myNodeId,
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+    this.clusterManager.send(payload.coordinatorNodeId, "CLUSTER_SUB_ACK", ackPayload);
+  }
+  /**
+   * Handle CLUSTER_SUB_ACK from a data node.
+   */
+  handleSubAck(senderId, payload) {
+    const subscription = this.subscriptions.get(payload.subscriptionId);
+    if (!subscription) {
+      logger.warn(
+        { subscriptionId: payload.subscriptionId, nodeId: payload.nodeId },
+        "Received ACK for unknown subscription"
+      );
+      return;
+    }
+    const acks = this.nodeAcks.get(payload.subscriptionId);
+    if (!acks) return;
+    logger.debug(
+      { subscriptionId: payload.subscriptionId, nodeId: payload.nodeId, success: payload.success },
+      "Received subscription ACK"
+    );
+    if (payload.success) {
+      subscription.registeredNodes.add(payload.nodeId);
+      subscription.pendingResults.set(payload.nodeId, payload);
+    }
+    acks.add(payload.nodeId);
+    this.checkAcksComplete(payload.subscriptionId);
+  }
+  /**
+   * Handle CLUSTER_SUB_UPDATE from a data node.
+   */
+  handleSubUpdate(senderId, payload) {
+    const subscription = this.subscriptions.get(payload.subscriptionId);
+    if (!subscription) {
+      logger.warn(
+        { subscriptionId: payload.subscriptionId },
+        "Update for unknown subscription"
+      );
+      return;
+    }
+    logger.debug(
+      { subscriptionId: payload.subscriptionId, key: payload.key, changeType: payload.changeType },
+      "Received subscription update"
+    );
+    if (payload.changeType === "LEAVE") {
+      subscription.currentResults.delete(payload.key);
+    } else {
+      subscription.currentResults.set(payload.key, {
+        value: payload.value,
+        score: payload.score,
+        sourceNode: payload.sourceNodeId
+      });
+    }
+    this.forwardUpdateToClient(subscription, payload);
+    this.metricsService?.incDistributedSubUpdates("received", payload.changeType);
+    if (payload.timestamp) {
+      const latencyMs = Date.now() - payload.timestamp;
+      this.metricsService?.recordDistributedSubUpdateLatency(subscription.type, latencyMs);
+    }
+  }
+  /**
+   * Handle CLUSTER_SUB_UNREGISTER from coordinator.
+   */
+  handleSubUnregister(senderId, payload) {
+    logger.debug(
+      { subscriptionId: payload.subscriptionId },
+      "Received subscription unregister request"
+    );
+    this.localSearchCoordinator.unsubscribe(payload.subscriptionId);
+    this.localQueryRegistry.unregister(payload.subscriptionId);
+  }
+  /**
+   * Handle local search update (emitted by SearchCoordinator for distributed subscriptions).
+   */
+  handleLocalSearchUpdate(payload) {
+    const coordinatorNodeId = this.getCoordinatorForSubscription(payload.subscriptionId);
+    if (!coordinatorNodeId) return;
+    const myNodeId = this.clusterManager.config.nodeId;
+    if (coordinatorNodeId === myNodeId) {
+      this.handleSubUpdate(myNodeId, payload);
+    } else {
+      this.clusterManager.send(coordinatorNodeId, "CLUSTER_SUB_UPDATE", payload);
+    }
+    this.metricsService?.incDistributedSubUpdates("sent", payload.changeType);
+  }
+  /**
+   * Register a local search subscription for a distributed coordinator.
+   */
+  registerLocalSearchSubscription(subscription) {
+    return this.localSearchCoordinator.registerDistributedSubscription(
+      subscription.id,
+      subscription.mapName,
+      subscription.searchQuery,
+      subscription.searchOptions || {},
+      subscription.coordinatorNodeId
+    );
+  }
+  /**
+   * Register a local query subscription for a distributed coordinator.
+   */
+  registerLocalQuerySubscription(subscription) {
+    return this.localQueryRegistry.registerDistributed(
+      subscription.id,
+      subscription.mapName,
+      subscription.queryPredicate,
+      subscription.coordinatorNodeId
+    );
+  }
+  /**
+   * Unregister local subscription.
+   */
+  unregisterLocalSubscription(subscription) {
+    if (subscription.type === "SEARCH") {
+      this.localSearchCoordinator.unsubscribe(subscription.id);
+    } else {
+      this.localQueryRegistry.unregister(subscription.id);
+    }
+  }
+  /**
+   * Handle local ACK (from this node's registration).
+   */
+  handleLocalAck(subscriptionId, nodeId, result) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) return;
+    const acks = this.nodeAcks.get(subscriptionId);
+    if (!acks) return;
+    subscription.registeredNodes.add(nodeId);
+    subscription.pendingResults.set(nodeId, {
+      subscriptionId,
+      nodeId,
+      success: true,
+      initialResults: (result.results || []).map((r) => ({
+        key: r.key,
+        value: r.value,
+        score: r.score,
+        matchedTerms: r.matchedTerms
+      })),
+      totalHits: result.totalHits || (result.results?.length ?? 0)
+    });
+    acks.add(nodeId);
+    this.checkAcksComplete(subscriptionId);
+  }
+  /**
+   * Wait for all node ACKs with timeout.
+   */
+  waitForAcks(subscriptionId, expectedNodes) {
+    return new Promise((resolve, reject) => {
+      const startTime = performance.now();
+      const timeoutHandle = setTimeout(() => {
+        this.resolveWithPartialAcks(subscriptionId);
+      }, this.config.ackTimeoutMs);
+      this.pendingAcks.set(subscriptionId, { resolve, reject, timeoutHandle, startTime });
+      this.metricsService?.setDistributedSubPendingAcks(this.pendingAcks.size);
+      this.checkAcksComplete(subscriptionId);
+    });
+  }
+  /**
+   * Check if all ACKs have been received.
+   */
+  checkAcksComplete(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    const acks = this.nodeAcks.get(subscriptionId);
+    const pendingAck = this.pendingAcks.get(subscriptionId);
+    if (!subscription || !acks || !pendingAck) return;
+    const allNodes = new Set(this.clusterManager.getMembers());
+    if (acks.size >= allNodes.size) {
+      clearTimeout(pendingAck.timeoutHandle);
+      this.pendingAcks.delete(subscriptionId);
+      const duration = performance.now() - pendingAck.startTime;
+      const result = this.mergeInitialResults(subscription);
+      const hasFailures = result.failedNodes.length > 0;
+      this.recordCompletionMetrics(
+        subscription,
+        result,
+        duration,
+        hasFailures ? "timeout" : "success"
+      );
+      pendingAck.resolve(result);
+    }
+  }
+  /**
+   * Resolve with partial ACKs (on timeout).
+   */
+  resolveWithPartialAcks(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    const pendingAck = this.pendingAcks.get(subscriptionId);
+    if (!subscription || !pendingAck) return;
+    this.pendingAcks.delete(subscriptionId);
+    logger.warn(
+      { subscriptionId, registeredNodes: Array.from(subscription.registeredNodes) },
+      "Subscription ACK timeout, resolving with partial results"
+    );
+    const duration = performance.now() - pendingAck.startTime;
+    const result = this.mergeInitialResults(subscription);
+    this.recordCompletionMetrics(subscription, result, duration, "timeout");
+    pendingAck.resolve(result);
+  }
+  /**
+   * Record metrics when subscription registration completes.
+   */
+  recordCompletionMetrics(subscription, result, durationMs, status) {
+    this.metricsService?.incDistributedSub(subscription.type, status);
+    this.metricsService?.recordDistributedSubRegistration(subscription.type, durationMs);
+    this.metricsService?.recordDistributedSubInitialResultsCount(subscription.type, result.results.length);
+    this.metricsService?.setDistributedSubPendingAcks(this.pendingAcks.size);
+    this.metricsService?.incDistributedSubAck("success", subscription.registeredNodes.size);
+    this.metricsService?.incDistributedSubAck("timeout", result.failedNodes.length);
+  }
+  /**
+   * Merge initial results from all nodes.
+   */
+  mergeInitialResults(subscription) {
+    const allNodes = new Set(this.clusterManager.getMembers());
+    const failedNodes = Array.from(allNodes).filter((n) => !subscription.registeredNodes.has(n));
+    if (subscription.type === "SEARCH") {
+      return this.mergeSearchResults(subscription, failedNodes);
+    } else {
+      return this.mergeQueryResults(subscription, failedNodes);
+    }
+  }
+  /**
+   * Merge search results using RRF.
+   */
+  mergeSearchResults(subscription, failedNodes) {
+    const resultSets = [];
+    const resultDataMap = /* @__PURE__ */ new Map();
+    for (const [nodeId, ack] of subscription.pendingResults) {
+      if (ack.success && ack.initialResults) {
+        const rankedResults = [];
+        for (const r of ack.initialResults) {
+          rankedResults.push({
+            docId: r.key,
+            score: r.score ?? 0,
+            source: nodeId
+          });
+          if (!resultDataMap.has(r.key)) {
+            resultDataMap.set(r.key, {
+              key: r.key,
+              value: r.value,
+              score: r.score ?? 0,
+              matchedTerms: r.matchedTerms,
+              nodeId
+            });
+          }
+        }
+        if (rankedResults.length > 0) {
+          resultSets.push(rankedResults);
+        }
+      }
+    }
+    const mergedResults = this.rrf.merge(resultSets);
+    const limit = subscription.searchOptions?.limit ?? 10;
+    const results = [];
+    for (const merged of mergedResults.slice(0, limit)) {
+      const original = resultDataMap.get(merged.docId);
+      if (original) {
+        results.push({
+          key: original.key,
+          value: original.value,
+          score: merged.score,
+          // Use RRF score
+          matchedTerms: original.matchedTerms
+        });
+        subscription.currentResults.set(original.key, {
+          value: original.value,
+          score: merged.score,
+          sourceNode: original.nodeId
+        });
+      }
+    }
+    let totalHits = 0;
+    for (const ack of subscription.pendingResults.values()) {
+      totalHits += ack.totalHits ?? 0;
+    }
+    return {
+      subscriptionId: subscription.id,
+      results,
+      totalHits,
+      registeredNodes: Array.from(subscription.registeredNodes),
+      failedNodes
+    };
+  }
+  /**
+   * Merge query results (simple dedupe by key).
+   */
+  mergeQueryResults(subscription, failedNodes) {
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const [nodeId, ack] of subscription.pendingResults) {
+      if (ack.success && ack.initialResults) {
+        for (const result of ack.initialResults) {
+          if (!resultMap.has(result.key)) {
+            resultMap.set(result.key, { key: result.key, value: result.value });
+            subscription.currentResults.set(result.key, {
+              value: result.value,
+              sourceNode: nodeId
+            });
+          }
+        }
+      }
+    }
+    const results = Array.from(resultMap.values());
+    return {
+      subscriptionId: subscription.id,
+      results,
+      totalHits: results.length,
+      registeredNodes: Array.from(subscription.registeredNodes),
+      failedNodes
+    };
+  }
+  /**
+   * Forward update to client WebSocket.
+   */
+  forwardUpdateToClient(subscription, payload) {
+    if (subscription.clientSocket.readyState !== import_ws4.WebSocket.OPEN) {
+      logger.warn(
+        { subscriptionId: subscription.id },
+        "Cannot forward update, client socket not open"
+      );
+      return;
+    }
+    const message = subscription.type === "SEARCH" ? {
+      type: "SEARCH_UPDATE",
+      payload: {
+        subscriptionId: payload.subscriptionId,
+        key: payload.key,
+        value: payload.value,
+        score: payload.score,
+        matchedTerms: payload.matchedTerms,
+        type: payload.changeType
+      }
+    } : {
+      type: "QUERY_UPDATE",
+      payload: {
+        queryId: payload.subscriptionId,
+        key: payload.key,
+        value: payload.value,
+        type: payload.changeType
+      }
+    };
+    try {
+      subscription.clientSocket.send(JSON.stringify(message));
+    } catch (error) {
+      logger.error(
+        { subscriptionId: subscription.id, error },
+        "Failed to send update to client"
+      );
+    }
+  }
+  /**
+   * Get coordinator node for a subscription.
+   * For remote subscriptions (where we are a data node), this returns the coordinator.
+   */
+  getCoordinatorForSubscription(subscriptionId) {
+    if (this.subscriptions.has(subscriptionId)) {
+      return this.clusterManager.config.nodeId;
+    }
+    const searchSub = this.localSearchCoordinator.getDistributedSubscription(subscriptionId);
+    if (searchSub?.coordinatorNodeId) {
+      return searchSub.coordinatorNodeId;
+    }
+    const querySub = this.localQueryRegistry.getDistributedSubscription(subscriptionId);
+    if (querySub?.coordinatorNodeId) {
+      return querySub.coordinatorNodeId;
+    }
+    return null;
+  }
+  /**
+   * Cleanup on destroy.
+   */
+  destroy() {
+    for (const subscriptionId of this.subscriptions.keys()) {
+      this.unsubscribe(subscriptionId);
+    }
+    for (const pending of this.pendingAcks.values()) {
+      clearTimeout(pending.timeoutHandle);
+    }
+    this.pendingAcks.clear();
+    this.removeAllListeners();
+  }
+};
+
+// src/ServerCoordinator.ts
+var GC_INTERVAL_MS = 60 * 60 * 1e3;
+var GC_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
+var CLIENT_HEARTBEAT_TIMEOUT_MS = 2e4;
+var CLIENT_HEARTBEAT_CHECK_INTERVAL_MS = 5e3;
+var ServerCoordinator = class {
+  constructor(config) {
+    this.clients = /* @__PURE__ */ new Map();
+    // Interceptors
+    this.interceptors = [];
+    // In-memory storage (partitioned later)
+    this.maps = /* @__PURE__ */ new Map();
+    this.pendingClusterQueries = /* @__PURE__ */ new Map();
+    // GC Consensus State
+    this.gcReports = /* @__PURE__ */ new Map();
+    // Track map loading state to avoid returning empty results during async load
+    this.mapLoadingPromises = /* @__PURE__ */ new Map();
+    // Track pending batch operations for testing purposes
+    this.pendingBatchOperations = /* @__PURE__ */ new Set();
+    this.journalSubscriptions = /* @__PURE__ */ new Map();
+    this._actualPort = 0;
+    this._actualClusterPort = 0;
+    this._readyPromise = new Promise((resolve) => {
+      this._readyResolve = resolve;
+    });
+    this._nodeId = config.nodeId;
+    this.hlc = new import_core22.HLC(config.nodeId);
+    this.storage = config.storage;
+    const rawSecret = config.jwtSecret || process.env.JWT_SECRET || "topgun-secret-dev";
+    this.jwtSecret = rawSecret.replace(/\\n/g, "\n");
+    this.queryRegistry = new QueryRegistry();
     this.securityManager = new SecurityManager(config.securityPolicies || []);
     this.interceptors = config.interceptors || [];
     this.metricsService = new MetricsService();
@@ -9930,7 +11605,7 @@ var ServerCoordinator = class {
     this.metricsServer.on("error", (err) => {
       logger.error({ err, port: metricsPort }, "Metrics server failed to start");
     });
-    this.wss = new import_ws3.WebSocketServer({
+    this.wss = new import_ws5.WebSocketServer({
       server: this.httpServer,
       // Increase backlog for pending connections (default Linux is 128)
       backlog: config.wsBacklog ?? 511,
@@ -9972,8 +11647,8 @@ var ServerCoordinator = class {
           this.cluster,
           this.partitionService,
           {
-            ...import_core20.DEFAULT_REPLICATION_CONFIG,
-            defaultConsistency: config.defaultConsistency ?? import_core20.ConsistencyLevel.EVENTUAL,
+            ...import_core22.DEFAULT_REPLICATION_CONFIG,
+            defaultConsistency: config.defaultConsistency ?? import_core22.ConsistencyLevel.EVENTUAL,
             ...config.replicationConfig
           }
         );
@@ -9989,7 +11664,7 @@ var ServerCoordinator = class {
         cluster: this.cluster,
         sendToClient: (clientId, message) => {
           const client = this.clients.get(clientId);
-          if (client && client.socket.readyState === import_ws3.WebSocket.OPEN) {
+          if (client && client.socket.readyState === import_ws5.WebSocket.OPEN) {
             client.writer.write(message);
           }
         }
@@ -10036,7 +11711,7 @@ var ServerCoordinator = class {
         void 0,
         // LagTracker - can be added later
         {
-          defaultConsistency: config.defaultConsistency ?? import_core20.ConsistencyLevel.STRONG,
+          defaultConsistency: config.defaultConsistency ?? import_core22.ConsistencyLevel.STRONG,
           preferLocalReplica: true,
           loadBalancing: "latency-based"
         }
@@ -10089,6 +11764,26 @@ var ServerCoordinator = class {
           logger.info({ mapName, fields: ftsConfig.fields }, "FTS enabled for map");
         }
       }
+      this.clusterSearchCoordinator = new ClusterSearchCoordinator(
+        this.cluster,
+        this.partitionService,
+        this.searchCoordinator,
+        config.distributedSearch,
+        this.metricsService
+      );
+      logger.info("ClusterSearchCoordinator initialized for distributed search");
+      this.distributedSubCoordinator = new DistributedSubscriptionCoordinator(
+        this.cluster,
+        this.queryRegistry,
+        this.searchCoordinator,
+        void 0,
+        // Use default config
+        this.metricsService
+      );
+      logger.info("DistributedSubscriptionCoordinator initialized for distributed live subscriptions");
+      this.searchCoordinator.setNodeId(config.nodeId);
+      this.queryRegistry.setClusterManager(this.cluster, config.nodeId);
+      this.queryRegistry.setMapGetter((name) => this.getMap(name));
       this.systemManager = new SystemManager(
         this.cluster,
         this.metricsService,
@@ -10131,7 +11826,7 @@ var ServerCoordinator = class {
         await this.getMapAsync(mapName);
         const map = this.maps.get(mapName);
         if (!map) return;
-        if (map instanceof import_core20.LWWMap) {
+        if (map instanceof import_core22.LWWMap) {
           const entries = Array.from(map.entries());
           if (entries.length > 0) {
             logger.info({ mapName, count: entries.length }, "Backfilling FTS index");
@@ -10229,11 +11924,11 @@ var ServerCoordinator = class {
     const map = this.maps.get(mapName);
     if (map) {
       const entries = [];
-      if (map instanceof import_core20.LWWMap) {
+      if (map instanceof import_core22.LWWMap) {
         for (const [key, value] of map.entries()) {
           entries.push([key, value]);
         }
-      } else if (map instanceof import_core20.ORMap) {
+      } else if (map instanceof import_core22.ORMap) {
         for (const key of map.allKeys()) {
           const values = map.get(key);
           const value = values.length > 0 ? values[0] : null;
@@ -10354,10 +12049,10 @@ var ServerCoordinator = class {
     this.metricsService.destroy();
     this.wss.close();
     logger.info(`Closing ${this.clients.size} client connections...`);
-    const shutdownMsg = (0, import_core20.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
+    const shutdownMsg = (0, import_core22.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.clients.values()) {
       try {
-        if (client.socket.readyState === import_ws3.WebSocket.OPEN) {
+        if (client.socket.readyState === import_ws5.WebSocket.OPEN) {
           client.socket.send(shutdownMsg);
           if (client.writer) {
             client.writer.close();
@@ -10420,6 +12115,12 @@ var ServerCoordinator = class {
     if (this.eventJournalService) {
       this.eventJournalService.dispose();
     }
+    if (this.clusterSearchCoordinator) {
+      this.clusterSearchCoordinator.destroy();
+    }
+    if (this.distributedSubCoordinator) {
+      this.distributedSubCoordinator.destroy();
+    }
     logger.info("Server Coordinator shutdown complete.");
   }
   async handleConnection(ws) {
@@ -10487,7 +12188,7 @@ var ServerCoordinator = class {
           buf = Buffer.from(message);
         }
         try {
-          data = (0, import_core20.deserialize)(buf);
+          data = (0, import_core22.deserialize)(buf);
         } catch (e) {
           try {
             const text = Buffer.isBuffer(buf) ? buf.toString() : new TextDecoder().decode(buf);
@@ -10528,6 +12229,9 @@ var ServerCoordinator = class {
       this.topicManager.unsubscribeAll(clientId);
       this.counterHandler.unsubscribeAll(clientId);
       this.searchCoordinator.unsubscribeClient(clientId);
+      if (this.distributedSubCoordinator && connection) {
+        this.distributedSubCoordinator.unsubscribeClient(connection.socket);
+      }
       const members = this.cluster.getMembers();
       for (const memberId of members) {
         if (!this.cluster.isLocal(memberId)) {
@@ -10540,10 +12244,10 @@ var ServerCoordinator = class {
       this.clients.delete(clientId);
       this.metricsService.setConnectedClients(this.clients.size);
     });
-    ws.send((0, import_core20.serialize)({ type: "AUTH_REQUIRED" }));
+    ws.send((0, import_core22.serialize)({ type: "AUTH_REQUIRED" }));
   }
   async handleMessage(client, rawMessage) {
-    const parseResult = import_core20.MessageSchema.safeParse(rawMessage);
+    const parseResult = import_core22.MessageSchema.safeParse(rawMessage);
     if (!parseResult.success) {
       logger.error({ clientId: client.id, error: parseResult.error }, "Invalid message format from client");
       client.writer.write({
@@ -10602,70 +12306,115 @@ var ServerCoordinator = class {
         }
         logger.info({ clientId: client.id, mapName, query }, "Client subscribed");
         this.metricsService.incOp("SUBSCRIBE", mapName);
-        const allMembers = this.cluster.getMembers();
-        let remoteMembers = allMembers.filter((id) => !this.cluster.isLocal(id));
-        const queryKey = query._id || query.where?._id;
-        if (queryKey && typeof queryKey === "string" && this.readReplicaHandler) {
-          try {
-            const targetNode = this.readReplicaHandler.selectReadNode({
+        if (this.distributedSubCoordinator && this.cluster && this.cluster.getMembers().length > 1) {
+          this.distributedSubCoordinator.subscribeQuery(
+            queryId,
+            client.socket,
+            mapName,
+            query
+          ).then((result) => {
+            const filteredResults = result.results.map((res) => {
+              const filteredValue = this.securityManager.filterObject(res.value, client.principal, mapName);
+              return { ...res, value: filteredValue };
+            });
+            client.writer.write({
+              type: "QUERY_RESP",
+              payload: {
+                queryId,
+                results: filteredResults
+              }
+            });
+            client.subscriptions.add(queryId);
+            logger.debug({
+              clientId: client.id,
+              queryId,
               mapName,
-              key: queryKey,
-              options: {
-                // Default to EVENTUAL for read scaling unless specified otherwise
-                // In future, we could extract consistency from query options if available
-                consistency: import_core20.ConsistencyLevel.EVENTUAL
+              resultCount: result.results.length,
+              totalHits: result.totalHits,
+              nodes: result.registeredNodes
+            }, "Distributed query subscription created");
+          }).catch((err) => {
+            logger.error({ err, queryId }, "Distributed query subscription failed");
+            client.writer.write({
+              type: "QUERY_RESP",
+              payload: {
+                queryId,
+                results: [],
+                error: "Failed to create distributed subscription"
               }
             });
-            if (targetNode) {
-              if (this.cluster.isLocal(targetNode)) {
-                remoteMembers = [];
-                logger.debug({ clientId: client.id, mapName, key: queryKey }, "Read optimization: Serving locally");
-              } else if (remoteMembers.includes(targetNode)) {
-                remoteMembers = [targetNode];
-                logger.debug({ clientId: client.id, mapName, key: queryKey, targetNode }, "Read optimization: Routing to replica");
+          });
+        } else {
+          const allMembers = this.cluster.getMembers();
+          let remoteMembers = allMembers.filter((id) => !this.cluster.isLocal(id));
+          const queryKey = query._id || query.where?._id;
+          if (queryKey && typeof queryKey === "string" && this.readReplicaHandler) {
+            try {
+              const targetNode = this.readReplicaHandler.selectReadNode({
+                mapName,
+                key: queryKey,
+                options: {
+                  // Default to EVENTUAL for read scaling unless specified otherwise
+                  // In future, we could extract consistency from query options if available
+                  consistency: import_core22.ConsistencyLevel.EVENTUAL
+                }
+              });
+              if (targetNode) {
+                if (this.cluster.isLocal(targetNode)) {
+                  remoteMembers = [];
+                  logger.debug({ clientId: client.id, mapName, key: queryKey }, "Read optimization: Serving locally");
+                } else if (remoteMembers.includes(targetNode)) {
+                  remoteMembers = [targetNode];
+                  logger.debug({ clientId: client.id, mapName, key: queryKey, targetNode }, "Read optimization: Routing to replica");
+                }
               }
+            } catch (e) {
+              logger.warn({ err: e }, "Error in ReadReplicaHandler selection");
             }
-          } catch (e) {
-            logger.warn({ err: e }, "Error in ReadReplicaHandler selection");
           }
-        }
-        const requestId = crypto.randomUUID();
-        const pending = {
-          requestId,
-          client,
-          queryId,
-          mapName,
-          query,
-          results: [],
-          // Will populate with local results first
-          expectedNodes: new Set(remoteMembers),
-          respondedNodes: /* @__PURE__ */ new Set(),
-          timer: setTimeout(() => this.finalizeClusterQuery(requestId, true), 5e3)
-          // 5s timeout
-        };
-        this.pendingClusterQueries.set(requestId, pending);
-        try {
-          const localResults = await this.executeLocalQuery(mapName, query);
-          pending.results.push(...localResults);
-          if (remoteMembers.length > 0) {
-            for (const nodeId of remoteMembers) {
-              this.cluster.send(nodeId, "CLUSTER_QUERY_EXEC", {
-                requestId,
-                mapName,
-                query
-              });
+          const requestId = crypto.randomUUID();
+          const pending = {
+            requestId,
+            client,
+            queryId,
+            mapName,
+            query,
+            results: [],
+            // Will populate with local results first
+            expectedNodes: new Set(remoteMembers),
+            respondedNodes: /* @__PURE__ */ new Set(),
+            timer: setTimeout(() => this.finalizeClusterQuery(requestId, true), 5e3)
+            // 5s timeout
+          };
+          this.pendingClusterQueries.set(requestId, pending);
+          try {
+            const localResults = await this.executeLocalQuery(mapName, query);
+            pending.results.push(...localResults);
+            if (remoteMembers.length > 0) {
+              for (const nodeId of remoteMembers) {
+                this.cluster.send(nodeId, "CLUSTER_QUERY_EXEC", {
+                  requestId,
+                  mapName,
+                  query
+                });
+              }
+            } else {
+              this.finalizeClusterQuery(requestId);
             }
-          } else {
+          } catch (err) {
+            logger.error({ err, mapName }, "Failed to execute local query");
             this.finalizeClusterQuery(requestId);
           }
-        } catch (err) {
-          logger.error({ err, mapName }, "Failed to execute local query");
-          this.finalizeClusterQuery(requestId);
         }
         break;
       }
       case "QUERY_UNSUB": {
         const { queryId: unsubId } = message.payload;
+        if (this.distributedSubCoordinator && this.cluster && this.cluster.getMembers().length > 1) {
+          this.distributedSubCoordinator.unsubscribe(unsubId).catch((err) => {
+            logger.warn({ err, queryId: unsubId }, "Failed to unsubscribe from distributed coordinator");
+          });
+        }
         this.queryRegistry.unregister(unsubId);
         client.subscriptions.delete(unsubId);
         break;
@@ -10808,7 +12557,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName);
-          if (mapForSync instanceof import_core20.LWWMap) {
+          if (mapForSync instanceof import_core22.LWWMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -10846,7 +12595,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName);
-          if (mapForBucket instanceof import_core20.LWWMap) {
+          if (mapForBucket instanceof import_core22.LWWMap) {
             const treeForBucket = mapForBucket.getMerkleTree();
             const buckets = treeForBucket.getBuckets(path);
             const node = treeForBucket.getNode(path);
@@ -10989,7 +12738,7 @@ var ServerCoordinator = class {
         client.writer.write(result.response);
         for (const targetClientId of result.broadcastTo) {
           const targetClient = this.clients.get(targetClientId);
-          if (targetClient && targetClient.socket.readyState === import_ws3.WebSocket.OPEN) {
+          if (targetClient && targetClient.socket.readyState === import_ws5.WebSocket.OPEN) {
             targetClient.writer.write(result.broadcastMessage);
           }
         }
@@ -11228,7 +12977,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName, "OR");
-          if (mapForSync instanceof import_core20.ORMap) {
+          if (mapForSync instanceof import_core22.ORMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -11265,7 +13014,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName, "OR");
-          if (mapForBucket instanceof import_core20.ORMap) {
+          if (mapForBucket instanceof import_core22.ORMap) {
             const tree = mapForBucket.getMerkleTree();
             const buckets = tree.getBuckets(path);
             const isLeaf = tree.isLeaf(path);
@@ -11309,7 +13058,7 @@ var ServerCoordinator = class {
         const { mapName: diffMapName, keys } = message.payload;
         try {
           const mapForDiff = await this.getMapAsync(diffMapName, "OR");
-          if (mapForDiff instanceof import_core20.ORMap) {
+          if (mapForDiff instanceof import_core22.ORMap) {
             const entries = [];
             const allTombstones = mapForDiff.getTombstones();
             for (const key of keys) {
@@ -11341,7 +13090,7 @@ var ServerCoordinator = class {
         const { mapName: pushMapName, entries: pushEntries } = message.payload;
         try {
           const mapForPush = await this.getMapAsync(pushMapName, "OR");
-          if (mapForPush instanceof import_core20.ORMap) {
+          if (mapForPush instanceof import_core22.ORMap) {
             let totalAdded = 0;
             let totalUpdated = 0;
             for (const entry of pushEntries) {
@@ -11469,7 +13218,7 @@ var ServerCoordinator = class {
         });
         break;
       }
-      // Phase 11.1: Full-Text Search
+      // Phase 11.1: Full-Text Search (Phase 14: Distributed Search)
       case "SEARCH": {
         const { requestId: searchReqId, mapName: searchMapName, query: searchQuery, options: searchOptions } = message.payload;
         if (!this.securityManager.checkPermission(client.principal, searchMapName, "READ")) {
@@ -11497,18 +13246,58 @@ var ServerCoordinator = class {
           });
           break;
         }
-        const searchResult = this.searchCoordinator.search(searchMapName, searchQuery, searchOptions);
-        searchResult.requestId = searchReqId;
-        logger.debug({
-          clientId: client.id,
-          mapName: searchMapName,
-          query: searchQuery,
-          resultCount: searchResult.results.length
-        }, "Search executed");
-        client.writer.write({
-          type: "SEARCH_RESP",
-          payload: searchResult
-        });
+        if (this.clusterSearchCoordinator && this.cluster.getMembers().length > 1) {
+          this.clusterSearchCoordinator.search(searchMapName, searchQuery, {
+            limit: searchOptions?.limit ?? 10,
+            minScore: searchOptions?.minScore,
+            boost: searchOptions?.boost
+          }).then((distributedResult) => {
+            logger.debug({
+              clientId: client.id,
+              mapName: searchMapName,
+              query: searchQuery,
+              resultCount: distributedResult.results.length,
+              totalHits: distributedResult.totalHits,
+              respondedNodes: distributedResult.respondedNodes.length,
+              failedNodes: distributedResult.failedNodes.length,
+              executionTimeMs: distributedResult.executionTimeMs
+            }, "Distributed search executed");
+            client.writer.write({
+              type: "SEARCH_RESP",
+              payload: {
+                requestId: searchReqId,
+                results: distributedResult.results,
+                totalCount: distributedResult.totalHits,
+                // Include cursor for pagination if available
+                nextCursor: distributedResult.nextCursor
+              }
+            });
+          }).catch((err) => {
+            logger.error({ err, mapName: searchMapName, query: searchQuery }, "Distributed search failed");
+            client.writer.write({
+              type: "SEARCH_RESP",
+              payload: {
+                requestId: searchReqId,
+                results: [],
+                totalCount: 0,
+                error: `Distributed search failed: ${err.message}`
+              }
+            });
+          });
+        } else {
+          const searchResult = this.searchCoordinator.search(searchMapName, searchQuery, searchOptions);
+          searchResult.requestId = searchReqId;
+          logger.debug({
+            clientId: client.id,
+            mapName: searchMapName,
+            query: searchQuery,
+            resultCount: searchResult.results.length
+          }, "Local search executed");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: searchResult
+          });
+        }
         break;
       }
       // Phase 11.1b: Live Search Subscriptions
@@ -11539,33 +13328,75 @@ var ServerCoordinator = class {
           });
           break;
         }
-        const initialResults = this.searchCoordinator.subscribe(
-          client.id,
-          subscriptionId,
-          subMapName,
-          subQuery,
-          subOptions
-        );
-        logger.debug({
-          clientId: client.id,
-          subscriptionId,
-          mapName: subMapName,
-          query: subQuery,
-          resultCount: initialResults.length
-        }, "Search subscription created");
-        client.writer.write({
-          type: "SEARCH_RESP",
-          payload: {
-            requestId: subscriptionId,
-            results: initialResults,
-            totalCount: initialResults.length
-          }
-        });
+        if (this.distributedSubCoordinator && this.cluster && this.cluster.getMembers().length > 1) {
+          this.distributedSubCoordinator.subscribeSearch(
+            subscriptionId,
+            client.socket,
+            subMapName,
+            subQuery,
+            subOptions || {}
+          ).then((result) => {
+            client.writer.write({
+              type: "SEARCH_RESP",
+              payload: {
+                requestId: subscriptionId,
+                results: result.results,
+                totalCount: result.totalHits
+              }
+            });
+            logger.debug({
+              clientId: client.id,
+              subscriptionId,
+              mapName: subMapName,
+              query: subQuery,
+              resultCount: result.results.length,
+              totalHits: result.totalHits,
+              nodes: result.registeredNodes
+            }, "Distributed search subscription created");
+          }).catch((err) => {
+            logger.error({ err, subscriptionId }, "Distributed search subscription failed");
+            client.writer.write({
+              type: "SEARCH_RESP",
+              payload: {
+                requestId: subscriptionId,
+                results: [],
+                totalCount: 0,
+                error: "Failed to create distributed subscription"
+              }
+            });
+          });
+        } else {
+          const initialResults = this.searchCoordinator.subscribe(
+            client.id,
+            subscriptionId,
+            subMapName,
+            subQuery,
+            subOptions
+          );
+          logger.debug({
+            clientId: client.id,
+            subscriptionId,
+            mapName: subMapName,
+            query: subQuery,
+            resultCount: initialResults.length
+          }, "Search subscription created (local)");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: subscriptionId,
+              results: initialResults,
+              totalCount: initialResults.length
+            }
+          });
+        }
         break;
       }
       case "SEARCH_UNSUB": {
         const { subscriptionId: unsubId } = message.payload;
         this.searchCoordinator.unsubscribe(unsubId);
+        if (this.distributedSubCoordinator) {
+          this.distributedSubCoordinator.unsubscribe(unsubId);
+        }
         logger.debug({ clientId: client.id, subscriptionId: unsubId }, "Search unsubscription");
         break;
       }
@@ -11582,7 +13413,7 @@ var ServerCoordinator = class {
       } else if (op.orRecord && op.orRecord.timestamp) {
       } else if (op.orTag) {
         try {
-          ts = import_core20.HLC.parse(op.orTag);
+          ts = import_core22.HLC.parse(op.orTag);
         } catch (e) {
         }
       }
@@ -11606,7 +13437,7 @@ var ServerCoordinator = class {
     };
     let broadcastCount = 0;
     for (const client of this.clients.values()) {
-      if (client.isAuthenticated && client.socket.readyState === import_ws3.WebSocket.OPEN && client.writer) {
+      if (client.isAuthenticated && client.socket.readyState === import_ws5.WebSocket.OPEN && client.writer) {
         client.writer.write(message);
         broadcastCount++;
       }
@@ -11679,7 +13510,7 @@ var ServerCoordinator = class {
         client.writer.write({ ...message, payload: newPayload });
       }
     } else {
-      const msgData = (0, import_core20.serialize)(message);
+      const msgData = (0, import_core22.serialize)(message);
       for (const [id, client] of this.clients) {
         if (id !== excludeClientId && client.socket.readyState === 1) {
           client.writer.writeRaw(msgData);
@@ -11757,7 +13588,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core20.serialize)(batchMessage);
+      const serializedBatch = (0, import_core22.serialize)(batchMessage);
       for (const client of clients) {
         try {
           client.writer.writeRaw(serializedBatch);
@@ -11842,7 +13673,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core20.serialize)(batchMessage);
+      const serializedBatch = (0, import_core22.serialize)(batchMessage);
       for (const client of clients) {
         sendPromises.push(new Promise((resolve, reject) => {
           try {
@@ -12038,9 +13869,9 @@ var ServerCoordinator = class {
   async executeLocalQuery(mapName, query) {
     const map = await this.getMapAsync(mapName);
     const localQuery = { ...query };
-    delete localQuery.offset;
+    delete localQuery.cursor;
     delete localQuery.limit;
-    if (map instanceof import_core20.IndexedLWWMap) {
+    if (map instanceof import_core22.IndexedLWWMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const entries = map.queryEntries(coreQuery);
@@ -12050,7 +13881,7 @@ var ServerCoordinator = class {
         });
       }
     }
-    if (map instanceof import_core20.IndexedORMap) {
+    if (map instanceof import_core22.IndexedORMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const results = map.query(coreQuery);
@@ -12058,14 +13889,14 @@ var ServerCoordinator = class {
       }
     }
     const records = /* @__PURE__ */ new Map();
-    if (map instanceof import_core20.LWWMap) {
+    if (map instanceof import_core22.LWWMap) {
       for (const key of map.allKeys()) {
         const rec = map.getRecord(key);
         if (rec && rec.value !== null) {
           records.set(key, rec);
         }
       }
-    } else if (map instanceof import_core20.ORMap) {
+    } else if (map instanceof import_core22.ORMap) {
       const items = map.items;
       for (const key of items.keys()) {
         const values = map.get(key);
@@ -12157,7 +13988,7 @@ var ServerCoordinator = class {
     };
     return mapping[op] || null;
   }
-  finalizeClusterQuery(requestId, timeout = false) {
+  async finalizeClusterQuery(requestId, timeout = false) {
     const pending = this.pendingClusterQueries.get(requestId);
     if (!pending) return;
     if (timeout) {
@@ -12182,7 +14013,49 @@ var ServerCoordinator = class {
         return 0;
       });
     }
-    const slicedResults = query.offset || query.limit ? finalResults.slice(query.offset || 0, (query.offset || 0) + (query.limit || finalResults.length)) : finalResults;
+    let slicedResults = finalResults;
+    let nextCursor;
+    let hasMore = false;
+    let cursorStatus = "none";
+    if (query.cursor || query.limit) {
+      const sort = query.sort || {};
+      const sortEntries = Object.entries(sort);
+      const sortField = sortEntries.length > 0 ? sortEntries[0][0] : "_key";
+      if (query.cursor) {
+        const cursorData = import_core22.QueryCursor.decode(query.cursor);
+        if (!cursorData) {
+          cursorStatus = "invalid";
+        } else if (!import_core22.QueryCursor.isValid(cursorData, query.predicate ?? query.where, sort)) {
+          if (Date.now() - cursorData.timestamp > import_core22.DEFAULT_QUERY_CURSOR_MAX_AGE_MS) {
+            cursorStatus = "expired";
+          } else {
+            cursorStatus = "invalid";
+          }
+        } else {
+          cursorStatus = "valid";
+          slicedResults = finalResults.filter((r) => {
+            const sortValue = r.value[sortField];
+            return import_core22.QueryCursor.isAfterCursor(
+              { key: r.key, sortValue },
+              cursorData
+            );
+          });
+        }
+      }
+      if (query.limit) {
+        hasMore = slicedResults.length > query.limit;
+        slicedResults = slicedResults.slice(0, query.limit);
+        if (hasMore && slicedResults.length > 0) {
+          const lastResult = slicedResults[slicedResults.length - 1];
+          const sortValue = lastResult.value[sortField];
+          nextCursor = import_core22.QueryCursor.fromLastResult(
+            { key: lastResult.key, sortValue },
+            sort,
+            query.predicate ?? query.where
+          );
+        }
+      }
+    }
     const resultKeys = new Set(slicedResults.map((r) => r.key));
     const sub = {
       id: queryId,
@@ -12201,7 +14074,7 @@ var ServerCoordinator = class {
     });
     client.writer.write({
       type: "QUERY_RESP",
-      payload: { queryId, results: filteredResults }
+      payload: { queryId, results: filteredResults, nextCursor, hasMore, cursorStatus }
     });
   }
   /**
@@ -12213,11 +14086,11 @@ var ServerCoordinator = class {
   async applyOpToMap(op, remoteNodeId) {
     const typeHint = op.opType === "OR_ADD" || op.opType === "OR_REMOVE" ? "OR" : "LWW";
     const map = this.getMap(op.mapName, typeHint);
-    if (typeHint === "OR" && map instanceof import_core20.LWWMap) {
+    if (typeHint === "OR" && map instanceof import_core22.LWWMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: LWWMap but received OR op");
       throw new Error("Map type mismatch: LWWMap but received OR op");
     }
-    if (typeHint === "LWW" && map instanceof import_core20.ORMap) {
+    if (typeHint === "LWW" && map instanceof import_core22.ORMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: ORMap but received LWW op");
       throw new Error("Map type mismatch: ORMap but received LWW op");
     }
@@ -12228,7 +14101,7 @@ var ServerCoordinator = class {
       mapName: op.mapName,
       key: op.key
     };
-    if (map instanceof import_core20.LWWMap) {
+    if (map instanceof import_core22.LWWMap) {
       oldRecord = map.getRecord(op.key);
       if (this.conflictResolverHandler.hasResolvers(op.mapName)) {
         const mergeResult = await this.conflictResolverHandler.mergeWithResolver(
@@ -12256,7 +14129,7 @@ var ServerCoordinator = class {
         eventPayload.eventType = "UPDATED";
         eventPayload.record = op.record;
       }
-    } else if (map instanceof import_core20.ORMap) {
+    } else if (map instanceof import_core22.ORMap) {
       oldRecord = map.getRecords(op.key);
       if (op.opType === "OR_ADD") {
         map.apply(op.key, op.orRecord);
@@ -12272,7 +14145,7 @@ var ServerCoordinator = class {
       }
     }
     this.queryRegistry.processChange(op.mapName, map, op.key, op.record || op.orRecord, oldRecord);
-    const mapSize = map instanceof import_core20.ORMap ? map.totalRecords : map.size;
+    const mapSize = map instanceof import_core22.ORMap ? map.totalRecords : map.size;
     this.metricsService.setMapSize(op.mapName, mapSize);
     if (this.storage) {
       if (recordToStore) {
@@ -12313,17 +14186,6 @@ var ServerCoordinator = class {
     }
     return { eventPayload, oldRecord };
   }
-  /**
-   * Broadcast event to cluster members (excluding self).
-   */
-  broadcastToCluster(eventPayload) {
-    const members = this.cluster.getMembers();
-    for (const memberId of members) {
-      if (!this.cluster.isLocal(memberId)) {
-        this.cluster.send(memberId, "CLUSTER_EVENT", eventPayload);
-      }
-    }
-  }
   /**
    * Apply replicated operation from another node (callback for ReplicationPipeline)
    * This is called when we receive a replicated operation as a backup node
@@ -12449,7 +14311,6 @@ var ServerCoordinator = class {
       payload: eventPayload,
       timestamp: this.hlc.now()
     }, originalSenderId);
-    this.broadcastToCluster(eventPayload);
     this.runAfterInterceptors(op, context);
   }
   /**
@@ -12576,7 +14437,6 @@ var ServerCoordinator = class {
       });
     }
     batchedEvents.push(eventPayload);
-    this.broadcastToCluster(eventPayload);
     this.runAfterInterceptors(op, context);
   }
   handleClusterEvent(payload) {
@@ -12586,11 +14446,11 @@ var ServerCoordinator = class {
       return;
     }
     const map = this.getMap(mapName, eventType === "OR_ADD" || eventType === "OR_REMOVE" ? "OR" : "LWW");
-    const oldRecord = map instanceof import_core20.LWWMap ? map.getRecord(key) : null;
+    const oldRecord = map instanceof import_core22.LWWMap ? map.getRecord(key) : null;
     if (this.partitionService.isRelated(key)) {
-      if (map instanceof import_core20.LWWMap && payload.record) {
+      if (map instanceof import_core22.LWWMap && payload.record) {
         map.merge(key, payload.record);
-      } else if (map instanceof import_core20.ORMap) {
+      } else if (map instanceof import_core22.ORMap) {
         if (eventType === "OR_ADD" && payload.orRecord) {
           map.apply(key, payload.orRecord);
         } else if (eventType === "OR_REMOVE" && payload.orTag) {
@@ -12609,9 +14469,9 @@ var ServerCoordinator = class {
     if (!this.maps.has(name)) {
       let map;
       if (typeHint === "OR") {
-        map = new import_core20.ORMap(this.hlc);
+        map = new import_core22.ORMap(this.hlc);
       } else {
-        map = new import_core20.LWWMap(this.hlc);
+        map = new import_core22.LWWMap(this.hlc);
       }
       this.maps.set(name, map);
       if (this.storage) {
@@ -12634,7 +14494,7 @@ var ServerCoordinator = class {
     this.getMap(name, typeHint);
     const loadingPromise = this.mapLoadingPromises.get(name);
     const map = this.maps.get(name);
-    const mapSize = map instanceof import_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.ORMap ? map.size : 0;
+    const mapSize = map instanceof import_core22.LWWMap ? Array.from(map.entries()).length : map instanceof import_core22.ORMap ? map.size : 0;
     logger.info({
       mapName: name,
       mapExisted,
@@ -12644,7 +14504,7 @@ var ServerCoordinator = class {
     if (loadingPromise) {
       logger.info({ mapName: name }, "[getMapAsync] Waiting for loadMapFromStorage...");
       await loadingPromise;
-      const newMapSize = map instanceof import_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.ORMap ? map.size : 0;
+      const newMapSize = map instanceof import_core22.LWWMap ? Array.from(map.entries()).length : map instanceof import_core22.ORMap ? map.size : 0;
       logger.info({ mapName: name, mapSizeAfterLoad: newMapSize }, "[getMapAsync] Load completed");
     }
     return this.maps.get(name);
@@ -12661,7 +14521,7 @@ var ServerCoordinator = class {
     const mapName = key.substring(0, separatorIndex);
     const actualKey = key.substring(separatorIndex + 1);
     const map = this.maps.get(mapName);
-    if (!map || !(map instanceof import_core20.LWWMap)) {
+    if (!map || !(map instanceof import_core22.LWWMap)) {
       return null;
     }
     return map.getRecord(actualKey) ?? null;
@@ -12715,16 +14575,16 @@ var ServerCoordinator = class {
       const currentMap = this.maps.get(name);
       if (!currentMap) return;
       let targetMap = currentMap;
-      if (isOR && currentMap instanceof import_core20.LWWMap) {
+      if (isOR && currentMap instanceof import_core22.LWWMap) {
         logger.info({ mapName: name }, "Map auto-detected as ORMap. Switching type.");
-        targetMap = new import_core20.ORMap(this.hlc);
+        targetMap = new import_core22.ORMap(this.hlc);
         this.maps.set(name, targetMap);
-      } else if (!isOR && currentMap instanceof import_core20.ORMap && typeHint !== "OR") {
+      } else if (!isOR && currentMap instanceof import_core22.ORMap && typeHint !== "OR") {
         logger.info({ mapName: name }, "Map auto-detected as LWWMap. Switching type.");
-        targetMap = new import_core20.LWWMap(this.hlc);
+        targetMap = new import_core22.LWWMap(this.hlc);
         this.maps.set(name, targetMap);
       }
-      if (targetMap instanceof import_core20.ORMap) {
+      if (targetMap instanceof import_core22.ORMap) {
         for (const [key, record] of records) {
           if (key === "__tombstones__") {
             const t = record;
@@ -12737,7 +14597,7 @@ var ServerCoordinator = class {
             }
           }
         }
-      } else if (targetMap instanceof import_core20.LWWMap) {
+      } else if (targetMap instanceof import_core22.LWWMap) {
         for (const [key, record] of records) {
           if (!record.type) {
             targetMap.merge(key, record);
@@ -12748,7 +14608,7 @@ var ServerCoordinator = class {
       if (count > 0) {
         logger.info({ mapName: name, count }, "Loaded records for map");
         this.queryRegistry.refreshSubscriptions(name, targetMap);
-        const mapSize = targetMap instanceof import_core20.ORMap ? targetMap.totalRecords : targetMap.size;
+        const mapSize = targetMap instanceof import_core22.ORMap ? targetMap.totalRecords : targetMap.size;
         this.metricsService.setMapSize(name, mapSize);
       }
     } catch (err) {
@@ -12821,7 +14681,7 @@ var ServerCoordinator = class {
           idleTime: now - client.lastPingReceived,
           timeoutMs: CLIENT_HEARTBEAT_TIMEOUT_MS
         }, "Evicting dead client (heartbeat timeout)");
-        if (client.socket.readyState === import_ws3.WebSocket.OPEN) {
+        if (client.socket.readyState === import_ws5.WebSocket.OPEN) {
           client.socket.close(4002, "Heartbeat timeout");
         }
       }
@@ -12830,7 +14690,7 @@ var ServerCoordinator = class {
   reportLocalHlc() {
     let minHlc = this.hlc.now();
     for (const client of this.clients.values()) {
-      if (import_core20.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
+      if (import_core22.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
         minHlc = client.lastActiveHlc;
       }
     }
@@ -12851,7 +14711,7 @@ var ServerCoordinator = class {
       let globalSafe = this.hlc.now();
       let initialized = false;
       for (const ts of this.gcReports.values()) {
-        if (!initialized || import_core20.HLC.compare(ts, globalSafe) < 0) {
+        if (!initialized || import_core22.HLC.compare(ts, globalSafe) < 0) {
           globalSafe = ts;
           initialized = true;
         }
@@ -12886,7 +14746,7 @@ var ServerCoordinator = class {
     logger.info({ olderThanMillis: olderThan.millis }, "Performing Garbage Collection");
     const now = Date.now();
     for (const [name, map] of this.maps) {
-      if (map instanceof import_core20.LWWMap) {
+      if (map instanceof import_core22.LWWMap) {
         for (const key of map.allKeys()) {
           const record = map.getRecord(key);
           if (record && record.value !== null && record.ttlMs) {
@@ -12919,11 +14779,18 @@ var ServerCoordinator = class {
                   payload: eventPayload,
                   timestamp: this.hlc.now()
                 });
-                const members = this.cluster.getMembers();
-                for (const memberId of members) {
-                  if (!this.cluster.isLocal(memberId)) {
-                    this.cluster.send(memberId, "CLUSTER_EVENT", eventPayload);
-                  }
+                this.queryRegistry.processChange(name, map, key, tombstone, record);
+                if (this.replicationPipeline) {
+                  const op = {
+                    opType: "set",
+                    mapName: name,
+                    key,
+                    record: tombstone
+                  };
+                  const opId = `ttl:${name}:${key}:${Date.now()}`;
+                  this.replicationPipeline.replicate(op, opId, key).catch((err) => {
+                    logger.warn({ opId, key, err }, "TTL expiration replication failed (non-fatal)");
+                  });
                 }
               }
             }
@@ -12938,7 +14805,7 @@ var ServerCoordinator = class {
             });
           }
         }
-      } else if (map instanceof import_core20.ORMap) {
+      } else if (map instanceof import_core22.ORMap) {
         const items = map.items;
         const tombstonesSet = map.tombstones;
         const tagsToExpire = [];
@@ -12956,6 +14823,7 @@ var ServerCoordinator = class {
         }
         for (const { key, tag } of tagsToExpire) {
           logger.info({ mapName: name, key, tag }, "ORMap Record expired (TTL). Removing.");
+          const oldRecords = map.getRecords(key);
           map.applyTombstone(tag);
           if (this.storage) {
             const records = map.getRecords(key);
@@ -12981,11 +14849,19 @@ var ServerCoordinator = class {
             payload: eventPayload,
             timestamp: this.hlc.now()
           });
-          const members = this.cluster.getMembers();
-          for (const memberId of members) {
-            if (!this.cluster.isLocal(memberId)) {
-              this.cluster.send(memberId, "CLUSTER_EVENT", eventPayload);
-            }
+          const newRecords = map.getRecords(key);
+          this.queryRegistry.processChange(name, map, key, newRecords, oldRecords);
+          if (this.replicationPipeline) {
+            const op = {
+              opType: "OR_REMOVE",
+              mapName: name,
+              key,
+              orTag: tag
+            };
+            const opId = `ttl:${name}:${key}:${tag}:${Date.now()}`;
+            this.replicationPipeline.replicate(op, opId, key).catch((err) => {
+              logger.warn({ opId, key, err }, "ORMap TTL expiration replication failed (non-fatal)");
+            });
           }
         }
         const removedTags = map.prune(olderThan);
@@ -13041,17 +14917,17 @@ var ServerCoordinator = class {
   stringToWriteConcern(value) {
     switch (value) {
       case "FIRE_AND_FORGET":
-        return import_core20.WriteConcern.FIRE_AND_FORGET;
+        return import_core22.WriteConcern.FIRE_AND_FORGET;
       case "MEMORY":
-        return import_core20.WriteConcern.MEMORY;
+        return import_core22.WriteConcern.MEMORY;
       case "APPLIED":
-        return import_core20.WriteConcern.APPLIED;
+        return import_core22.WriteConcern.APPLIED;
       case "REPLICATED":
-        return import_core20.WriteConcern.REPLICATED;
+        return import_core22.WriteConcern.REPLICATED;
       case "PERSISTED":
-        return import_core20.WriteConcern.PERSISTED;
+        return import_core22.WriteConcern.PERSISTED;
       default:
-        return import_core20.WriteConcern.MEMORY;
+        return import_core22.WriteConcern.MEMORY;
     }
   }
   /**
@@ -13108,7 +14984,7 @@ var ServerCoordinator = class {
             }
           });
           if (op.id) {
-            this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.REPLICATED);
           }
         }
       }
@@ -13116,7 +14992,7 @@ var ServerCoordinator = class {
         this.broadcastBatch(batchedEvents, clientId);
         for (const op of ops) {
           if (op.id && this.partitionService.isLocalOwner(op.key)) {
-            this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.REPLICATED);
           }
         }
       }
@@ -13144,7 +15020,7 @@ var ServerCoordinator = class {
         const owner = this.partitionService.getOwner(op.key);
         await this.forwardOpAndWait(op, owner);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.REPLICATED);
         }
       }
     }
@@ -13152,7 +15028,7 @@ var ServerCoordinator = class {
       await this.broadcastBatchSync(batchedEvents, clientId);
       for (const op of ops) {
         if (op.id && this.partitionService.isLocalOwner(op.key)) {
-          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.REPLICATED);
         }
       }
     }
@@ -13186,7 +15062,7 @@ var ServerCoordinator = class {
       return;
     }
     if (op.id) {
-      this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.APPLIED);
+      this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.APPLIED);
     }
     if (eventPayload) {
       batchedEvents.push({
@@ -13200,7 +15076,7 @@ var ServerCoordinator = class {
       try {
         await this.persistOpSync(op);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.PERSISTED);
+          this.writeAckManager.notifyLevel(op.id, import_core22.WriteConcern.PERSISTED);
         }
       } catch (err) {
         logger.error({ opId: op.id, err }, "Persistence failed");
@@ -13543,10 +15419,10 @@ var RateLimitInterceptor = class {
 };
 
 // src/utils/nativeStats.ts
-var import_core21 = require("@topgunbuild/core");
+var import_core23 = require("@topgunbuild/core");
 function getNativeModuleStatus() {
   return {
-    nativeHash: (0, import_core21.isUsingNativeHash)(),
+    nativeHash: (0, import_core23.isUsingNativeHash)(),
     sharedArrayBuffer: SharedMemoryManager.isAvailable()
   };
 }
@@ -13579,15 +15455,15 @@ function logNativeStatus() {
 }
 
 // src/cluster/ClusterCoordinator.ts
-var import_events13 = require("events");
-var import_core22 = require("@topgunbuild/core");
+var import_events16 = require("events");
+var import_core24 = require("@topgunbuild/core");
 var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
   gradualRebalancing: true,
-  migration: import_core22.DEFAULT_MIGRATION_CONFIG,
-  replication: import_core22.DEFAULT_REPLICATION_CONFIG,
+  migration: import_core24.DEFAULT_MIGRATION_CONFIG,
+  replication: import_core24.DEFAULT_REPLICATION_CONFIG,
   replicationEnabled: true
 };
-var ClusterCoordinator = class extends import_events13.EventEmitter {
+var ClusterCoordinator = class extends import_events16.EventEmitter {
   constructor(config) {
     super();
     this.replicationPipeline = null;
@@ -13952,12 +15828,12 @@ var ClusterCoordinator = class extends import_events13.EventEmitter {
 };
 
 // src/MapWithResolver.ts
-var import_core23 = require("@topgunbuild/core");
+var import_core25 = require("@topgunbuild/core");
 var MapWithResolver = class {
   constructor(config) {
     this.mapName = config.name;
-    this.hlc = new import_core23.HLC(config.nodeId);
-    this.map = new import_core23.LWWMap(this.hlc);
+    this.hlc = new import_core25.HLC(config.nodeId);
+    this.map = new import_core25.LWWMap(this.hlc);
     this.resolverService = config.resolverService;
     this.onRejection = config.onRejection;
   }
@@ -14213,7 +16089,7 @@ function mergeWithDefaults(userConfig) {
 }
 
 // src/config/MapFactory.ts
-var import_core24 = require("@topgunbuild/core");
+var import_core26 = require("@topgunbuild/core");
 var MapFactory = class {
   /**
    * Create a MapFactory.
@@ -14237,9 +16113,9 @@ var MapFactory = class {
   createLWWMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core24.LWWMap(hlc);
+      return new import_core26.LWWMap(hlc);
     }
-    const map = new import_core24.IndexedLWWMap(hlc);
+    const map = new import_core26.IndexedLWWMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToLWWMap(map, indexDef);
     }
@@ -14255,9 +16131,9 @@ var MapFactory = class {
   createORMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core24.ORMap(hlc);
+      return new import_core26.ORMap(hlc);
     }
-    const map = new import_core24.IndexedORMap(hlc);
+    const map = new import_core26.IndexedORMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToORMap(map, indexDef);
     }
@@ -14294,7 +16170,7 @@ var MapFactory = class {
    * Supports dot notation for nested paths.
    */
   createAttribute(path) {
-    return (0, import_core24.simpleAttribute)(path, (record) => {
+    return (0, import_core26.simpleAttribute)(path, (record) => {
       return this.getNestedValue(record, path);
     });
   }