@topgunbuild/server 0.7.0 → 0.8.0

package/dist/index.js

@@ -71,6 +71,7 @@ __export(index_exports, {
   ReduceTasklet: () => ReduceTasklet,
   RepairScheduler: () => RepairScheduler,
   ReplicationPipeline: () => ReplicationPipeline,
+  SearchCoordinator: () => SearchCoordinator,
   SecurityManager: () => SecurityManager,
   ServerCoordinator: () => ServerCoordinator,
   TaskletScheduler: () => TaskletScheduler,
@@ -105,7 +106,7 @@ var import_http = require("http");
 var import_https = require("https");
 var import_fs2 = require("fs");
 var import_ws3 = require("ws");
-var import_core19 = require("@topgunbuild/core");
+var import_core20 = require("@topgunbuild/core");
 var jwt = __toESM(require("jsonwebtoken"));
 var crypto = __toESM(require("crypto"));
 
@@ -9255,6 +9256,554 @@ var EventJournalService = class extends import_core18.EventJournalImpl {
   }
 };
 
+// src/search/SearchCoordinator.ts
+var import_core19 = require("@topgunbuild/core");
+var SearchCoordinator = class {
+  constructor() {
+    /** Map name → FullTextIndex */
+    this.indexes = /* @__PURE__ */ new Map();
+    /** Map name → FullTextIndexConfig (for reference) */
+    this.configs = /* @__PURE__ */ new Map();
+    // ============================================
+    // Phase 11.1b: Live Search Subscription tracking
+    // ============================================
+    /** Subscription ID → SearchSubscription */
+    this.subscriptions = /* @__PURE__ */ new Map();
+    /** Map name → Set of subscription IDs */
+    this.subscriptionsByMap = /* @__PURE__ */ new Map();
+    /** Client ID → Set of subscription IDs */
+    this.subscriptionsByClient = /* @__PURE__ */ new Map();
+    // ============================================
+    // Phase 11.2: Notification Batching
+    // ============================================
+    /** Queue of pending notifications per map */
+    this.pendingNotifications = /* @__PURE__ */ new Map();
+    /** Timer for batching notifications */
+    this.notificationTimer = null;
+    /** Batch interval in milliseconds (~1 frame at 60fps) */
+    this.BATCH_INTERVAL = 16;
+    logger.debug("SearchCoordinator initialized");
+  }
+  /**
+   * Set the callback for sending updates to clients.
+   * Called by ServerCoordinator during initialization.
+   */
+  setSendUpdateCallback(callback) {
+    this.sendUpdate = callback;
+  }
+  /**
+   * Set the callback for sending batched updates to clients.
+   * When set, notifications are batched within BATCH_INTERVAL (16ms) window.
+   * Called by ServerCoordinator during initialization.
+   *
+   * @param callback - Function to call with batched updates
+   */
+  setSendBatchUpdateCallback(callback) {
+    this.sendBatchUpdate = callback;
+  }
+  /**
+   * Set the callback for retrieving document values.
+   * Called by ServerCoordinator during initialization.
+   */
+  setDocumentValueGetter(getter) {
+    this.getDocumentValue = getter;
+  }
+  /**
+   * Enable full-text search for a map.
+   *
+   * @param mapName - Name of the map to enable FTS for
+   * @param config - FTS configuration (fields, tokenizer, bm25 options)
+   */
+  enableSearch(mapName, config) {
+    if (this.indexes.has(mapName)) {
+      logger.warn({ mapName }, "FTS already enabled for map, replacing index");
+      this.indexes.delete(mapName);
+    }
+    const index = new import_core19.FullTextIndex(config);
+    this.indexes.set(mapName, index);
+    this.configs.set(mapName, config);
+    logger.info({ mapName, fields: config.fields }, "FTS enabled for map");
+  }
+  /**
+   * Disable full-text search for a map.
+   *
+   * @param mapName - Name of the map to disable FTS for
+   */
+  disableSearch(mapName) {
+    if (!this.indexes.has(mapName)) {
+      logger.warn({ mapName }, "FTS not enabled for map, nothing to disable");
+      return;
+    }
+    this.indexes.delete(mapName);
+    this.configs.delete(mapName);
+    logger.info({ mapName }, "FTS disabled for map");
+  }
+  /**
+   * Check if FTS is enabled for a map.
+   */
+  isSearchEnabled(mapName) {
+    return this.indexes.has(mapName);
+  }
+  /**
+   * Get enabled map names.
+   */
+  getEnabledMaps() {
+    return Array.from(this.indexes.keys());
+  }
+  /**
+   * Execute a one-shot search query.
+   *
+   * @param mapName - Name of the map to search
+   * @param query - Search query text
+   * @param options - Search options (limit, minScore, boost)
+   * @returns Search response payload
+   */
+  search(mapName, query, options) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Search requested for map without FTS enabled");
+      return {
+        requestId: "",
+        results: [],
+        totalCount: 0,
+        error: `Full-text search not enabled for map: ${mapName}`
+      };
+    }
+    try {
+      const searchResults = index.search(query, options);
+      const results = searchResults.map((result) => {
+        const value = this.getDocumentValue ? this.getDocumentValue(mapName, result.docId) : void 0;
+        return {
+          key: result.docId,
+          value,
+          score: result.score,
+          matchedTerms: result.matchedTerms || []
+        };
+      });
+      logger.debug(
+        { mapName, query, resultCount: results.length },
+        "Search executed"
+      );
+      return {
+        requestId: "",
+        results,
+        totalCount: searchResults.length
+      };
+    } catch (err) {
+      logger.error({ mapName, query, err }, "Search failed");
+      return {
+        requestId: "",
+        results: [],
+        totalCount: 0,
+        error: `Search failed: ${err.message}`
+      };
+    }
+  }
+  /**
+   * Handle document set/update.
+   * Called by ServerCoordinator when data changes.
+   *
+   * @param mapName - Name of the map
+   * @param key - Document key
+   * @param value - Document value
+   */
+  onDataChange(mapName, key, value, changeType) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    if (changeType === "remove" || value === null || value === void 0) {
+      index.onRemove(key);
+    } else {
+      index.onSet(key, value);
+    }
+    this.notifySubscribers(mapName, key, value ?? null, changeType);
+  }
+  /**
+   * Build index from existing map entries.
+   * Called when FTS is enabled for a map that already has data.
+   *
+   * @param mapName - Name of the map
+   * @param entries - Iterator of [key, value] tuples
+   */
+  buildIndexFromEntries(mapName, entries) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Cannot build index: FTS not enabled for map");
+      return;
+    }
+    let count = 0;
+    for (const [key, value] of entries) {
+      if (value !== null) {
+        index.onSet(key, value);
+        count++;
+      }
+    }
+    logger.info({ mapName, documentCount: count }, "Index built from entries");
+  }
+  /**
+   * Get index statistics for monitoring.
+   */
+  getIndexStats(mapName) {
+    const index = this.indexes.get(mapName);
+    const config = this.configs.get(mapName);
+    if (!index || !config) {
+      return null;
+    }
+    return {
+      documentCount: index.getSize(),
+      fields: config.fields
+    };
+  }
+  /**
+   * Clear all indexes (for testing or shutdown).
+   */
+  clear() {
+    for (const index of this.indexes.values()) {
+      index.clear();
+    }
+    this.indexes.clear();
+    this.configs.clear();
+    this.subscriptions.clear();
+    this.subscriptionsByMap.clear();
+    this.subscriptionsByClient.clear();
+    this.pendingNotifications.clear();
+    if (this.notificationTimer) {
+      clearTimeout(this.notificationTimer);
+      this.notificationTimer = null;
+    }
+    logger.debug("SearchCoordinator cleared");
+  }
+  // ============================================
+  // Phase 11.1b: Live Search Subscription Methods
+  // ============================================
+  /**
+   * Subscribe to live search results.
+   * Returns initial results and tracks the subscription for delta updates.
+   *
+   * @param clientId - ID of the subscribing client
+   * @param subscriptionId - Unique subscription identifier
+   * @param mapName - Name of the map to search
+   * @param query - Search query text
+   * @param options - Search options (limit, minScore, boost)
+   * @returns Initial search results
+   */
+  subscribe(clientId, subscriptionId, mapName, query, options) {
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      logger.warn({ mapName }, "Subscribe requested for map without FTS enabled");
+      return [];
+    }
+    const queryTerms = index.tokenizeQuery(query);
+    const searchResults = index.search(query, options);
+    const currentResults = /* @__PURE__ */ new Map();
+    const results = [];
+    for (const result of searchResults) {
+      const value = this.getDocumentValue ? this.getDocumentValue(mapName, result.docId) : void 0;
+      currentResults.set(result.docId, {
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+      results.push({
+        key: result.docId,
+        value,
+        score: result.score,
+        matchedTerms: result.matchedTerms || []
+      });
+    }
+    const subscription = {
+      id: subscriptionId,
+      clientId,
+      mapName,
+      query,
+      queryTerms,
+      options: options || {},
+      currentResults
+    };
+    this.subscriptions.set(subscriptionId, subscription);
+    if (!this.subscriptionsByMap.has(mapName)) {
+      this.subscriptionsByMap.set(mapName, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByMap.get(mapName).add(subscriptionId);
+    if (!this.subscriptionsByClient.has(clientId)) {
+      this.subscriptionsByClient.set(clientId, /* @__PURE__ */ new Set());
+    }
+    this.subscriptionsByClient.get(clientId).add(subscriptionId);
+    logger.debug(
+      { subscriptionId, clientId, mapName, query, resultCount: results.length },
+      "Search subscription created"
+    );
+    return results;
+  }
+  /**
+   * Unsubscribe from a live search.
+   *
+   * @param subscriptionId - Subscription to remove
+   */
+  unsubscribe(subscriptionId) {
+    const subscription = this.subscriptions.get(subscriptionId);
+    if (!subscription) {
+      return;
+    }
+    this.subscriptions.delete(subscriptionId);
+    const mapSubs = this.subscriptionsByMap.get(subscription.mapName);
+    if (mapSubs) {
+      mapSubs.delete(subscriptionId);
+      if (mapSubs.size === 0) {
+        this.subscriptionsByMap.delete(subscription.mapName);
+      }
+    }
+    const clientSubs = this.subscriptionsByClient.get(subscription.clientId);
+    if (clientSubs) {
+      clientSubs.delete(subscriptionId);
+      if (clientSubs.size === 0) {
+        this.subscriptionsByClient.delete(subscription.clientId);
+      }
+    }
+    logger.debug({ subscriptionId }, "Search subscription removed");
+  }
+  /**
+   * Unsubscribe all subscriptions for a client.
+   * Called when a client disconnects.
+   *
+   * @param clientId - ID of the disconnected client
+   */
+  unsubscribeClient(clientId) {
+    const clientSubs = this.subscriptionsByClient.get(clientId);
+    if (!clientSubs) {
+      return;
+    }
+    const subscriptionIds = Array.from(clientSubs);
+    for (const subscriptionId of subscriptionIds) {
+      this.unsubscribe(subscriptionId);
+    }
+    logger.debug({ clientId, count: subscriptionIds.length }, "Client subscriptions cleared");
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  /**
+   * Notify subscribers about a document change.
+   * Computes delta (ENTER/UPDATE/LEAVE) for each affected subscription.
+   *
+   * @param mapName - Name of the map that changed
+   * @param key - Document key that changed
+   * @param value - New document value (null if removed)
+   * @param changeType - Type of change
+   */
+  notifySubscribers(mapName, key, value, changeType) {
+    if (!this.sendUpdate) {
+      return;
+    }
+    const subscriptionIds = this.subscriptionsByMap.get(mapName);
+    if (!subscriptionIds || subscriptionIds.size === 0) {
+      return;
+    }
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    for (const subId of subscriptionIds) {
+      const sub = this.subscriptions.get(subId);
+      if (!sub) continue;
+      const wasInResults = sub.currentResults.has(key);
+      let isInResults = false;
+      let newScore = 0;
+      let matchedTerms = [];
+      logger.debug({ subId, key, wasInResults, changeType }, "Processing subscription update");
+      if (changeType !== "remove" && value !== null) {
+        const result = this.scoreDocument(sub, key, value, index);
+        if (result && result.score >= (sub.options.minScore ?? 0)) {
+          isInResults = true;
+          newScore = result.score;
+          matchedTerms = result.matchedTerms;
+        }
+      }
+      let updateType = null;
+      if (!wasInResults && isInResults) {
+        updateType = "ENTER";
+        sub.currentResults.set(key, { score: newScore, matchedTerms });
+      } else if (wasInResults && !isInResults) {
+        updateType = "LEAVE";
+        sub.currentResults.delete(key);
+      } else if (wasInResults && isInResults) {
+        const old = sub.currentResults.get(key);
+        if (Math.abs(old.score - newScore) > 1e-4 || changeType === "update") {
+          updateType = "UPDATE";
+          sub.currentResults.set(key, { score: newScore, matchedTerms });
+        }
+      }
+      logger.debug({ subId, key, wasInResults, isInResults, updateType, newScore }, "Update decision");
+      if (updateType) {
+        this.sendUpdate(
+          sub.clientId,
+          subId,
+          key,
+          value,
+          newScore,
+          matchedTerms,
+          updateType
+        );
+      }
+    }
+  }
+  /**
+   * Score a single document against a subscription's query.
+   *
+   * OPTIMIZED: O(Q × D) complexity instead of O(N) full index scan.
+   * Uses pre-tokenized queryTerms and FullTextIndex.scoreSingleDocument().
+   *
+   * @param subscription - The subscription containing query and cached queryTerms
+   * @param key - Document key
+   * @param value - Document value
+   * @param index - The FullTextIndex for this map
+   * @returns Scored result or null if document doesn't match
+   */
+  scoreDocument(subscription, key, value, index) {
+    const result = index.scoreSingleDocument(key, subscription.queryTerms, value);
+    if (!result) {
+      return null;
+    }
+    return {
+      score: result.score,
+      matchedTerms: result.matchedTerms || []
+    };
+  }
+  // ============================================
+  // Phase 11.2: Notification Batching Methods
+  // ============================================
+  /**
+   * Queue a notification for batched processing.
+   * Notifications are collected and processed together after BATCH_INTERVAL.
+   *
+   * @param mapName - Name of the map that changed
+   * @param key - Document key that changed
+   * @param value - New document value (null if removed)
+   * @param changeType - Type of change
+   */
+  queueNotification(mapName, key, value, changeType) {
+    if (!this.sendBatchUpdate) {
+      this.notifySubscribers(mapName, key, value, changeType);
+      return;
+    }
+    const notification = { key, value, changeType };
+    if (!this.pendingNotifications.has(mapName)) {
+      this.pendingNotifications.set(mapName, []);
+    }
+    this.pendingNotifications.get(mapName).push(notification);
+    this.scheduleNotificationFlush();
+  }
+  /**
+   * Schedule a flush of pending notifications.
+   * Uses setTimeout to batch notifications within BATCH_INTERVAL window.
+   */
+  scheduleNotificationFlush() {
+    if (this.notificationTimer) {
+      return;
+    }
+    this.notificationTimer = setTimeout(() => {
+      this.flushNotifications();
+      this.notificationTimer = null;
+    }, this.BATCH_INTERVAL);
+  }
+  /**
+   * Flush all pending notifications.
+   * Processes each map's notifications and sends batched updates.
+   */
+  flushNotifications() {
+    if (this.pendingNotifications.size === 0) {
+      return;
+    }
+    for (const [mapName, notifications] of this.pendingNotifications) {
+      this.processBatchedNotifications(mapName, notifications);
+    }
+    this.pendingNotifications.clear();
+  }
+  /**
+   * Process batched notifications for a single map.
+   * Computes updates for each subscription and sends as a batch.
+   *
+   * @param mapName - Name of the map
+   * @param notifications - Array of pending notifications
+   */
+  processBatchedNotifications(mapName, notifications) {
+    const subscriptionIds = this.subscriptionsByMap.get(mapName);
+    if (!subscriptionIds || subscriptionIds.size === 0) {
+      return;
+    }
+    const index = this.indexes.get(mapName);
+    if (!index) {
+      return;
+    }
+    for (const subId of subscriptionIds) {
+      const sub = this.subscriptions.get(subId);
+      if (!sub) continue;
+      const updates = [];
+      for (const { key, value, changeType } of notifications) {
+        const update = this.computeSubscriptionUpdate(sub, key, value, changeType, index);
+        if (update) {
+          updates.push(update);
+        }
+      }
+      if (updates.length > 0 && this.sendBatchUpdate) {
+        this.sendBatchUpdate(sub.clientId, subId, updates);
+      }
+    }
+  }
+  /**
+   * Compute the update for a single document change against a subscription.
+   * Returns null if no update is needed.
+   *
+   * @param subscription - The subscription to check
+   * @param key - Document key
+   * @param value - Document value (null if removed)
+   * @param changeType - Type of change
+   * @param index - The FullTextIndex for this map
+   * @returns BatchedUpdate or null
+   */
+  computeSubscriptionUpdate(subscription, key, value, changeType, index) {
+    const wasInResults = subscription.currentResults.has(key);
+    let isInResults = false;
+    let newScore = 0;
+    let matchedTerms = [];
+    if (changeType !== "remove" && value !== null) {
+      const result = this.scoreDocument(subscription, key, value, index);
+      if (result && result.score >= (subscription.options.minScore ?? 0)) {
+        isInResults = true;
+        newScore = result.score;
+        matchedTerms = result.matchedTerms;
+      }
+    }
+    let updateType = null;
+    if (!wasInResults && isInResults) {
+      updateType = "ENTER";
+      subscription.currentResults.set(key, { score: newScore, matchedTerms });
+    } else if (wasInResults && !isInResults) {
+      updateType = "LEAVE";
+      subscription.currentResults.delete(key);
+    } else if (wasInResults && isInResults) {
+      const old = subscription.currentResults.get(key);
+      if (Math.abs(old.score - newScore) > 1e-4 || changeType === "update") {
+        updateType = "UPDATE";
+        subscription.currentResults.set(key, { score: newScore, matchedTerms });
+      }
+    }
+    if (!updateType) {
+      return null;
+    }
+    return {
+      key,
+      value,
+      score: newScore,
+      matchedTerms,
+      type: updateType
+    };
+  }
+};
+
 // src/ServerCoordinator.ts
 var GC_INTERVAL_MS = 60 * 60 * 1e3;
 var GC_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
@@ -9281,7 +9830,7 @@ var ServerCoordinator = class {
       this._readyResolve = resolve;
     });
     this._nodeId = config.nodeId;
-    this.hlc = new import_core19.HLC(config.nodeId);
+    this.hlc = new import_core20.HLC(config.nodeId);
     this.storage = config.storage;
     const rawSecret = config.jwtSecret || process.env.JWT_SECRET || "topgun-secret-dev";
     this.jwtSecret = rawSecret.replace(/\\n/g, "\n");
@@ -9423,8 +9972,8 @@ var ServerCoordinator = class {
           this.cluster,
           this.partitionService,
           {
-            ...import_core19.DEFAULT_REPLICATION_CONFIG,
-            defaultConsistency: config.defaultConsistency ?? import_core19.ConsistencyLevel.EVENTUAL,
+            ...import_core20.DEFAULT_REPLICATION_CONFIG,
+            defaultConsistency: config.defaultConsistency ?? import_core20.ConsistencyLevel.EVENTUAL,
             ...config.replicationConfig
           }
         );
@@ -9487,7 +10036,7 @@ var ServerCoordinator = class {
         void 0,
         // LagTracker - can be added later
         {
-          defaultConsistency: config.defaultConsistency ?? import_core19.ConsistencyLevel.STRONG,
+          defaultConsistency: config.defaultConsistency ?? import_core20.ConsistencyLevel.STRONG,
           preferLocalReplica: true,
           loadBalancing: "latency-based"
         }
@@ -9512,6 +10061,34 @@ var ServerCoordinator = class {
       );
       this.repairScheduler.start();
       logger.info("MerkleTreeManager and RepairScheduler initialized");
+      this.searchCoordinator = new SearchCoordinator();
+      this.searchCoordinator.setDocumentValueGetter((mapName, key) => {
+        const map = this.maps.get(mapName);
+        if (!map) return void 0;
+        return map.get(key);
+      });
+      this.searchCoordinator.setSendUpdateCallback((clientId, subscriptionId, key, value, score, matchedTerms, type) => {
+        const client = this.clients.get(clientId);
+        if (client) {
+          client.writer.write({
+            type: "SEARCH_UPDATE",
+            payload: {
+              subscriptionId,
+              key,
+              value,
+              score,
+              matchedTerms,
+              type
+            }
+          });
+        }
+      });
+      if (config.fullTextSearch) {
+        for (const [mapName, ftsConfig] of Object.entries(config.fullTextSearch)) {
+          this.searchCoordinator.enableSearch(mapName, ftsConfig);
+          logger.info({ mapName, fields: ftsConfig.fields }, "FTS enabled for map");
+        }
+      }
       this.systemManager = new SystemManager(
         this.cluster,
         this.metricsService,
@@ -9535,6 +10112,7 @@ var ServerCoordinator = class {
     if (this.storage) {
       this.storage.initialize().then(() => {
         logger.info("Storage adapter initialized");
+        this.backfillSearchIndexes();
       }).catch((err) => {
         logger.error({ err }, "Failed to initialize storage");
       });
@@ -9542,6 +10120,36 @@ var ServerCoordinator = class {
     this.startGarbageCollection();
     this.startHeartbeatCheck();
   }
+  /**
+   * Populate FTS indexes from existing map data.
+   * Called after storage initialization.
+   */
+  async backfillSearchIndexes() {
+    const enabledMaps = this.searchCoordinator.getEnabledMaps();
+    const promises2 = enabledMaps.map(async (mapName) => {
+      try {
+        await this.getMapAsync(mapName);
+        const map = this.maps.get(mapName);
+        if (!map) return;
+        if (map instanceof import_core20.LWWMap) {
+          const entries = Array.from(map.entries());
+          if (entries.length > 0) {
+            logger.info({ mapName, count: entries.length }, "Backfilling FTS index");
+            this.searchCoordinator.buildIndexFromEntries(
+              mapName,
+              map.entries()
+            );
+          }
+        } else {
+          logger.warn({ mapName }, "FTS backfill skipped: Map type not supported (only LWWMap)");
+        }
+      } catch (err) {
+        logger.error({ mapName, err }, "Failed to backfill FTS index");
+      }
+    });
+    await Promise.all(promises2);
+    logger.info("FTS backfill completed");
+  }
   /** Wait for server to be fully ready (ports assigned) */
   ready() {
     return this._readyPromise;
@@ -9608,6 +10216,59 @@ var ServerCoordinator = class {
   getTaskletScheduler() {
     return this.taskletScheduler;
   }
+  // === Phase 11.1: Full-Text Search Public API ===
+  /**
+   * Enable full-text search for a map.
+   * Can be called at runtime to enable FTS dynamically.
+   *
+   * @param mapName - Name of the map to enable FTS for
+   * @param config - FTS configuration (fields, tokenizer, bm25 options)
+   */
+  enableFullTextSearch(mapName, config) {
+    this.searchCoordinator.enableSearch(mapName, config);
+    const map = this.maps.get(mapName);
+    if (map) {
+      const entries = [];
+      if (map instanceof import_core20.LWWMap) {
+        for (const [key, value] of map.entries()) {
+          entries.push([key, value]);
+        }
+      } else if (map instanceof import_core20.ORMap) {
+        for (const key of map.allKeys()) {
+          const values = map.get(key);
+          const value = values.length > 0 ? values[0] : null;
+          entries.push([key, value]);
+        }
+      }
+      this.searchCoordinator.buildIndexFromEntries(mapName, entries);
+    }
+  }
+  /**
+   * Disable full-text search for a map.
+   *
+   * @param mapName - Name of the map to disable FTS for
+   */
+  disableFullTextSearch(mapName) {
+    this.searchCoordinator.disableSearch(mapName);
+  }
+  /**
+   * Check if full-text search is enabled for a map.
+   *
+   * @param mapName - Name of the map to check
+   * @returns True if FTS is enabled
+   */
+  isFullTextSearchEnabled(mapName) {
+    return this.searchCoordinator.isSearchEnabled(mapName);
+  }
+  /**
+   * Get FTS index statistics for a map.
+   *
+   * @param mapName - Name of the map
+   * @returns Index stats or null if FTS not enabled
+   */
+  getFullTextSearchStats(mapName) {
+    return this.searchCoordinator.getIndexStats(mapName);
+  }
   /**
    * Phase 10.02: Graceful cluster departure
    *
@@ -9693,7 +10354,7 @@ var ServerCoordinator = class {
     this.metricsService.destroy();
     this.wss.close();
     logger.info(`Closing ${this.clients.size} client connections...`);
-    const shutdownMsg = (0, import_core19.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
+    const shutdownMsg = (0, import_core20.serialize)({ type: "SHUTDOWN_PENDING", retryAfter: 5e3 });
     for (const client of this.clients.values()) {
       try {
         if (client.socket.readyState === import_ws3.WebSocket.OPEN) {
@@ -9826,7 +10487,7 @@ var ServerCoordinator = class {
           buf = Buffer.from(message);
         }
         try {
-          data = (0, import_core19.deserialize)(buf);
+          data = (0, import_core20.deserialize)(buf);
         } catch (e) {
           try {
             const text = Buffer.isBuffer(buf) ? buf.toString() : new TextDecoder().decode(buf);
@@ -9866,6 +10527,7 @@ var ServerCoordinator = class {
       this.lockManager.handleClientDisconnect(clientId);
       this.topicManager.unsubscribeAll(clientId);
       this.counterHandler.unsubscribeAll(clientId);
+      this.searchCoordinator.unsubscribeClient(clientId);
       const members = this.cluster.getMembers();
       for (const memberId of members) {
         if (!this.cluster.isLocal(memberId)) {
@@ -9878,10 +10540,10 @@ var ServerCoordinator = class {
       this.clients.delete(clientId);
       this.metricsService.setConnectedClients(this.clients.size);
     });
-    ws.send((0, import_core19.serialize)({ type: "AUTH_REQUIRED" }));
+    ws.send((0, import_core20.serialize)({ type: "AUTH_REQUIRED" }));
   }
   async handleMessage(client, rawMessage) {
-    const parseResult = import_core19.MessageSchema.safeParse(rawMessage);
+    const parseResult = import_core20.MessageSchema.safeParse(rawMessage);
     if (!parseResult.success) {
       logger.error({ clientId: client.id, error: parseResult.error }, "Invalid message format from client");
       client.writer.write({
@@ -9951,7 +10613,7 @@ var ServerCoordinator = class {
               options: {
                 // Default to EVENTUAL for read scaling unless specified otherwise
                 // In future, we could extract consistency from query options if available
-                consistency: import_core19.ConsistencyLevel.EVENTUAL
+                consistency: import_core20.ConsistencyLevel.EVENTUAL
               }
             });
             if (targetNode) {
@@ -10146,7 +10808,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName);
-          if (mapForSync instanceof import_core19.LWWMap) {
+          if (mapForSync instanceof import_core20.LWWMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -10184,7 +10846,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName);
-          if (mapForBucket instanceof import_core19.LWWMap) {
+          if (mapForBucket instanceof import_core20.LWWMap) {
             const treeForBucket = mapForBucket.getMerkleTree();
             const buckets = treeForBucket.getBuckets(path);
             const node = treeForBucket.getNode(path);
@@ -10566,7 +11228,7 @@ var ServerCoordinator = class {
         this.metricsService.incOp("GET", message.mapName);
         try {
           const mapForSync = await this.getMapAsync(message.mapName, "OR");
-          if (mapForSync instanceof import_core19.ORMap) {
+          if (mapForSync instanceof import_core20.ORMap) {
             const tree = mapForSync.getMerkleTree();
             const rootHash = tree.getRootHash();
             client.writer.write({
@@ -10603,7 +11265,7 @@ var ServerCoordinator = class {
         const { mapName, path } = message.payload;
         try {
           const mapForBucket = await this.getMapAsync(mapName, "OR");
-          if (mapForBucket instanceof import_core19.ORMap) {
+          if (mapForBucket instanceof import_core20.ORMap) {
             const tree = mapForBucket.getMerkleTree();
             const buckets = tree.getBuckets(path);
             const isLeaf = tree.isLeaf(path);
@@ -10647,7 +11309,7 @@ var ServerCoordinator = class {
         const { mapName: diffMapName, keys } = message.payload;
         try {
           const mapForDiff = await this.getMapAsync(diffMapName, "OR");
-          if (mapForDiff instanceof import_core19.ORMap) {
+          if (mapForDiff instanceof import_core20.ORMap) {
             const entries = [];
             const allTombstones = mapForDiff.getTombstones();
             for (const key of keys) {
@@ -10679,7 +11341,7 @@ var ServerCoordinator = class {
         const { mapName: pushMapName, entries: pushEntries } = message.payload;
         try {
           const mapForPush = await this.getMapAsync(pushMapName, "OR");
-          if (mapForPush instanceof import_core19.ORMap) {
+          if (mapForPush instanceof import_core20.ORMap) {
             let totalAdded = 0;
             let totalUpdated = 0;
             for (const entry of pushEntries) {
@@ -10807,6 +11469,106 @@ var ServerCoordinator = class {
         });
         break;
       }
+      // Phase 11.1: Full-Text Search
+      case "SEARCH": {
+        const { requestId: searchReqId, mapName: searchMapName, query: searchQuery, options: searchOptions } = message.payload;
+        if (!this.securityManager.checkPermission(client.principal, searchMapName, "READ")) {
+          logger.warn({ clientId: client.id, mapName: searchMapName }, "Access Denied: SEARCH");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: searchReqId,
+              results: [],
+              totalCount: 0,
+              error: `Access denied for map: ${searchMapName}`
+            }
+          });
+          break;
+        }
+        if (!this.searchCoordinator.isSearchEnabled(searchMapName)) {
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: searchReqId,
+              results: [],
+              totalCount: 0,
+              error: `Full-text search not enabled for map: ${searchMapName}`
+            }
+          });
+          break;
+        }
+        const searchResult = this.searchCoordinator.search(searchMapName, searchQuery, searchOptions);
+        searchResult.requestId = searchReqId;
+        logger.debug({
+          clientId: client.id,
+          mapName: searchMapName,
+          query: searchQuery,
+          resultCount: searchResult.results.length
+        }, "Search executed");
+        client.writer.write({
+          type: "SEARCH_RESP",
+          payload: searchResult
+        });
+        break;
+      }
+      // Phase 11.1b: Live Search Subscriptions
+      case "SEARCH_SUB": {
+        const { subscriptionId, mapName: subMapName, query: subQuery, options: subOptions } = message.payload;
+        if (!this.securityManager.checkPermission(client.principal, subMapName, "READ")) {
+          logger.warn({ clientId: client.id, mapName: subMapName }, "Access Denied: SEARCH_SUB");
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: subscriptionId,
+              results: [],
+              totalCount: 0,
+              error: `Access denied for map: ${subMapName}`
+            }
+          });
+          break;
+        }
+        if (!this.searchCoordinator.isSearchEnabled(subMapName)) {
+          client.writer.write({
+            type: "SEARCH_RESP",
+            payload: {
+              requestId: subscriptionId,
+              results: [],
+              totalCount: 0,
+              error: `Full-text search not enabled for map: ${subMapName}`
+            }
+          });
+          break;
+        }
+        const initialResults = this.searchCoordinator.subscribe(
+          client.id,
+          subscriptionId,
+          subMapName,
+          subQuery,
+          subOptions
+        );
+        logger.debug({
+          clientId: client.id,
+          subscriptionId,
+          mapName: subMapName,
+          query: subQuery,
+          resultCount: initialResults.length
+        }, "Search subscription created");
+        client.writer.write({
+          type: "SEARCH_RESP",
+          payload: {
+            requestId: subscriptionId,
+            results: initialResults,
+            totalCount: initialResults.length
+          }
+        });
+        break;
+      }
+      case "SEARCH_UNSUB": {
+        const { subscriptionId: unsubId } = message.payload;
+        this.searchCoordinator.unsubscribe(unsubId);
+        logger.debug({ clientId: client.id, subscriptionId: unsubId }, "Search unsubscription");
+        break;
+      }
       default:
         logger.warn({ type: message.type }, "Unknown message type");
     }
@@ -10820,7 +11582,7 @@ var ServerCoordinator = class {
       } else if (op.orRecord && op.orRecord.timestamp) {
       } else if (op.orTag) {
         try {
-          ts = import_core19.HLC.parse(op.orTag);
+          ts = import_core20.HLC.parse(op.orTag);
         } catch (e) {
         }
       }
@@ -10917,7 +11679,7 @@ var ServerCoordinator = class {
         client.writer.write({ ...message, payload: newPayload });
       }
     } else {
-      const msgData = (0, import_core19.serialize)(message);
+      const msgData = (0, import_core20.serialize)(message);
       for (const [id, client] of this.clients) {
         if (id !== excludeClientId && client.socket.readyState === 1) {
           client.writer.writeRaw(msgData);
@@ -10995,7 +11757,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core19.serialize)(batchMessage);
+      const serializedBatch = (0, import_core20.serialize)(batchMessage);
       for (const client of clients) {
         try {
           client.writer.writeRaw(serializedBatch);
@@ -11080,7 +11842,7 @@ var ServerCoordinator = class {
         payload: { events: filteredEvents },
         timestamp: this.hlc.now()
       };
-      const serializedBatch = (0, import_core19.serialize)(batchMessage);
+      const serializedBatch = (0, import_core20.serialize)(batchMessage);
       for (const client of clients) {
         sendPromises.push(new Promise((resolve, reject) => {
           try {
@@ -11278,7 +12040,7 @@ var ServerCoordinator = class {
     const localQuery = { ...query };
     delete localQuery.offset;
     delete localQuery.limit;
-    if (map instanceof import_core19.IndexedLWWMap) {
+    if (map instanceof import_core20.IndexedLWWMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const entries = map.queryEntries(coreQuery);
@@ -11288,7 +12050,7 @@ var ServerCoordinator = class {
         });
       }
     }
-    if (map instanceof import_core19.IndexedORMap) {
+    if (map instanceof import_core20.IndexedORMap) {
       const coreQuery = this.convertToCoreQuery(localQuery);
       if (coreQuery) {
         const results = map.query(coreQuery);
@@ -11296,14 +12058,14 @@ var ServerCoordinator = class {
       }
     }
     const records = /* @__PURE__ */ new Map();
-    if (map instanceof import_core19.LWWMap) {
+    if (map instanceof import_core20.LWWMap) {
       for (const key of map.allKeys()) {
         const rec = map.getRecord(key);
         if (rec && rec.value !== null) {
           records.set(key, rec);
         }
       }
-    } else if (map instanceof import_core19.ORMap) {
+    } else if (map instanceof import_core20.ORMap) {
       const items = map.items;
       for (const key of items.keys()) {
         const values = map.get(key);
@@ -11451,11 +12213,11 @@ var ServerCoordinator = class {
   async applyOpToMap(op, remoteNodeId) {
     const typeHint = op.opType === "OR_ADD" || op.opType === "OR_REMOVE" ? "OR" : "LWW";
     const map = this.getMap(op.mapName, typeHint);
-    if (typeHint === "OR" && map instanceof import_core19.LWWMap) {
+    if (typeHint === "OR" && map instanceof import_core20.LWWMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: LWWMap but received OR op");
       throw new Error("Map type mismatch: LWWMap but received OR op");
     }
-    if (typeHint === "LWW" && map instanceof import_core19.ORMap) {
+    if (typeHint === "LWW" && map instanceof import_core20.ORMap) {
       logger.error({ mapName: op.mapName }, "Map type mismatch: ORMap but received LWW op");
       throw new Error("Map type mismatch: ORMap but received LWW op");
     }
@@ -11466,7 +12228,7 @@ var ServerCoordinator = class {
       mapName: op.mapName,
       key: op.key
     };
-    if (map instanceof import_core19.LWWMap) {
+    if (map instanceof import_core20.LWWMap) {
       oldRecord = map.getRecord(op.key);
       if (this.conflictResolverHandler.hasResolvers(op.mapName)) {
         const mergeResult = await this.conflictResolverHandler.mergeWithResolver(
@@ -11494,7 +12256,7 @@ var ServerCoordinator = class {
         eventPayload.eventType = "UPDATED";
         eventPayload.record = op.record;
       }
-    } else if (map instanceof import_core19.ORMap) {
+    } else if (map instanceof import_core20.ORMap) {
       oldRecord = map.getRecords(op.key);
       if (op.opType === "OR_ADD") {
         map.apply(op.key, op.orRecord);
@@ -11510,7 +12272,7 @@ var ServerCoordinator = class {
       }
     }
     this.queryRegistry.processChange(op.mapName, map, op.key, op.record || op.orRecord, oldRecord);
-    const mapSize = map instanceof import_core19.ORMap ? map.totalRecords : map.size;
+    const mapSize = map instanceof import_core20.ORMap ? map.totalRecords : map.size;
     this.metricsService.setMapSize(op.mapName, mapSize);
     if (this.storage) {
       if (recordToStore) {
@@ -11543,6 +12305,12 @@ var ServerCoordinator = class {
       const partitionId = this.partitionService.getPartitionId(op.key);
       this.merkleTreeManager.updateRecord(partitionId, op.key, recordToStore);
     }
+    if (this.searchCoordinator.isSearchEnabled(op.mapName)) {
+      const isRemove = op.opType === "REMOVE" || op.record && op.record.value === null;
+      const value = isRemove ? null : op.record?.value ?? op.orRecord?.value;
+      const changeType = isRemove ? "remove" : oldRecord ? "update" : "add";
+      this.searchCoordinator.onDataChange(op.mapName, op.key, value, changeType);
+    }
     return { eventPayload, oldRecord };
   }
   /**
@@ -11818,11 +12586,11 @@ var ServerCoordinator = class {
       return;
     }
     const map = this.getMap(mapName, eventType === "OR_ADD" || eventType === "OR_REMOVE" ? "OR" : "LWW");
-    const oldRecord = map instanceof import_core19.LWWMap ? map.getRecord(key) : null;
+    const oldRecord = map instanceof import_core20.LWWMap ? map.getRecord(key) : null;
     if (this.partitionService.isRelated(key)) {
-      if (map instanceof import_core19.LWWMap && payload.record) {
+      if (map instanceof import_core20.LWWMap && payload.record) {
         map.merge(key, payload.record);
-      } else if (map instanceof import_core19.ORMap) {
+      } else if (map instanceof import_core20.ORMap) {
         if (eventType === "OR_ADD" && payload.orRecord) {
           map.apply(key, payload.orRecord);
         } else if (eventType === "OR_REMOVE" && payload.orTag) {
@@ -11841,9 +12609,9 @@ var ServerCoordinator = class {
     if (!this.maps.has(name)) {
       let map;
       if (typeHint === "OR") {
-        map = new import_core19.ORMap(this.hlc);
+        map = new import_core20.ORMap(this.hlc);
       } else {
-        map = new import_core19.LWWMap(this.hlc);
+        map = new import_core20.LWWMap(this.hlc);
       }
       this.maps.set(name, map);
       if (this.storage) {
@@ -11866,7 +12634,7 @@ var ServerCoordinator = class {
     this.getMap(name, typeHint);
     const loadingPromise = this.mapLoadingPromises.get(name);
     const map = this.maps.get(name);
-    const mapSize = map instanceof import_core19.LWWMap ? Array.from(map.entries()).length : map instanceof import_core19.ORMap ? map.size : 0;
+    const mapSize = map instanceof import_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.ORMap ? map.size : 0;
     logger.info({
       mapName: name,
       mapExisted,
@@ -11876,7 +12644,7 @@ var ServerCoordinator = class {
     if (loadingPromise) {
       logger.info({ mapName: name }, "[getMapAsync] Waiting for loadMapFromStorage...");
       await loadingPromise;
-      const newMapSize = map instanceof import_core19.LWWMap ? Array.from(map.entries()).length : map instanceof import_core19.ORMap ? map.size : 0;
+      const newMapSize = map instanceof import_core20.LWWMap ? Array.from(map.entries()).length : map instanceof import_core20.ORMap ? map.size : 0;
       logger.info({ mapName: name, mapSizeAfterLoad: newMapSize }, "[getMapAsync] Load completed");
     }
     return this.maps.get(name);
@@ -11893,7 +12661,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_core19.LWWMap)) {
+    if (!map || !(map instanceof import_core20.LWWMap)) {
       return null;
     }
     return map.getRecord(actualKey) ?? null;
@@ -11947,16 +12715,16 @@ var ServerCoordinator = class {
       const currentMap = this.maps.get(name);
       if (!currentMap) return;
       let targetMap = currentMap;
-      if (isOR && currentMap instanceof import_core19.LWWMap) {
+      if (isOR && currentMap instanceof import_core20.LWWMap) {
         logger.info({ mapName: name }, "Map auto-detected as ORMap. Switching type.");
-        targetMap = new import_core19.ORMap(this.hlc);
+        targetMap = new import_core20.ORMap(this.hlc);
         this.maps.set(name, targetMap);
-      } else if (!isOR && currentMap instanceof import_core19.ORMap && typeHint !== "OR") {
+      } else if (!isOR && currentMap instanceof import_core20.ORMap && typeHint !== "OR") {
         logger.info({ mapName: name }, "Map auto-detected as LWWMap. Switching type.");
-        targetMap = new import_core19.LWWMap(this.hlc);
+        targetMap = new import_core20.LWWMap(this.hlc);
         this.maps.set(name, targetMap);
       }
-      if (targetMap instanceof import_core19.ORMap) {
+      if (targetMap instanceof import_core20.ORMap) {
         for (const [key, record] of records) {
           if (key === "__tombstones__") {
             const t = record;
@@ -11969,7 +12737,7 @@ var ServerCoordinator = class {
             }
           }
         }
-      } else if (targetMap instanceof import_core19.LWWMap) {
+      } else if (targetMap instanceof import_core20.LWWMap) {
         for (const [key, record] of records) {
           if (!record.type) {
             targetMap.merge(key, record);
@@ -11980,7 +12748,7 @@ var ServerCoordinator = class {
       if (count > 0) {
         logger.info({ mapName: name, count }, "Loaded records for map");
         this.queryRegistry.refreshSubscriptions(name, targetMap);
-        const mapSize = targetMap instanceof import_core19.ORMap ? targetMap.totalRecords : targetMap.size;
+        const mapSize = targetMap instanceof import_core20.ORMap ? targetMap.totalRecords : targetMap.size;
         this.metricsService.setMapSize(name, mapSize);
       }
     } catch (err) {
@@ -12062,7 +12830,7 @@ var ServerCoordinator = class {
   reportLocalHlc() {
     let minHlc = this.hlc.now();
     for (const client of this.clients.values()) {
-      if (import_core19.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
+      if (import_core20.HLC.compare(client.lastActiveHlc, minHlc) < 0) {
         minHlc = client.lastActiveHlc;
       }
     }
@@ -12083,7 +12851,7 @@ var ServerCoordinator = class {
       let globalSafe = this.hlc.now();
       let initialized = false;
       for (const ts of this.gcReports.values()) {
-        if (!initialized || import_core19.HLC.compare(ts, globalSafe) < 0) {
+        if (!initialized || import_core20.HLC.compare(ts, globalSafe) < 0) {
           globalSafe = ts;
           initialized = true;
         }
@@ -12118,7 +12886,7 @@ var ServerCoordinator = class {
     logger.info({ olderThanMillis: olderThan.millis }, "Performing Garbage Collection");
     const now = Date.now();
     for (const [name, map] of this.maps) {
-      if (map instanceof import_core19.LWWMap) {
+      if (map instanceof import_core20.LWWMap) {
         for (const key of map.allKeys()) {
           const record = map.getRecord(key);
           if (record && record.value !== null && record.ttlMs) {
@@ -12170,7 +12938,7 @@ var ServerCoordinator = class {
             });
           }
         }
-      } else if (map instanceof import_core19.ORMap) {
+      } else if (map instanceof import_core20.ORMap) {
         const items = map.items;
         const tombstonesSet = map.tombstones;
         const tagsToExpire = [];
@@ -12273,17 +13041,17 @@ var ServerCoordinator = class {
   stringToWriteConcern(value) {
     switch (value) {
       case "FIRE_AND_FORGET":
-        return import_core19.WriteConcern.FIRE_AND_FORGET;
+        return import_core20.WriteConcern.FIRE_AND_FORGET;
       case "MEMORY":
-        return import_core19.WriteConcern.MEMORY;
+        return import_core20.WriteConcern.MEMORY;
       case "APPLIED":
-        return import_core19.WriteConcern.APPLIED;
+        return import_core20.WriteConcern.APPLIED;
       case "REPLICATED":
-        return import_core19.WriteConcern.REPLICATED;
+        return import_core20.WriteConcern.REPLICATED;
       case "PERSISTED":
-        return import_core19.WriteConcern.PERSISTED;
+        return import_core20.WriteConcern.PERSISTED;
       default:
-        return import_core19.WriteConcern.MEMORY;
+        return import_core20.WriteConcern.MEMORY;
     }
   }
   /**
@@ -12340,7 +13108,7 @@ var ServerCoordinator = class {
             }
           });
           if (op.id) {
-            this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
           }
         }
       }
@@ -12348,7 +13116,7 @@ var ServerCoordinator = class {
         this.broadcastBatch(batchedEvents, clientId);
         for (const op of ops) {
           if (op.id && this.partitionService.isLocalOwner(op.key)) {
-            this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
+            this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
           }
         }
       }
@@ -12376,7 +13144,7 @@ var ServerCoordinator = class {
         const owner = this.partitionService.getOwner(op.key);
         await this.forwardOpAndWait(op, owner);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
         }
       }
     }
@@ -12384,7 +13152,7 @@ var ServerCoordinator = class {
       await this.broadcastBatchSync(batchedEvents, clientId);
       for (const op of ops) {
         if (op.id && this.partitionService.isLocalOwner(op.key)) {
-          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.REPLICATED);
+          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.REPLICATED);
         }
       }
     }
@@ -12418,7 +13186,7 @@ var ServerCoordinator = class {
       return;
     }
     if (op.id) {
-      this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.APPLIED);
+      this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.APPLIED);
     }
     if (eventPayload) {
       batchedEvents.push({
@@ -12432,7 +13200,7 @@ var ServerCoordinator = class {
       try {
         await this.persistOpSync(op);
         if (op.id) {
-          this.writeAckManager.notifyLevel(op.id, import_core19.WriteConcern.PERSISTED);
+          this.writeAckManager.notifyLevel(op.id, import_core20.WriteConcern.PERSISTED);
         }
       } catch (err) {
         logger.error({ opId: op.id, err }, "Persistence failed");
@@ -12775,10 +13543,10 @@ var RateLimitInterceptor = class {
 };
 
 // src/utils/nativeStats.ts
-var import_core20 = require("@topgunbuild/core");
+var import_core21 = require("@topgunbuild/core");
 function getNativeModuleStatus() {
   return {
-    nativeHash: (0, import_core20.isUsingNativeHash)(),
+    nativeHash: (0, import_core21.isUsingNativeHash)(),
     sharedArrayBuffer: SharedMemoryManager.isAvailable()
   };
 }
@@ -12812,11 +13580,11 @@ function logNativeStatus() {
 
 // src/cluster/ClusterCoordinator.ts
 var import_events13 = require("events");
-var import_core21 = require("@topgunbuild/core");
+var import_core22 = require("@topgunbuild/core");
 var DEFAULT_CLUSTER_COORDINATOR_CONFIG = {
   gradualRebalancing: true,
-  migration: import_core21.DEFAULT_MIGRATION_CONFIG,
-  replication: import_core21.DEFAULT_REPLICATION_CONFIG,
+  migration: import_core22.DEFAULT_MIGRATION_CONFIG,
+  replication: import_core22.DEFAULT_REPLICATION_CONFIG,
   replicationEnabled: true
 };
 var ClusterCoordinator = class extends import_events13.EventEmitter {
@@ -13184,12 +13952,12 @@ var ClusterCoordinator = class extends import_events13.EventEmitter {
 };
 
 // src/MapWithResolver.ts
-var import_core22 = require("@topgunbuild/core");
+var import_core23 = require("@topgunbuild/core");
 var MapWithResolver = class {
   constructor(config) {
     this.mapName = config.name;
-    this.hlc = new import_core22.HLC(config.nodeId);
-    this.map = new import_core22.LWWMap(this.hlc);
+    this.hlc = new import_core23.HLC(config.nodeId);
+    this.map = new import_core23.LWWMap(this.hlc);
     this.resolverService = config.resolverService;
     this.onRejection = config.onRejection;
   }
@@ -13445,7 +14213,7 @@ function mergeWithDefaults(userConfig) {
 }
 
 // src/config/MapFactory.ts
-var import_core23 = require("@topgunbuild/core");
+var import_core24 = require("@topgunbuild/core");
 var MapFactory = class {
   /**
    * Create a MapFactory.
@@ -13469,9 +14237,9 @@ var MapFactory = class {
   createLWWMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core23.LWWMap(hlc);
+      return new import_core24.LWWMap(hlc);
     }
-    const map = new import_core23.IndexedLWWMap(hlc);
+    const map = new import_core24.IndexedLWWMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToLWWMap(map, indexDef);
     }
@@ -13487,9 +14255,9 @@ var MapFactory = class {
   createORMap(mapName, hlc) {
     const mapConfig = this.mapConfigs.get(mapName);
     if (!mapConfig || mapConfig.indexes.length === 0) {
-      return new import_core23.ORMap(hlc);
+      return new import_core24.ORMap(hlc);
     }
-    const map = new import_core23.IndexedORMap(hlc);
+    const map = new import_core24.IndexedORMap(hlc);
     for (const indexDef of mapConfig.indexes) {
       this.addIndexToORMap(map, indexDef);
     }
@@ -13526,7 +14294,7 @@ var MapFactory = class {
    * Supports dot notation for nested paths.
    */
   createAttribute(path) {
-    return (0, import_core23.simpleAttribute)(path, (record) => {
+    return (0, import_core24.simpleAttribute)(path, (record) => {
       return this.getNestedValue(record, path);
     });
   }
@@ -13658,6 +14426,7 @@ var MapFactory = class {
   ReduceTasklet,
   RepairScheduler,
   ReplicationPipeline,
+  SearchCoordinator,
   SecurityManager,
   ServerCoordinator,
   TaskletScheduler,