@topgunbuild/server 0.6.0 → 0.8.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _topgunbuild_core from '@topgunbuild/core';
-import { Timestamp, LWWRecord, ORMapRecord, Principal, EventJournalImpl, EventJournalConfig, JournalEvent, PermissionPolicy, ConsistencyLevel, ReplicationConfig, LWWMap, ORMap, PermissionType, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, ReplicationLag, ReplicationHealth, ReplicationResult, EntryProcessorDef, EntryProcessorResult, HLC, MergeRejection, ConflictResolverDef, MergeContext, MergeResult, IndexedLWWMap, IndexedORMap } from '@topgunbuild/core';
+import { Timestamp, LWWRecord, ORMapRecord, Principal, EventJournalImpl, EventJournalConfig, JournalEvent, PermissionPolicy, ConsistencyLevel, ReplicationConfig, FullTextIndexConfig, LWWMap, ORMap, PermissionType, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, ReplicationLag, ReplicationHealth, ReplicationResult, ClusterReadOptions, MerkleTree, EntryProcessorDef, EntryProcessorResult, HLC, MergeRejection, ConflictResolverDef, MergeContext, MergeResult, IndexedLWWMap, IndexedORMap, SearchUpdateType, FTSSearchOptions, SearchRespPayload, SearchOptions } from '@topgunbuild/core';
 import { WebSocket } from 'ws';
 import { Pool, PoolConfig } from 'pg';
 import pino from 'pino';
