@topgunbuild/server 0.7.0 → 0.8.1

package/dist/index.mjs

@@ -9187,6 +9187,556 @@ var EventJournalService = class extends EventJournalImpl {
   }
 };
 
+// src/search/SearchCoordinator.ts
+import {
+  FullTextIndex
+} from "@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 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;
@@ -9444,6 +9994,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,
@@ -9467,6 +10045,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");
       });
@@ -9474,6 +10053,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 LWWMap3) {
+          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;
@@ -9540,6 +10149,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 LWWMap3) {
+        for (const [key, value] of map.entries()) {
+          entries.push([key, value]);
+        }
+      } else if (map instanceof ORMap2) {
+        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
    *
@@ -9798,6 +10460,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)) {
@@ -10739,6 +11402,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");
     }
@@ -11475,6 +12238,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 };
   }
   /**
@@ -13601,6 +14370,7 @@ export {
   ReduceTasklet,
   RepairScheduler,
   ReplicationPipeline,
+  SearchCoordinator,
   SecurityManager,
   ServerCoordinator,
   TaskletScheduler,