@@ -1858,6 +1858,8 @@ interface ServerCoordinatorConfig {
     eventJournalEnabled?: boolean;
     /** Event journal configuration */
     eventJournalConfig?: Partial<Omit<EventJournalServiceConfig, 'pool'>>;
+    /** Enable full-text search for specific maps */
+    fullTextSearch?: Record<string, FullTextIndexConfig>;
 }
 declare class ServerCoordinator {
     private httpServer;
@@ -1902,12 +1904,22 @@ declare class ServerCoordinator {
     private conflictResolverHandler;
     private eventJournalService?;
     private journalSubscriptions;
+    private partitionReassigner?;
+    private readReplicaHandler?;
+    private merkleTreeManager?;
+    private repairScheduler?;
+    private searchCoordinator;
     private readonly _nodeId;
     private _actualPort;
     private _actualClusterPort;
     private _readyPromise;
     private _readyResolve;
     constructor(config: ServerCoordinatorConfig);
+    /**
+     * Populate FTS indexes from existing map data.
+     * Called after storage initialization.
+     */
+    private backfillSearchIndexes;
     /** Wait for server to be fully ready (ports assigned) */
     ready(): Promise<void>;
     /**
@@ -1943,6 +1955,54 @@ declare class ServerCoordinator {
     getTaskletSchedulerStats(): TaskletSchedulerStats;
     /** Get tasklet scheduler for scheduling long-running operations */
     getTaskletScheduler(): TaskletScheduler;
+    /**
+     * 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: string, config: FullTextIndexConfig): void;
+    /**
+     * Disable full-text search for a map.
+     *
+     * @param mapName - Name of the map to disable FTS for
+     */
+    disableFullTextSearch(mapName: string): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * Get FTS index statistics for a map.
+     *
+     * @param mapName - Name of the map
+     * @returns Index stats or null if FTS not enabled
+     */
+    getFullTextSearchStats(mapName: string): {
+        documentCount: number;
+        fields: string[];
+    } | null;
+    /**
+     * Phase 10.02: Graceful cluster departure
+     *
+     * Notifies the cluster that this node is leaving and allows time for:
+     * 1. Pending replication to complete
+     * 2. Other nodes to detect departure
+     * 3. Partition reassignment to begin
+     */
+    private gracefulClusterDeparture;
+    /**
+     * Get list of partition IDs owned by this node
+     */
+    private getOwnedPartitions;
+    /**
+     * Wait for replication pipeline to flush pending operations
+     */
+    private waitForReplicationFlush;
     shutdown(): Promise<void>;
     private handleConnection;
     private handleMessage;
@@ -2052,6 +2112,16 @@ declare class ServerCoordinator {
      * Use this for queries to avoid returning empty results during initial load.
      */
     getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
+    /**
+     * Phase 10.04: Get local record for anti-entropy repair
+     * Returns the LWWRecord for a key, used by RepairScheduler
+     */
+    private getLocalRecord;
+    /**
+     * Phase 10.04: Apply repaired record from anti-entropy repair
+     * Used by RepairScheduler to apply resolved conflicts
+     */
+    private applyRepairRecord;
     private loadMapFromStorage;
     private startGarbageCollection;
     /**
@@ -2347,6 +2417,31 @@ interface FailureDetectorConfig {
     /** Initial heartbeat interval estimate (ms). Default: 1000 */
     initialHeartbeatIntervalMs: number;
 }
+declare const DEFAULT_FAILURE_DETECTOR_CONFIG: FailureDetectorConfig;
+interface NodeState {
+    /** Last heartbeat timestamp */
+    lastHeartbeat: number;
+    /** Heartbeat interval history for phi calculation */
+    intervalHistory: number[];
+    /** Whether node is currently suspected */
+    isSuspected: boolean;
+    /** Timestamp when suspicion started */
+    suspicionStartTime?: number;
+    /** Whether failure has been confirmed */
+    isConfirmedFailed: boolean;
+}
+interface FailureDetectorEvents {
+    nodeSuspected: {
+        nodeId: string;
+        phi: number;
+    };
+    nodeRecovered: {
+        nodeId: string;
+    };
+    nodeConfirmedFailed: {
+        nodeId: string;
+    };
+}
 declare class FailureDetector extends EventEmitter {
     private config;
     private nodeStates;
@@ -2460,7 +2555,7 @@ interface ClusterMember {
     isSelf: boolean;
 }
 interface ClusterMessage {
-    type: 'HELLO' | 'OP_FORWARD' | 'PARTITION_UPDATE' | 'HEARTBEAT' | 'CLUSTER_EVENT' | 'CLUSTER_QUERY_EXEC' | 'CLUSTER_QUERY_RESP' | 'CLUSTER_GC_REPORT' | 'CLUSTER_GC_COMMIT' | 'CLUSTER_LOCK_REQ' | 'CLUSTER_LOCK_RELEASE' | 'CLUSTER_LOCK_GRANTED' | 'CLUSTER_LOCK_RELEASED' | 'CLUSTER_CLIENT_DISCONNECTED' | 'CLUSTER_TOPIC_PUB';
+    type: 'HELLO' | 'MEMBER_LIST' | 'OP_FORWARD' | 'PARTITION_UPDATE' | 'HEARTBEAT' | 'CLUSTER_EVENT' | 'CLUSTER_QUERY_EXEC' | 'CLUSTER_QUERY_RESP' | 'CLUSTER_GC_REPORT' | 'CLUSTER_GC_COMMIT' | 'CLUSTER_LOCK_REQ' | 'CLUSTER_LOCK_RELEASE' | 'CLUSTER_LOCK_GRANTED' | 'CLUSTER_LOCK_RELEASED' | 'CLUSTER_CLIENT_DISCONNECTED' | 'CLUSTER_TOPIC_PUB' | 'CLUSTER_MERKLE_ROOT_REQ' | 'CLUSTER_MERKLE_ROOT_RESP' | 'CLUSTER_MERKLE_BUCKETS_REQ' | 'CLUSTER_MERKLE_BUCKETS_RESP' | 'CLUSTER_MERKLE_KEYS_REQ' | 'CLUSTER_MERKLE_KEYS_RESP' | 'CLUSTER_REPAIR_DATA_REQ' | 'CLUSTER_REPAIR_DATA_RESP';
     senderId: string;
     payload: any;
 }
@@ -2501,6 +2596,21 @@ declare class ClusterManager extends EventEmitter {
      * Handle incoming heartbeat from a peer.
      */
     private handleHeartbeat;
+    /**
+     * Send current member list to a specific node (gossip protocol).
+     * Called when a new node joins to propagate cluster topology.
+     */
+    private sendMemberList;
+    /**
+     * Broadcast member list to all connected nodes.
+     * Called when cluster membership changes.
+     */
+    private broadcastMemberList;
+    /**
+     * Handle incoming member list from a peer (gossip protocol).
+     * Attempts to connect to unknown members.
+     */
+    private handleMemberList;
     /**
      * Handle confirmed node failure.
      */
@@ -3187,6 +3297,505 @@ declare class ClusterCoordinator extends EventEmitter {
     private setupEventHandlers;
 }
 
+/**
+ * PartitionReassigner - Automatic Partition Failover
+ *
+ * Handles automatic reassignment of partitions when nodes fail:
+ * - Promotes backup nodes to owners
+ * - Assigns new backups from remaining cluster
+ * - Coordinates with MigrationManager for data transfer
+ * - Broadcasts partition table updates
+ *
+ * This is Phase 10.02 of the TopGun cluster enhancements.
+ */
+
+interface PartitionReassignerConfig {
+    /** Delay before reassigning partitions after failure detection (ms). Default: 1000 */
+    reassignmentDelayMs: number;
+    /** Maximum concurrent partition transfers. Default: 10 */
+    maxConcurrentTransfers: number;
+    /** Enable automatic backup promotion. Default: true */
+    autoPromoteBackups: boolean;
+    /** Enable automatic new backup assignment. Default: true */
+    autoAssignNewBackups: boolean;
+}
+declare const DEFAULT_REASSIGNER_CONFIG: PartitionReassignerConfig;
+interface ReassignmentEvent {
+    type: 'backup-promoted' | 'new-backup-assigned' | 'reassignment-complete';
+    partitionId: number;
+    previousOwner?: string;
+    newOwner?: string;
+    backups?: string[];
+    failedNodeId?: string;
+}
+interface FailoverStatus {
+    inProgress: boolean;
+    failedNodeId?: string;
+    partitionsReassigned: number;
+    partitionsPending: number;
+    startedAt?: number;
+    completedAt?: number;
+}
+declare class PartitionReassigner extends EventEmitter {
+    private config;
+    private clusterManager;
+    private partitionService;
+    private failoverInProgress;
+    private currentFailedNode?;
+    private reassignmentStartTime?;
+    private partitionsReassigned;
+    private pendingReassignments;
+    private reassignmentTimer?;
+    constructor(clusterManager: ClusterManager, partitionService: PartitionService, config?: Partial<PartitionReassignerConfig>);
+    private setupEventHandlers;
+    /**
+     * Handle a node failure - initiates failover process
+     */
+    private handleNodeFailure;
+    /**
+     * Handle a graceful node departure
+     */
+    private handleNodeDeparture;
+    /**
+     * Execute the failover process for a failed node
+     */
+    private executeFailover;
+    /**
+     * Find all partitions that need reassignment
+     */
+    private findOrphanedPartitions;
+    /**
+     * Reassign a single partition
+     */
+    private reassignPartition;
+    /**
+     * Select backup nodes for a partition
+     */
+    private selectBackups;
+    /**
+     * Complete the failover process
+     */
+    private completeFailover;
+    /**
+     * Get current failover status
+     */
+    getStatus(): FailoverStatus;
+    /**
+     * Check if failover is in progress
+     */
+    isFailoverInProgress(): boolean;
+    /**
+     * Force immediate reassignment (for testing/manual intervention)
+     */
+    forceReassignment(failedNodeId: string): void;
+    /**
+     * Stop any pending reassignment
+     */
+    stop(): void;
+}
+
+/**
+ * ReadReplicaHandler - Read Scaling via Replicas
+ *
+ * Phase 10.03: Enables reading from backup nodes to:
+ * - Scale read throughput linearly with replicas
+ * - Reduce latency by reading from nearest replica
+ * - Provide availability during owner unavailability
+ *
+ * Supports three consistency levels for reads:
+ * - STRONG: Read from partition owner (current behavior)
+ * - EVENTUAL: Read from any replica (owner or backup)
+ * - LOCAL: Read from local node if it's a replica
+ */
+
+interface ReadReplicaConfig {
+    /** Default consistency for reads. Default: STRONG */
+    defaultConsistency: ConsistencyLevel;
+    /** Maximum staleness for eventual reads in ms. Default: 5000 */
+    maxStalenessMs: number;
+    /** Prefer local replica over remote. Default: true */
+    preferLocalReplica: boolean;
+    /** Load balancing strategy for replica selection. Default: 'latency-based' */
+    loadBalancing: 'round-robin' | 'least-connections' | 'latency-based';
+}
+declare const DEFAULT_READ_REPLICA_CONFIG: ReadReplicaConfig;
+interface ReadResult<T> {
+    value: T | null;
+    version?: Timestamp;
+    source: string;
+    isOwner: boolean;
+    staleness?: number;
+}
+interface ReadRequest {
+    mapName: string;
+    key: string;
+    options?: ClusterReadOptions;
+}
+declare class ReadReplicaHandler extends EventEmitter {
+    private config;
+    private partitionService;
+    private clusterManager;
+    private lagTracker?;
+    private nodeId;
+    private roundRobinCounters;
+    constructor(partitionService: PartitionService, clusterManager: ClusterManager, nodeId: string, lagTracker?: LagTracker, config?: Partial<ReadReplicaConfig>);
+    /**
+     * Determine if a read request can be served locally
+     */
+    canServeLocally(request: ReadRequest): boolean;
+    /**
+     * Determine which node should handle the read
+     */
+    selectReadNode(request: ReadRequest): string | null;
+    /**
+     * Select replica using configured load balancing strategy
+     */
+    private selectByStrategy;
+    /**
+     * Round-robin selection
+     */
+    private selectRoundRobin;
+    /**
+     * Latency-based selection using lag tracker
+     */
+    private selectByLatency;
+    /**
+     * Get estimated staleness for a node in ms
+     */
+    private getNodeStaleness;
+    /**
+     * Check if a node is alive in the cluster
+     */
+    private isNodeAlive;
+    /**
+     * Select first alive backup from list
+     */
+    private selectAliveBackup;
+    /**
+     * Create read response metadata
+     */
+    createReadMetadata(key: string, options?: ClusterReadOptions): {
+        source: string;
+        isOwner: boolean;
+        consistency: ConsistencyLevel;
+    };
+    /**
+     * Check if local node should forward read to owner
+     */
+    shouldForwardRead(request: ReadRequest): boolean;
+    /**
+     * Get metrics for monitoring
+     */
+    getMetrics(): {
+        defaultConsistency: ConsistencyLevel;
+        preferLocalReplica: boolean;
+        loadBalancing: string;
+        roundRobinPartitions: number;
+    };
+}
+
+/**
+ * MerkleTreeManager - Per-Partition Merkle Tree Management
+ *
+ * Phase 10.04: Manages Merkle trees for each partition to enable:
+ * - Efficient delta sync between nodes
+ * - Anti-entropy repair detection
+ * - Incremental updates on writes
+ *
+ * Each partition maintains its own Merkle tree for independent
+ * consistency checking and repair.
+ */
+
+interface MerkleTreeManagerConfig {
+    /** Tree depth for Merkle trees. Default: 3 */
+    treeDepth: number;
+    /** Enable automatic tree updates on write. Default: true */
+    autoUpdate: boolean;
+    /** Lazy initialization of trees. Default: true */
+    lazyInit: boolean;
+}
+declare const DEFAULT_MERKLE_TREE_CONFIG: MerkleTreeManagerConfig;
+interface MerkleComparisonResult {
+    partitionId: number;
+    localRoot: number;
+    remoteRoot: number;
+    needsSync: boolean;
+    differingBuckets: string[];
+}
+interface PartitionMerkleInfo {
+    partitionId: number;
+    rootHash: number;
+    keyCount: number;
+    lastUpdated: number;
+}
+declare class MerkleTreeManager extends EventEmitter {
+    private config;
+    private trees;
+    private keyCounts;
+    private lastUpdated;
+    private nodeId;
+    constructor(nodeId: string, config?: Partial<MerkleTreeManagerConfig>);
+    /**
+     * Get or create a Merkle tree for a partition
+     */
+    getTree(partitionId: number): MerkleTree;
+    /**
+     * Build tree for a partition from existing data
+     */
+    buildTree(partitionId: number, records: Map<string, LWWRecord<any>>): void;
+    /**
+     * Incrementally update tree when a record changes
+     */
+    updateRecord(partitionId: number, key: string, record: LWWRecord<any>): void;
+    /**
+     * Remove a key from the tree (e.g., after GC)
+     */
+    removeRecord(partitionId: number, key: string): void;
+    /**
+     * Get the path prefix for a key in the Merkle tree
+     */
+    private getKeyPath;
+    /**
+     * Get root hash for a partition
+     */
+    getRootHash(partitionId: number): number;
+    /**
+     * Compare local tree with remote root hash
+     */
+    compareWithRemote(partitionId: number, remoteRoot: number): MerkleComparisonResult;
+    /**
+     * Find buckets that differ between local and remote tree
+     * Note: This is a simplified version - full implementation would
+     * need to exchange bucket hashes with the remote node
+     */
+    private findDifferingBuckets;
+    /**
+     * Recursively collect all leaf bucket paths
+     */
+    private collectLeafBuckets;
+    /**
+     * Get bucket hashes for a partition at a given path
+     */
+    getBuckets(partitionId: number, path: string): Record<string, number>;
+    /**
+     * Get keys in a specific bucket
+     */
+    getKeysInBucket(partitionId: number, path: string): string[];
+    /**
+     * Get all keys across all buckets for a partition
+     */
+    getAllKeys(partitionId: number): string[];
+    /**
+     * Recursively collect all keys from the tree
+     */
+    private collectAllKeys;
+    /**
+     * Get info about all managed partitions
+     */
+    getPartitionInfos(): PartitionMerkleInfo[];
+    /**
+     * Get info for a specific partition
+     */
+    getPartitionInfo(partitionId: number): PartitionMerkleInfo | null;
+    /**
+     * Clear tree for a partition (e.g., after migration)
+     */
+    clearPartition(partitionId: number): void;
+    /**
+     * Clear all trees
+     */
+    clearAll(): void;
+    /**
+     * Get metrics for monitoring
+     */
+    getMetrics(): {
+        totalPartitions: number;
+        totalKeys: number;
+        averageKeysPerPartition: number;
+    };
+    /**
+     * Serialize tree state for network transfer
+     */
+    serializeTree(partitionId: number): {
+        rootHash: number;
+        buckets: Record<string, Record<string, number>>;
+    } | null;
+    private collectBucketsAtDepth;
+}
+
+/**
+ * RepairScheduler - Anti-Entropy Repair System
+ *
+ * Phase 10.04: Proactively detects and repairs data inconsistencies:
+ * - Periodic scanning of partitions
+ * - Merkle tree-based difference detection
+ * - LWW conflict resolution
+ * - Throttled repair execution
+ *
+ * Based on Cassandra/Dynamo anti-entropy patterns.
+ */
+
+interface RepairConfig {
+    /** Enable anti-entropy repair. Default: true */
+    enabled: boolean;
+    /** Interval between full scans in ms. Default: 3600000 (1 hour) */
+    scanIntervalMs: number;
+    /** Keys per repair batch. Default: 1000 */
+    repairBatchSize: number;
+    /** Maximum concurrent partition repairs. Default: 2 */
+    maxConcurrentRepairs: number;
+    /** Delay between batches in ms. Default: 100 */
+    throttleMs: number;
+    /** Prioritize recently modified partitions. Default: true */
+    prioritizeRecent: boolean;
+    /** Timeout for network requests in ms. Default: 5000 */
+    requestTimeoutMs: number;
+}
+declare const DEFAULT_REPAIR_CONFIG: RepairConfig;
+interface RepairTask {
+    partitionId: number;
+    replicaNodeId: string;
+    priority: 'high' | 'normal' | 'low';
+    scheduledAt: number;
+}
+interface RepairResult {
+    partitionId: number;
+    replicaNodeId: string;
+    keysScanned: number;
+    keysRepaired: number;
+    durationMs: number;
+    success: boolean;
+    error?: string;
+}
+interface RepairMetrics {
+    scansCompleted: number;
+    repairsExecuted: number;
+    keysRepaired: number;
+    errorsEncountered: number;
+    lastScanTime?: number;
+    averageRepairDurationMs: number;
+}
+type RecordGetter = (key: string) => LWWRecord<any> | undefined;
+type RecordSetter = (key: string, record: LWWRecord<any>) => void;
+declare class RepairScheduler extends EventEmitter {
+    private config;
+    private merkleManager;
+    private clusterManager;
+    private partitionService;
+    private nodeId;
+    private repairQueue;
+    private activeRepairs;
+    private scanTimer?;
+    private processTimer?;
+    private started;
+    private pendingRequests;
+    private metrics;
+    private getRecord?;
+    private setRecord?;
+    constructor(merkleManager: MerkleTreeManager, clusterManager: ClusterManager, partitionService: PartitionService, nodeId: string, config?: Partial<RepairConfig>);
+    /**
+     * Set data access callbacks
+     */
+    setDataAccessors(getRecord: RecordGetter, setRecord: RecordSetter): void;
+    /**
+     * Setup network message handlers
+     */
+    private setupNetworkHandlers;
+    /**
+     * Handle incoming cluster messages
+     */
+    private handleClusterMessage;
+    private handleMerkleRootReq;
+    private handleMerkleBucketsReq;
+    private handleMerkleKeysReq;
+    private handleRepairDataReq;
+    private handleResponse;
+    /**
+     * Start the repair scheduler
+     */
+    start(): void;
+    /**
+     * Stop the repair scheduler
+     */
+    stop(): void;
+    /**
+     * Schedule a full scan of all owned partitions
+     */
+    scheduleFullScan(): void;
+    /**
+     * Schedule repair for a specific partition
+     */
+    schedulePartitionRepair(partitionId: number, priority?: 'high' | 'normal' | 'low'): void;
+    /**
+     * Sort repair queue by priority
+     */
+    private sortRepairQueue;
+    /**
+     * Process the repair queue
+     */
+    private processRepairQueue;
+    /**
+     * Execute repair for a partition-replica pair
+     */
+    private executeRepair;
+    /**
+     * Send a request and wait for response
+     */
+    private sendRequest;
+    /**
+     * Request Merkle root from remote node
+     */
+    private requestRemoteMerkleRoot;
+    /**
+     * Find keys that differ between local and remote using bucket exchange
+     */
+    private findDifferences;
+    /**
+     * Repair a single key
+     */
+    private repairKey;
+    /**
+     * Resolve conflict between two records using LWW
+     */
+    resolveConflict<T>(a: LWWRecord<T> | undefined, b: LWWRecord<T> | undefined): LWWRecord<T> | null;
+    /**
+     * Compare two timestamps
+     */
+    private compareTimestamps;
+    /**
+     * Get partitions owned by this node
+     */
+    private getOwnedPartitions;
+    /**
+     * Get partitions where this node is a backup
+     */
+    private getReplicaPartitions;
+    /**
+     * Update average repair duration
+     */
+    private updateAverageRepairDuration;
+    /**
+     * Get repair metrics
+     */
+    getMetrics(): RepairMetrics;
+    /**
+     * Get repair queue status
+     */
+    getQueueStatus(): {
+        queueLength: number;
+        activeRepairs: number;
+        maxConcurrent: number;
+    };
+    /**
+     * Force immediate repair for a partition
+     */
+    forceRepair(partitionId: number): void;
+    /**
+     * Sleep utility
+     */
+    private sleep;
+}
+
 /**
  * Configuration for the processor sandbox.
  */
@@ -3872,4 +4481,266 @@ declare class MapFactory {
     getConfig(): ServerIndexConfig;
 }
 
-export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type ClusterConfig, ClusterCoordinator, type ClusterCoordinatorConfig, type ClusterCoordinatorEvents, ClusterManager, type ClusterMember, type ClusterMessage, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, ConflictResolverHandler, type ConflictResolverHandlerConfig, ConflictResolverService, type ConflictResolverServiceConfig, type ConnectionContext, ConnectionRateLimiter, DEFAULT_CLUSTER_COORDINATOR_CONFIG, DEFAULT_CONFLICT_RESOLVER_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_JOURNAL_SERVICE_CONFIG, DEFAULT_LAG_TRACKER_CONFIG, DEFAULT_SANDBOX_CONFIG, EntryProcessorHandler, type EntryProcessorHandlerConfig, EventJournalService, type EventJournalServiceConfig, type ExportOptions, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, type IndexDefinition, IteratorTasklet, type IteratorTaskletConfig, type LagInfo, LagTracker, type LagTrackerConfig, LockManager, type Logger, MapFactory, type MapIndexConfig, MapTasklet, MapWithResolver, type MapWithResolverConfig, MemoryServerAdapter, type MergeWithResolverResult, MigrationManager, type NativeModuleStatus, type NativeStats, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PartitionDistribution, PartitionService, type PartitionServiceConfig, type PartitionServiceEvents, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, ProcessorSandbox, type ProcessorSandboxConfig, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, ReduceTasklet, ReplicationPipeline, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerIndexConfig, type ServerOp, type SetWithResolverResult, type StorageValue, type Tasklet, TaskletScheduler, type TaskletSchedulerConfig, type TaskletSchedulerStats, TimestampInterceptor, coalescingPresets, createEventPayloadPool, createMessagePool, createRecordPool, createTimestampPool, getCoalescingPreset, getGlobalBufferPool, getGlobalEventPayloadPool, getGlobalMessagePool, getGlobalRecordPool, getGlobalTimestampPool, getNativeModuleStatus, getNativeStats, logNativeStatus, logger, mergeWithDefaults, setGlobalBufferPool, setGlobalEventPayloadPool, setGlobalMessagePool, setGlobalRecordPool, setGlobalTimestampPool, validateIndexConfig };
+/**
+ * SearchCoordinator - Server-side Full-Text Search Handler
+ *
+ * Manages FullTextIndex instances per map and handles search requests.
+ * Part of Phase 11.1a: Server-side BM25 Search.
+ * Phase 11.1b: Live Search Subscriptions with delta updates.
+ *
+ * @module search/SearchCoordinator
+ */
+
+/**
+ * Result item returned from server search.
+ */
+interface ServerSearchResult {
+    key: string;
+    value: unknown;
+    score: number;
+    matchedTerms: string[];
+}
+/**
+ * Configuration for enabling search on a map.
+ */
+interface SearchConfig extends FullTextIndexConfig {
+}
+/**
+ * Callback type for sending updates to clients.
+ */
+type SendUpdateCallback = (clientId: string, subscriptionId: string, key: string, value: unknown, score: number, matchedTerms: string[], type: SearchUpdateType) => void;
+/**
+ * Batched update for a single document change.
+ */
+interface BatchedUpdate {
+    key: string;
+    value: unknown;
+    score: number;
+    matchedTerms: string[];
+    type: SearchUpdateType;
+}
+/**
+ * Callback type for sending batched updates to clients.
+ */
+type SendBatchUpdateCallback = (clientId: string, subscriptionId: string, updates: BatchedUpdate[]) => void;
+/**
+ * SearchCoordinator manages full-text search indexes for the server.
+ *
+ * Responsibilities:
+ * - Maintain FullTextIndex per enabled map
+ * - Execute one-shot search queries
+ * - Update indexes when data changes
+ *
+ * @example
+ * ```typescript
+ * const searchCoordinator = new SearchCoordinator();
+ *
+ * // Enable FTS for a map
+ * searchCoordinator.enableSearch('articles', {
+ *   fields: ['title', 'body'],
+ *   tokenizer: { minLength: 2 },
+ *   bm25: { k1: 1.2, b: 0.75 }
+ * });
+ *
+ * // Search
+ * const results = searchCoordinator.search('articles', 'machine learning', {
+ *   limit: 20,
+ *   boost: { title: 2.0 }
+ * });
+ * ```
+ */
+declare class SearchCoordinator {
+    /** Map name → FullTextIndex */
+    private readonly indexes;
+    /** Map name → FullTextIndexConfig (for reference) */
+    private readonly configs;
+    /** Callback to get document value by key (injected by ServerCoordinator) */
+    private getDocumentValue?;
+    /** Subscription ID → SearchSubscription */
+    private readonly subscriptions;
+    /** Map name → Set of subscription IDs */
+    private readonly subscriptionsByMap;
+    /** Client ID → Set of subscription IDs */
+    private readonly subscriptionsByClient;
+    /** Callback for sending updates to clients */
+    private sendUpdate?;
+    /** Callback for sending batched updates to clients */
+    private sendBatchUpdate?;
+    /** Queue of pending notifications per map */
+    private readonly pendingNotifications;
+    /** Timer for batching notifications */
+    private notificationTimer;
+    /** Batch interval in milliseconds (~1 frame at 60fps) */
+    private readonly BATCH_INTERVAL;
+    constructor();
+    /**
+     * Set the callback for sending updates to clients.
+     * Called by ServerCoordinator during initialization.
+     */
+    setSendUpdateCallback(callback: SendUpdateCallback): void;
+    /**
+     * 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: SendBatchUpdateCallback): void;
+    /**
+     * Set the callback for retrieving document values.
+     * Called by ServerCoordinator during initialization.
+     */
+    setDocumentValueGetter(getter: (mapName: string, key: string) => unknown | undefined): void;
+    /**
+     * 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: string, config: SearchConfig): void;
+    /**
+     * Disable full-text search for a map.
+     *
+     * @param mapName - Name of the map to disable FTS for
+     */
+    disableSearch(mapName: string): void;
+    /**
+     * Check if FTS is enabled for a map.
+     */
+    isSearchEnabled(mapName: string): boolean;
+    /**
+     * Get enabled map names.
+     */
+    getEnabledMaps(): string[];
+    /**
+     * 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: string, query: string, options?: FTSSearchOptions): SearchRespPayload;
+    /**
+     * 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: string, key: string, value: Record<string, unknown> | null | undefined, changeType: 'add' | 'update' | 'remove'): void;
+    /**
+     * 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: string, entries: Iterable<[string, Record<string, unknown> | null]>): void;
+    /**
+     * Get index statistics for monitoring.
+     */
+    getIndexStats(mapName: string): {
+        documentCount: number;
+        fields: string[];
+    } | null;
+    /**
+     * Clear all indexes (for testing or shutdown).
+     */
+    clear(): void;
+    /**
+     * 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: string, subscriptionId: string, mapName: string, query: string, options?: SearchOptions): ServerSearchResult[];
+    /**
+     * Unsubscribe from a live search.
+     *
+     * @param subscriptionId - Subscription to remove
+     */
+    unsubscribe(subscriptionId: string): void;
+    /**
+     * Unsubscribe all subscriptions for a client.
+     * Called when a client disconnects.
+     *
+     * @param clientId - ID of the disconnected client
+     */
+    unsubscribeClient(clientId: string): void;
+    /**
+     * Get the number of active subscriptions.
+     */
+    getSubscriptionCount(): number;
+    /**
+     * 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
+     */
+    private notifySubscribers;
+    /**
+     * 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
+     */
+    private scoreDocument;
+    /**
+     * 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: string, key: string, value: Record<string, unknown> | null, changeType: 'add' | 'update' | 'remove'): void;
+    /**
+     * Schedule a flush of pending notifications.
+     * Uses setTimeout to batch notifications within BATCH_INTERVAL window.
+     */
+    private scheduleNotificationFlush;
+    /**
+     * Flush all pending notifications.
+     * Processes each map's notifications and sends batched updates.
+     */
+    flushNotifications(): void;
+    /**
+     * 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
+     */
+    private processBatchedNotifications;
+    /**
+     * 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
+     */
+    private computeSubscriptionUpdate;
+}
+
+export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type ClusterConfig, ClusterCoordinator, type ClusterCoordinatorConfig, type ClusterCoordinatorEvents, ClusterManager, type ClusterMember, type ClusterMessage, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, ConflictResolverHandler, type ConflictResolverHandlerConfig, ConflictResolverService, type ConflictResolverServiceConfig, type ConnectionContext, ConnectionRateLimiter, DEFAULT_CLUSTER_COORDINATOR_CONFIG, DEFAULT_CONFLICT_RESOLVER_CONFIG, DEFAULT_FAILURE_DETECTOR_CONFIG, DEFAULT_INDEX_CONFIG, DEFAULT_JOURNAL_SERVICE_CONFIG, DEFAULT_LAG_TRACKER_CONFIG, DEFAULT_MERKLE_TREE_CONFIG, DEFAULT_READ_REPLICA_CONFIG, DEFAULT_REASSIGNER_CONFIG, DEFAULT_REPAIR_CONFIG, DEFAULT_SANDBOX_CONFIG, EntryProcessorHandler, type EntryProcessorHandlerConfig, EventJournalService, type EventJournalServiceConfig, type ExportOptions, type FailoverStatus, FailureDetector, type FailureDetectorConfig, type FailureDetectorEvents, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, type IndexDefinition, IteratorTasklet, type IteratorTaskletConfig, type LagInfo, LagTracker, type LagTrackerConfig, LockManager, type Logger, MapFactory, type MapIndexConfig, MapTasklet, MapWithResolver, type MapWithResolverConfig, MemoryServerAdapter, type MergeWithResolverResult, type MerkleComparisonResult, MerkleTreeManager, type MerkleTreeManagerConfig, MigrationManager, type NativeModuleStatus, type NativeStats, type NodeState, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PartitionDistribution, type PartitionMerkleInfo, PartitionReassigner, type PartitionReassignerConfig, PartitionService, type PartitionServiceConfig, type PartitionServiceEvents, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, ProcessorSandbox, type ProcessorSandboxConfig, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, type ReadReplicaConfig, ReadReplicaHandler, type ReadRequest, type ReadResult, type ReassignmentEvent, ReduceTasklet, type RepairConfig, type RepairMetrics, type RepairResult, RepairScheduler, type RepairTask, ReplicationPipeline, type SearchConfig, SearchCoordinator, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerIndexConfig, type ServerOp, type ServerSearchResult, type SetWithResolverResult, type StorageValue, type Tasklet, TaskletScheduler, type TaskletSchedulerConfig, type TaskletSchedulerStats, TimestampInterceptor, coalescingPresets, createEventPayloadPool, createMessagePool, createRecordPool, createTimestampPool, getCoalescingPreset, getGlobalBufferPool, getGlobalEventPayloadPool, getGlobalMessagePool, getGlobalRecordPool, getGlobalTimestampPool, getNativeModuleStatus, getNativeStats, logNativeStatus, logger, mergeWithDefaults, setGlobalBufferPool, setGlobalEventPayloadPool, setGlobalMessagePool, setGlobalRecordPool, setGlobalTimestampPool, validateIndexConfig };