@topgunbuild/server 0.9.0 → 0.10.0

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _topgunbuild_core 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 { Timestamp, LWWRecord, ORMapRecord, Principal, EventJournalImpl, EventJournalConfig, JournalEvent, SearchUpdateType, FullTextIndexConfig, FTSSearchOptions, SearchRespPayload, SearchOptions, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, PermissionPolicy, ConsistencyLevel, ReplicationConfig, LWWMap, ORMap, PermissionType, ReplicationLag, ReplicationHealth, ReplicationResult, ClusterReadOptions, MerkleTree, EntryProcessorDef, EntryProcessorResult, HLC, MergeRejection, ConflictResolverDef, MergeContext, MergeResult, IndexedLWWMap, IndexedORMap } from '@topgunbuild/core';
 import { WebSocket } from 'ws';
 import { Pool, PoolConfig } from 'pg';
 import pino from 'pino';
@@ -1782,1085 +1782,1454 @@ declare class EventJournalService extends EventJournalImpl {
     getPendingPersistCount(): number;
 }
 
-interface ServerCoordinatorConfig {
-    port: number;
-    nodeId: string;
-    storage?: IServerStorage;
-    jwtSecret?: string;
-    host?: string;
-    clusterPort?: number;
-    peers?: string[];
-    securityPolicies?: PermissionPolicy[];
-    /** Callback to resolve dynamic peer addresses after ports are known */
-    resolvePeers?: () => string[];
-    interceptors?: IInterceptor[];
-    metricsPort?: number;
-    discovery?: 'manual' | 'kubernetes';
-    serviceName?: string;
-    discoveryInterval?: number;
-    tls?: TLSConfig;
-    clusterTls?: ClusterTLSConfig;
-    /** Total event queue capacity for bounded queue (default: 10000) */
-    eventQueueCapacity?: number;
-    /** Number of event queue stripes for parallel processing (default: 4) */
-    eventStripeCount?: number;
-    /** Enable/disable backpressure (default: true) */
-    backpressureEnabled?: boolean;
-    /** How often to force sync processing (default: 100 operations) */
-    backpressureSyncFrequency?: number;
-    /** Maximum pending async operations before blocking (default: 1000) */
-    backpressureMaxPending?: number;
-    /** Backoff timeout in ms when at capacity (default: 5000) */
-    backpressureBackoffMs?: number;
-    /** Enable/disable write coalescing (default: true) */
-    writeCoalescingEnabled?: boolean;
-    /** Coalescing preset: 'conservative', 'balanced', 'highThroughput', 'aggressive' (default: 'highThroughput') */
-    writeCoalescingPreset?: CoalescingPreset;
-    /** Maximum messages to batch before forcing flush (default: 500 for highThroughput) */
-    writeCoalescingMaxBatch?: number;
-    /** Maximum delay before flushing in ms (default: 10 for highThroughput) */
-    writeCoalescingMaxDelayMs?: number;
-    /** Maximum batch size in bytes (default: 262144/256KB for highThroughput) */
-    writeCoalescingMaxBytes?: number;
-    /** WebSocket backlog for pending connections (default: 511) */
-    wsBacklog?: number;
-    /** Enable WebSocket per-message compression (default: false for CPU savings) */
-    wsCompression?: boolean;
-    /** Maximum WebSocket payload size in bytes (default: 64MB) */
-    wsMaxPayload?: number;
-    /** Maximum server connections (default: 10000) */
-    maxConnections?: number;
-    /** Server timeout in ms (default: 120000 = 2 min) */
-    serverTimeout?: number;
-    /** Keep-alive timeout in ms (default: 5000) */
-    keepAliveTimeout?: number;
-    /** Headers timeout in ms (default: 60000) */
-    headersTimeout?: number;
-    /** Enable connection rate limiting (default: true) */
-    rateLimitingEnabled?: boolean;
-    /** Maximum new connections per second (default: 100) */
-    maxConnectionsPerSecond?: number;
-    /** Maximum pending connections (default: 1000) */
-    maxPendingConnections?: number;
-    /** Enable worker pool for CPU-bound operations (default: false) */
-    workerPoolEnabled?: boolean;
-    /** Worker pool configuration */
-    workerPoolConfig?: Partial<WorkerPoolConfig>;
-    /** Default timeout for Write Concern acknowledgments in ms (default: 5000) */
-    writeAckTimeout?: number;
-    /** Enable replication to backup nodes (default: true when cluster has peers) */
-    replicationEnabled?: boolean;
-    /** Default consistency level for replication (default: EVENTUAL) */
-    defaultConsistency?: ConsistencyLevel;
-    /** Replication configuration */
-    replicationConfig?: Partial<ReplicationConfig>;
-    /** Enable event journal for audit/CDC (default: false) */
-    eventJournalEnabled?: boolean;
-    /** Event journal configuration */
-    eventJournalConfig?: Partial<Omit<EventJournalServiceConfig, 'pool'>>;
-    /** Enable full-text search for specific maps */
-    fullTextSearch?: Record<string, FullTextIndexConfig>;
+/**
+ * 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.
+ * Phase 14.2: Distributed Live Subscriptions support.
+ *
+ * @module search/SearchCoordinator
+ */
+
+/**
+ * Result item returned from server search.
+ */
+interface ServerSearchResult {
+    key: string;
+    value: unknown;
+    score: number;
+    matchedTerms: string[];
 }
-declare class ServerCoordinator {
-    private httpServer;
-    private metricsServer?;
-    private metricsService;
-    private wss;
-    private clients;
-    private interceptors;
-    private maps;
-    private hlc;
-    private storage?;
-    private jwtSecret;
-    private queryRegistry;
-    private cluster;
-    private partitionService;
-    private replicationPipeline?;
-    private lockManager;
-    private topicManager;
-    private securityManager;
-    private systemManager;
-    private pendingClusterQueries;
-    private gcInterval?;
-    private heartbeatCheckInterval?;
-    private gcReports;
-    private mapLoadingPromises;
-    private pendingBatchOperations;
-    private eventExecutor;
-    private backpressure;
-    private writeCoalescingEnabled;
-    private writeCoalescingOptions;
-    private rateLimiter;
-    private rateLimitingEnabled;
-    private workerPool?;
-    private merkleWorker?;
-    private crdtMergeWorker?;
-    private serializationWorker?;
-    private eventPayloadPool;
-    private taskletScheduler;
-    private writeAckManager;
-    private counterHandler;
-    private entryProcessorHandler;
-    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);
+/**
+ * Configuration for enabling search on a map.
+ */
+interface SearchConfig extends FullTextIndexConfig {
+}
+/**
+ * Cached result for a document in a subscription.
+ */
+interface CachedResult {
+    score: number;
+    matchedTerms: string[];
+}
+/**
+ * Represents a live search subscription.
+ */
+interface SearchSubscription {
+    /** Unique subscription ID */
+    id: string;
+    /** ID of the subscribed client */
+    clientId: string;
+    /** Name of the map being searched */
+    mapName: string;
+    /** Original query string */
+    query: string;
+    /** Tokenized query terms for fast comparison */
+    queryTerms: string[];
+    /** Search options (limit, minScore, boost) */
+    options: SearchOptions;
+    /** Cache of current results for delta computation */
+    currentResults: Map<string, CachedResult>;
+    /** If set, send updates to this coordinator node instead of local client */
+    coordinatorNodeId?: string;
+    /** True if registered via CLUSTER_SUB_REGISTER */
+    isDistributed?: boolean;
+}
+/**
+ * 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 extends EventEmitter {
+    /** 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;
+    /** Node ID for this server (set during init) */
+    private nodeId?;
+    constructor();
     /**
-     * Populate FTS indexes from existing map data.
-     * Called after storage initialization.
+     * Set the node ID for this server.
+     * Required for distributed subscriptions.
      */
-    private backfillSearchIndexes;
-    /** Wait for server to be fully ready (ports assigned) */
-    ready(): Promise<void>;
+    setNodeId(nodeId: string): void;
     /**
-     * Wait for all pending batch operations to complete.
-     * Useful for tests that need to verify state after OP_BATCH.
+     * Set the callback for sending updates to clients.
+     * Called by ServerCoordinator during initialization.
      */
-    waitForPendingBatches(): Promise<void>;
-    /** Get the actual port the server is listening on */
-    get port(): number;
-    /** Get the actual cluster port */
-    get clusterPort(): number;
-    /** Get event executor metrics for monitoring */
-    getEventExecutorMetrics(): StripeMetrics[];
-    /** Get total event executor metrics across all stripes */
-    getEventExecutorTotalMetrics(): QueueMetrics;
-    /** Get connection rate limiter stats for monitoring */
-    getRateLimiterStats(): RateLimiterStats;
-    /** Get worker pool stats for monitoring */
-    getWorkerPoolStats(): WorkerPoolStats | null;
-    /** Check if worker pool is enabled */
-    get workerPoolEnabled(): boolean;
-    /** Get MerkleWorker for external use (null if worker pool disabled) */
-    getMerkleWorker(): MerkleWorker | null;
-    /** Get CRDTMergeWorker for external use (null if worker pool disabled) */
-    getCRDTMergeWorker(): CRDTMergeWorker | null;
-    /** Get SerializationWorker for external use (null if worker pool disabled) */
-    getSerializationWorker(): SerializationWorker | null;
-    /** Get memory pool stats for monitoring GC pressure reduction */
-    getMemoryPoolStats(): {
-        eventPayloadPool: ObjectPoolStats;
+    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;
+    /**
+     * Register a distributed subscription from a remote coordinator.
+     * Called when receiving CLUSTER_SUB_REGISTER message.
+     *
+     * @param subscriptionId - Unique subscription ID
+     * @param mapName - Map name to search
+     * @param query - Search query string
+     * @param options - Search options
+     * @param coordinatorNodeId - Node ID of the coordinator (receives updates)
+     * @returns Initial search results from this node
+     */
+    registerDistributedSubscription(subscriptionId: string, mapName: string, query: string, options: SearchOptions, coordinatorNodeId: string): {
+        results: ServerSearchResult[];
+        totalHits: number;
     };
-    /** Get tasklet scheduler stats for monitoring cooperative multitasking */
-    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.
+     * Get a distributed subscription by ID.
+     * Returns undefined if not found or not distributed.
+     */
+    getDistributedSubscription(subscriptionId: string): SearchSubscription | undefined;
+    /**
+     * Unsubscribe all distributed subscriptions where the given node was the coordinator.
+     * Called when a cluster node disconnects.
+     *
+     * @param coordinatorNodeId - Node ID of the disconnected coordinator
+     */
+    unsubscribeByCoordinator(coordinatorNodeId: string): void;
+    /**
+     * Notify subscribers about a document change.
+     * Computes delta (ENTER/UPDATE/LEAVE) for each affected subscription.
+     * For distributed subscriptions, emits 'distributedUpdate' event instead of sending to client.
+     *
+     * @param mapName - Name of the map that changed
+     * @param key - Document key that changed
+     * @param value - New document value (null if removed)
+     * @param changeType - Type of change
+     */
+    private notifySubscribers;
+    /**
+     * Send update to remote coordinator node for a distributed subscription.
+     * Emits 'distributedUpdate' event with ClusterSubUpdatePayload.
      *
-     * @param mapName - Name of the map to enable FTS for
-     * @param config - FTS configuration (fields, tokenizer, bm25 options)
+     * @param sub - The distributed subscription
+     * @param key - Document key
+     * @param value - Document value
+     * @param score - Search score
+     * @param matchedTerms - Matched search terms
+     * @param changeType - Change type (ENTER/UPDATE/LEAVE)
      */
-    enableFullTextSearch(mapName: string, config: FullTextIndexConfig): void;
+    private sendDistributedUpdate;
     /**
-     * Disable full-text search for a map.
+     * Score a single document against a subscription's query.
      *
-     * @param mapName - Name of the map to disable FTS for
+     * 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
      */
-    disableFullTextSearch(mapName: string): void;
+    private scoreDocument;
     /**
-     * Check if full-text search is enabled for a map.
+     * Queue a notification for batched processing.
+     * Notifications are collected and processed together after BATCH_INTERVAL.
      *
-     * @param mapName - Name of the map to check
-     * @returns True if FTS is enabled
+     * @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
      */
-    isFullTextSearchEnabled(mapName: string): boolean;
+    queueNotification(mapName: string, key: string, value: Record<string, unknown> | null, changeType: 'add' | 'update' | 'remove'): void;
     /**
-     * Get FTS index statistics for a map.
-     *
-     * @param mapName - Name of the map
-     * @returns Index stats or null if FTS not enabled
+     * Schedule a flush of pending notifications.
+     * Uses setTimeout to batch notifications within BATCH_INTERVAL window.
      */
-    getFullTextSearchStats(mapName: string): {
-        documentCount: number;
-        fields: string[];
-    } | null;
+    private scheduleNotificationFlush;
     /**
-     * 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
+     * Flush all pending notifications.
+     * Processes each map's notifications and sends batched updates.
      */
-    private gracefulClusterDeparture;
+    flushNotifications(): void;
     /**
-     * Get list of partition IDs owned by this node
+     * 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 getOwnedPartitions;
+    private processBatchedNotifications;
     /**
-     * Wait for replication pipeline to flush pending operations
+     * 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 waitForReplicationFlush;
-    shutdown(): Promise<void>;
-    private handleConnection;
-    private handleMessage;
-    private updateClientHlc;
+    private computeSubscriptionUpdate;
+}
+
+/**
+ * FailureDetector - Phi Accrual Failure Detector
+ *
+ * Implements the Phi Accrual Failure Detection algorithm for distributed systems.
+ * Based on the paper: "The φ Accrual Failure Detector" by Hayashibara et al.
+ *
+ * The detector provides a suspicion level (phi) rather than binary alive/dead status,
+ * allowing the application to make decisions based on configurable thresholds.
+ *
+ * Hazelcast equivalent: com.hazelcast.internal.cluster.fd.PhiAccrualFailureDetector
+ */
+
+interface FailureDetectorConfig {
+    /** Interval between heartbeat checks (ms). Default: 1000 */
+    heartbeatIntervalMs: number;
+    /** Time after which a node is suspected if no heartbeat received (ms). Default: 5000 */
+    suspicionTimeoutMs: number;
+    /** Time after suspicion before confirming failure (ms). Default: 10000 */
+    confirmationTimeoutMs: number;
+    /** Phi threshold above which a node is considered suspected. Default: 8 */
+    phiThreshold: number;
+    /** Minimum samples required for accurate phi calculation. Default: 10 */
+    minSamples: number;
+    /** Maximum samples to keep in history. Default: 100 */
+    maxSamples: number;
+    /** 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;
+    private monitoringNodes;
+    private checkTimer?;
+    private confirmationTimers;
+    private started;
+    constructor(config?: Partial<FailureDetectorConfig>);
     /**
-     * Broadcast partition map to all connected and authenticated clients.
-     * Called when partition topology changes (node join/leave/failover).
+     * Start the failure detector monitoring loop.
      */
-    private broadcastPartitionMap;
+    start(): void;
     /**
-     * Notify a client about a merge rejection (Phase 5.05).
-     * Finds the client by node ID and sends MERGE_REJECTED message.
+     * Stop the failure detector and clean up.
      */
-    private notifyMergeRejection;
-    private broadcast;
+    stop(): void;
     /**
-     * === OPTIMIZATION 2 & 3: Batched Broadcast with Serialization Caching ===
-     * Groups clients by their permission roles and serializes once per group.
-     * Also batches multiple events into a single SERVER_BATCH_EVENT message.
-     * === OPTIMIZATION 4: Subscription-based Routing ===
-     * Only sends events to clients with active subscriptions for affected maps.
+     * Start monitoring a node.
      */
-    private broadcastBatch;
+    startMonitoring(nodeId: string): void;
     /**
-     * Helper method to get role signature for a client (for caching key)
+     * Stop monitoring a node.
      */
-    private getClientRoleSignature;
+    stopMonitoring(nodeId: string): void;
     /**
-     * === BACKPRESSURE: Synchronous Broadcast ===
-     * Same as broadcastBatch but waits for all sends to complete.
-     * Used when backpressure forces sync processing to drain the pipeline.
+     * Record a heartbeat from a node.
+     * This updates the node's state and clears any suspicion.
      */
-    private broadcastBatchSync;
-    private setupClusterListeners;
-    private executeLocalQuery;
+    recordHeartbeat(nodeId: string): void;
     /**
-     * Convert server Query format to core Query format for indexed execution.
-     * Returns null if conversion is not possible (complex queries).
+     * Check all monitored nodes for failure.
      */
-    private convertToCoreQuery;
+    private checkAllNodes;
     /**
-     * Convert predicate node to core Query format.
+     * Schedule failure confirmation after suspicion timeout.
      */
-    private predicateToCoreQuery;
+    private scheduleConfirmation;
     /**
-     * Convert server operator to core query type.
+     * Confirm node failure after confirmation timeout.
      */
-    private convertOperator;
-    private finalizeClusterQuery;
+    private confirmFailure;
     /**
-     * Core operation application logic shared between processLocalOp and processLocalOpForBatch.
-     * Handles map merge, storage persistence, query evaluation, and event generation.
+     * Calculate the phi value for a node using the Phi Accrual algorithm.
      *
-     * @returns Event payload for broadcasting (or null if operation failed)
+     * Phi = -log10(P_later(t_now - t_last))
+     *
+     * where P_later is the probability that a heartbeat will arrive later than expected.
      */
-    private applyOpToMap;
+    calculatePhi(nodeId: string): number;
     /**
-     * Broadcast event to cluster members (excluding self).
+     * Calculate mean of an array of numbers.
      */
-    private broadcastToCluster;
+    private calculateMean;
     /**
-     * Apply replicated operation from another node (callback for ReplicationPipeline)
-     * This is called when we receive a replicated operation as a backup node
+     * Calculate variance of an array of numbers.
      */
-    private applyReplicatedOperation;
+    private calculateVariance;
     /**
-     * Build OpContext for interceptors.
+     * Get list of currently suspected nodes.
      */
-    private buildOpContext;
+    getSuspectedNodes(): string[];
     /**
-     * Run onBeforeOp interceptors. Returns modified op or null if dropped.
+     * Get list of confirmed failed nodes.
      */
-    private runBeforeInterceptors;
+    getConfirmedFailedNodes(): string[];
     /**
-     * Run onAfterOp interceptors (fire-and-forget).
+     * Check if a specific node is suspected.
      */
-    private runAfterInterceptors;
-    private handleLockGranted;
-    private processLocalOp;
+    isSuspected(nodeId: string): boolean;
     /**
-     * === OPTIMIZATION 1: Async Batch Processing with Backpressure ===
-     * Processes validated operations asynchronously after ACK has been sent.
-     * Uses BackpressureRegulator to periodically force sync processing and
-     * prevent unbounded accumulation of async work.
+     * Check if a specific node's failure is confirmed.
      */
-    private processBatchAsync;
+    isConfirmedFailed(nodeId: string): boolean;
     /**
-     * === BACKPRESSURE: Synchronous Batch Processing ===
-     * Processes operations synchronously, waiting for broadcast completion.
-     * Used when backpressure forces sync to drain the pipeline.
+     * Get the current phi value for a node.
      */
-    private processBatchSync;
+    getPhi(nodeId: string): number;
     /**
-     * Forward operation to owner node and wait for completion.
-     * Used in sync processing mode.
+     * Get all monitored nodes.
      */
-    private forwardOpAndWait;
+    getMonitoredNodes(): string[];
+    /**
+     * Get metrics for monitoring.
+     */
+    getMetrics(): {
+        monitoredNodes: number;
+        suspectedNodes: number;
+        confirmedFailedNodes: number;
+    };
+}
+
+interface ClusterConfig {
+    nodeId: string;
+    host: string;
+    port: number;
+    peers: string[];
+    discovery?: 'manual' | 'kubernetes';
+    serviceName?: string;
+    discoveryInterval?: number;
+    tls?: ClusterTLSConfig;
+    /** Heartbeat interval in milliseconds. Default: 1000 */
+    heartbeatIntervalMs?: number;
+    /** Failure detection configuration */
+    failureDetection?: Partial<FailureDetectorConfig>;
+}
+interface ClusterMember {
+    nodeId: string;
+    host: string;
+    port: number;
+    socket: WebSocket;
+    isSelf: boolean;
+}
+interface ClusterMessage {
+    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' | 'CLUSTER_SEARCH_REQ' | 'CLUSTER_SEARCH_RESP' | 'CLUSTER_SEARCH_SUBSCRIBE' | 'CLUSTER_SEARCH_UNSUBSCRIBE' | 'CLUSTER_SEARCH_UPDATE' | 'CLUSTER_SUB_REGISTER' | 'CLUSTER_SUB_ACK' | 'CLUSTER_SUB_UPDATE' | 'CLUSTER_SUB_UNREGISTER';
+    senderId: string;
+    payload: any;
+}
+declare class ClusterManager extends EventEmitter {
+    readonly config: ClusterConfig;
+    private server?;
+    private members;
+    private pendingConnections;
+    private reconnectIntervals;
+    private discoveryTimer?;
+    private heartbeatTimer?;
+    private failureDetector;
+    constructor(config: ClusterConfig);
     /**
-     * Process a single operation for batch processing.
-     * Uses shared applyOpToMap but collects events instead of broadcasting immediately.
+     * Get the failure detector instance.
      */
-    private processLocalOpForBatch;
-    private handleClusterEvent;
-    getMap(name: string, typeHint?: 'LWW' | 'OR'): LWWMap<string, any> | ORMap<string, any>;
+    getFailureDetector(): FailureDetector;
+    private _actualPort;
+    /** Get the actual port the cluster is listening on */
+    get port(): number;
+    start(): Promise<number>;
+    /** Called when server is ready - registers self and initiates peer connections */
+    private onServerReady;
+    stop(): void;
     /**
-     * Returns map after ensuring it's fully loaded from storage.
-     * Use this for queries to avoid returning empty results during initial load.
+     * Start sending heartbeats to all peers.
      */
-    getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
+    private startHeartbeat;
     /**
-     * Phase 10.04: Get local record for anti-entropy repair
-     * Returns the LWWRecord for a key, used by RepairScheduler
+     * Stop sending heartbeats.
      */
-    private getLocalRecord;
+    private stopHeartbeat;
     /**
-     * Phase 10.04: Apply repaired record from anti-entropy repair
-     * Used by RepairScheduler to apply resolved conflicts
+     * Send heartbeat to all connected peers.
      */
-    private applyRepairRecord;
-    private loadMapFromStorage;
-    private startGarbageCollection;
+    private sendHeartbeatToAll;
     /**
-     * Starts the periodic check for dead clients (those that haven't sent PING).
+     * Handle incoming heartbeat from a peer.
      */
-    private startHeartbeatCheck;
+    private handleHeartbeat;
     /**
-     * Handles incoming PING message from client.
-     * Responds with PONG immediately.
+     * Send current member list to a specific node (gossip protocol).
+     * Called when a new node joins to propagate cluster topology.
      */
-    private handlePing;
+    private sendMemberList;
     /**
-     * Checks if a client is still alive based on heartbeat.
+     * Broadcast member list to all connected nodes.
+     * Called when cluster membership changes.
      */
-    isClientAlive(clientId: string): boolean;
+    private broadcastMemberList;
     /**
-     * Returns how long the client has been idle (no PING received).
+     * Handle incoming member list from a peer (gossip protocol).
+     * Attempts to connect to unknown members.
      */
-    getClientIdleTime(clientId: string): number;
+    private handleMemberList;
     /**
-     * Evicts clients that haven't sent a PING within the timeout period.
+     * Handle confirmed node failure.
      */
-    private evictDeadClients;
-    private reportLocalHlc;
-    private handleGcReport;
-    private performGarbageCollection;
-    private buildTLSOptions;
+    private handleNodeFailure;
+    private connectToPeers;
+    private startDiscovery;
+    private scheduleReconnect;
+    private connectToPeerWithBackoff;
+    private connectToPeer;
+    private _connectToPeerInternal;
+    private handleSocket;
+    send(nodeId: string, type: ClusterMessage['type'], payload: any): void;
+    sendToNode(nodeId: string, message: any): void;
+    getMembers(): string[];
+    isLocal(nodeId: string): boolean;
+    private buildClusterTLSOptions;
+}
+
+/**
+ * MigrationManager - Manages gradual partition rebalancing
+ *
+ * Phase 4 Task 03: Parallel Partition Sync
+ *
+ * Features:
+ * - Gradual rebalancing with configurable batch size
+ * - State machine for migration lifecycle
+ * - Backpressure via chunk acknowledgments
+ * - Retry logic for failed migrations
+ * - Metrics and observability
+ */
+
+declare class MigrationManager extends EventEmitter {
+    private readonly config;
+    private readonly clusterManager;
+    private readonly partitionService;
+    private activeMigrations;
+    private migrationQueue;
+    private incomingMigrations;
+    private pendingChunkAcks;
+    private pendingVerifications;
+    private metrics;
+    private batchTimer;
+    private dataCollector;
+    private dataStorer;
+    constructor(clusterManager: ClusterManager, partitionService: PartitionService, config?: Partial<MigrationConfig>);
     /**
-     * Get effective Write Concern level for an operation.
-     * Per-op writeConcern overrides batch-level.
+     * Set the data collector callback
+     * Called to collect all records for a partition before migration
      */
-    private getEffectiveWriteConcern;
+    setDataCollector(collector: (partitionId: number) => Promise<Uint8Array[]>): void;
     /**
-     * Convert string WriteConcern value to enum.
+     * Set the data storer callback
+     * Called to store received records after successful migration
      */
-    private stringToWriteConcern;
+    setDataStorer(storer: (partitionId: number, data: Uint8Array[]) => Promise<void>): void;
     /**
-     * Process batch with Write Concern tracking.
-     * Notifies WriteAckManager at each stage of processing.
+     * Plan migration for topology change
      */
-    private processBatchAsyncWithWriteConcern;
+    planMigration(oldDistribution: Map<number, PartitionDistribution>, newDistribution: Map<number, PartitionDistribution>): void;
     /**
-     * Synchronous batch processing with Write Concern.
+     * Start batch processing timer
      */
-    private processBatchSyncWithWriteConcern;
+    private startBatchProcessing;
     /**
-     * Process a single operation with Write Concern level notifications.
+     * Stop batch processing
      */
-    private processLocalOpWithWriteConcern;
+    private stopBatchProcessing;
     /**
-     * Persist operation synchronously (blocking).
-     * Used for PERSISTED Write Concern.
+     * Start next batch of migrations
      */
-    private persistOpSync;
+    startNextBatch(): Promise<void>;
     /**
-     * Persist operation asynchronously (fire-and-forget).
-     * Used for non-PERSISTED Write Concern levels.
+     * Start migration for a single partition
      */
-    private persistOpAsync;
-}
-
-interface PostgresAdapterOptions {
-    tableName?: string;
-}
-declare class PostgresAdapter implements IServerStorage {
-    private pool;
-    private tableName;
-    constructor(configOrPool: PoolConfig | Pool, options?: PostgresAdapterOptions);
-    initialize(): Promise<void>;
-    close(): Promise<void>;
-    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
-    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
-    loadAllKeys(mapName: string): Promise<string[]>;
-    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
-    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
-    delete(mapName: string, key: string): Promise<void>;
-    deleteAll(mapName: string, keys: string[]): Promise<void>;
-    private mapRowToRecord;
-    private isORMapValue;
-}
-
-/**
- * In-memory implementation of IServerStorage.
- * Useful for development, testing, and demos without requiring a database.
- *
- * Note: Data is lost when the server restarts.
- */
-declare class MemoryServerAdapter implements IServerStorage {
-    private storage;
-    initialize(): Promise<void>;
-    close(): Promise<void>;
-    private getMap;
-    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
-    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
-    loadAllKeys(mapName: string): Promise<string[]>;
-    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
-    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
-    delete(mapName: string, key: string): Promise<void>;
-    deleteAll(mapName: string, keys: string[]): Promise<void>;
-}
-
-declare class SecurityManager {
-    private policies;
-    constructor(policies?: PermissionPolicy[]);
-    addPolicy(policy: PermissionPolicy): void;
-    checkPermission(principal: Principal, mapName: string, action: PermissionType): boolean;
-    filterObject(object: any, principal: Principal, mapName: string): any;
-    private hasRole;
-    private matchesMap;
-}
-
-declare const logger: pino.Logger<never, boolean>;
-type Logger = typeof logger;
-
-/**
- * ConnectionRateLimiter - Rate limiter for incoming WebSocket connections.
- *
- * Implements connection rate limiting to prevent connection storms and
- * protect the server from being overwhelmed during high load scenarios.
- *
- * Features:
- * - Limits connections per second to prevent TCP backlog exhaustion
- * - Tracks pending connections (in-progress handshakes)
- * - Provides graceful rejection when limits are exceeded
- * - Auto-resets counters after cooldown period
- */
-interface RateLimiterConfig {
-    /** Maximum new connections allowed per second (default: 100) */
-    maxConnectionsPerSecond: number;
-    /** Maximum pending connections waiting for handshake (default: 1000) */
-    maxPendingConnections: number;
-    /** Cooldown period in ms after which counters reset (default: 1000) */
-    cooldownMs: number;
-}
-interface RateLimiterStats {
-    /** Current connections per second rate */
-    connectionsPerSecond: number;
-    /** Number of connections currently pending (handshake in progress) */
-    pendingConnections: number;
-    /** Total connections established since start */
-    totalConnections: number;
-    /** Total connections rejected due to rate limiting */
-    totalRejected: number;
-}
-declare class ConnectionRateLimiter {
-    private config;
-    /** Connection attempts in current window */
-    private connectionCount;
-    /** Timestamp when current window started */
-    private windowStart;
-    /** Currently pending connections (handshake in progress) */
-    private pendingCount;
-    /** Total connections established since start */
-    private totalConnections;
-    /** Total connections rejected since start */
-    private totalRejected;
-    constructor(config?: Partial<RateLimiterConfig>);
+    private startPartitionMigration;
     /**
-     * Check if a new connection should be accepted.
-     * @returns true if the connection should be accepted, false if it should be rejected
+     * Split records into chunks
      */
-    shouldAccept(): boolean;
+    private chunkify;
     /**
-     * Register a connection attempt.
-     * Call this when a new connection is initiated (before handshake completes).
+     * Calculate checksum for a chunk using native xxhash
      */
-    onConnectionAttempt(): void;
+    private calculateChecksum;
     /**
-     * Register that a connection has been established (handshake complete).
-     * Call this when the connection is fully established and authenticated.
+     * Calculate checksum for all partition records using streaming xxhash
      */
-    onConnectionEstablished(): void;
+    private calculatePartitionChecksum;
     /**
-     * Register that a connection has been closed.
-     * Call this when a pending connection is closed before completing handshake.
+     * Wait for chunk acknowledgment
      */
-    onConnectionClosed(): void;
+    private waitForChunkAck;
     /**
-     * Register that a connection was rejected.
-     * Call this when shouldAccept() returns false and the connection is rejected.
+     * Wait for migration verification
      */
-    onConnectionRejected(): void;
+    private waitForVerification;
     /**
-     * Decrease pending count when a connection times out or fails.
-     * Call this when a pending connection fails to complete handshake.
+     * Handle successful migration completion
      */
-    onPendingConnectionFailed(): void;
+    private onMigrationComplete;
     /**
-     * Get current rate limiter statistics.
+     * Handle migration failure
      */
-    getStats(): RateLimiterStats;
+    private onMigrationFailed;
     /**
-     * Reset the rate limiter state.
-     * Useful for testing or when recovering from errors.
+     * Handle MIGRATION_START message
      */
-    reset(): void;
+    private handleMigrationStart;
     /**
-     * Update configuration at runtime.
+     * Handle MIGRATION_CHUNK message
      */
-    updateConfig(config: Partial<RateLimiterConfig>): void;
+    private handleMigrationChunk;
     /**
-     * Check if window has expired and reset if needed.
+     * Handle MIGRATION_COMPLETE message
      */
-    private maybeResetWindow;
-}
-
-declare class TimestampInterceptor implements IInterceptor {
-    name: string;
-    onBeforeOp(op: ServerOp, context: OpContext): Promise<ServerOp>;
-}
-
-interface RateLimitConfig {
-    windowMs: number;
-    maxOps: number;
-}
-declare class RateLimitInterceptor implements IInterceptor {
-    name: string;
-    private limits;
-    private config;
-    constructor(config?: RateLimitConfig);
-    onBeforeOp(op: ServerOp, context: OpContext): Promise<ServerOp | null>;
-    onDisconnect(context: any): Promise<void>;
-}
-
-/**
- * Native Module Statistics
- *
- * Provides information about available native optimizations.
- *
- * Phase 3.05: Integration
- */
-
-/**
- * Native module availability status
- */
-interface NativeModuleStatus {
-    /** Native xxHash64 is available and being used */
-    nativeHash: boolean;
-    /** SharedArrayBuffer is available */
-    sharedArrayBuffer: boolean;
-}
-/**
- * Comprehensive native statistics
- */
-interface NativeStats {
-    /** Module availability status */
-    modules: NativeModuleStatus;
-    /** Shared memory statistics (if enabled) */
-    sharedMemory: SharedMemoryStats | null;
-    /** Summary of what's being used */
-    summary: string;
-}
-/**
- * Check which native modules are available.
- */
-declare function getNativeModuleStatus(): NativeModuleStatus;
-/**
- * Get native statistics including shared memory.
- *
- * @param sharedMemoryManager - Optional SharedMemoryManager instance
- */
-declare function getNativeStats(sharedMemoryManager?: SharedMemoryManager): NativeStats;
-/**
- * Log native module status to console.
- */
-declare function logNativeStatus(): void;
-
-/**
- * FailureDetector - Phi Accrual Failure Detector
- *
- * Implements the Phi Accrual Failure Detection algorithm for distributed systems.
- * Based on the paper: "The φ Accrual Failure Detector" by Hayashibara et al.
- *
- * The detector provides a suspicion level (phi) rather than binary alive/dead status,
- * allowing the application to make decisions based on configurable thresholds.
- *
- * Hazelcast equivalent: com.hazelcast.internal.cluster.fd.PhiAccrualFailureDetector
- */
-
-interface FailureDetectorConfig {
-    /** Interval between heartbeat checks (ms). Default: 1000 */
-    heartbeatIntervalMs: number;
-    /** Time after which a node is suspected if no heartbeat received (ms). Default: 5000 */
-    suspicionTimeoutMs: number;
-    /** Time after suspicion before confirming failure (ms). Default: 10000 */
-    confirmationTimeoutMs: number;
-    /** Phi threshold above which a node is considered suspected. Default: 8 */
-    phiThreshold: number;
-    /** Minimum samples required for accurate phi calculation. Default: 10 */
-    minSamples: number;
-    /** Maximum samples to keep in history. Default: 100 */
-    maxSamples: number;
-    /** 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;
-    private monitoringNodes;
-    private checkTimer?;
-    private confirmationTimers;
-    private started;
-    constructor(config?: Partial<FailureDetectorConfig>);
+    private handleMigrationComplete;
     /**
-     * Start the failure detector monitoring loop.
+     * Handle MIGRATION_CHUNK_ACK message
      */
-    start(): void;
+    private handleMigrationChunkAck;
     /**
-     * Stop the failure detector and clean up.
+     * Handle MIGRATION_VERIFY message
      */
-    stop(): void;
+    private handleMigrationVerify;
     /**
-     * Start monitoring a node.
+     * Reassemble chunks into continuous data
      */
-    startMonitoring(nodeId: string): void;
+    private reassemble;
     /**
-     * Stop monitoring a node.
+     * Deserialize records from chunk data
      */
-    stopMonitoring(nodeId: string): void;
+    private deserializeRecords;
     /**
-     * Record a heartbeat from a node.
-     * This updates the node's state and clears any suspicion.
+     * Setup cluster message handlers
      */
-    recordHeartbeat(nodeId: string): void;
+    private setupMessageHandlers;
     /**
-     * Check all monitored nodes for failure.
+     * Check if a partition is currently migrating
      */
-    private checkAllNodes;
+    isActive(partitionId: number): boolean;
+    /**
+     * Get migration status
+     */
+    getStatus(): MigrationStatus;
+    /**
+     * Get migration metrics
+     */
+    getMetrics(): MigrationMetrics;
+    /**
+     * Cancel all active and queued migrations
+     */
+    cancelAll(): Promise<void>;
+    /**
+     * Cleanup resources (sync version for backwards compatibility)
+     */
+    close(): void;
+    /**
+     * Async cleanup - waits for cancellation to complete
+     */
+    closeAsync(): Promise<void>;
+}
+
+interface PartitionDistribution {
+    owner: string;
+    backups: string[];
+}
+interface PartitionServiceEvents {
+    'rebalanced': (map: PartitionMap, changes: PartitionChange[]) => void;
+    'partitionMoved': (info: {
+        partitionId: number;
+        previousOwner: string;
+        newOwner: string;
+        version: number;
+    }) => void;
+}
+interface PartitionServiceConfig {
+    /** Enable gradual rebalancing (default: false for backward compatibility) */
+    gradualRebalancing: boolean;
+    /** Migration configuration */
+    migration: Partial<MigrationConfig>;
+}
+declare class PartitionService extends EventEmitter {
+    private cluster;
+    private partitions;
+    private readonly PARTITION_COUNT;
+    private readonly BACKUP_COUNT;
+    private mapVersion;
+    private lastRebalanceTime;
+    private config;
+    private migrationManager;
+    constructor(cluster: ClusterManager, config?: Partial<PartitionServiceConfig>);
+    /**
+     * Handle membership change
+     */
+    private onMembershipChange;
+    getPartitionId(key: string): number;
+    getDistribution(key: string): PartitionDistribution;
+    getOwner(key: string): string;
+    isLocalOwner(key: string): boolean;
+    isLocalBackup(key: string): boolean;
+    isRelated(key: string): boolean;
     /**
-     * Schedule failure confirmation after suspicion timeout.
+     * Get current partition map version
      */
-    private scheduleConfirmation;
+    getMapVersion(): number;
     /**
-     * Confirm node failure after confirmation timeout.
+     * Generate full PartitionMap for client consumption
      */
-    private confirmFailure;
+    getPartitionMap(): PartitionMap;
     /**
-     * Calculate the phi value for a node using the Phi Accrual algorithm.
-     *
-     * Phi = -log10(P_later(t_now - t_last))
-     *
-     * where P_later is the probability that a heartbeat will arrive later than expected.
+     * Get partition info by ID
      */
-    calculatePhi(nodeId: string): number;
+    getPartitionInfo(partitionId: number): PartitionInfo | null;
     /**
-     * Calculate mean of an array of numbers.
+     * Get owner node for a partition ID
      */
-    private calculateMean;
+    getPartitionOwner(partitionId: number): string | null;
+    private rebalance;
     /**
-     * Calculate variance of an array of numbers.
+     * Perform gradual rebalancing using MigrationManager
      */
-    private calculateVariance;
+    private rebalanceGradual;
     /**
-     * Get list of currently suspected nodes.
+     * Set partition owner (called after migration completes)
      */
-    getSuspectedNodes(): string[];
+    setOwner(partitionId: number, nodeId: string): void;
     /**
-     * Get list of confirmed failed nodes.
+     * Get backups for a partition
      */
-    getConfirmedFailedNodes(): string[];
+    getBackups(partitionId: number): string[];
     /**
-     * Check if a specific node is suspected.
+     * Get migration status
      */
-    isSuspected(nodeId: string): boolean;
+    getMigrationStatus(): MigrationStatus | null;
     /**
-     * Check if a specific node's failure is confirmed.
+     * Check if partition is currently migrating
      */
-    isConfirmedFailed(nodeId: string): boolean;
+    isMigrating(partitionId: number): boolean;
     /**
-     * Get the current phi value for a node.
+     * Check if any partition is currently migrating
      */
-    getPhi(nodeId: string): number;
+    isRebalancing(): boolean;
     /**
-     * Get all monitored nodes.
+     * Get MigrationManager for configuration
      */
-    getMonitoredNodes(): string[];
+    getMigrationManager(): MigrationManager | null;
     /**
-     * Get metrics for monitoring.
+     * Cancel all migrations
      */
-    getMetrics(): {
-        monitoredNodes: number;
-        suspectedNodes: number;
-        confirmedFailedNodes: number;
-    };
+    cancelMigrations(): Promise<void>;
 }
 
-interface ClusterConfig {
-    nodeId: string;
-    host: string;
+/**
+ * ClusterSearchCoordinator - Distributed Search across Cluster Nodes
+ *
+ * Implements Scatter-Gather architecture for distributed full-text search.
+ * Broadcasts search queries to all nodes, collects local results, and merges
+ * them using Reciprocal Rank Fusion (RRF) for unified ranking.
+ *
+ * Key features:
+ * - Scatter-Gather search across all cluster nodes
+ * - RRF-based result merging (handles distributed IDF problem)
+ * - Cursor-based pagination for efficient deep results
+ * - Graceful degradation on node failures
+ * - Single-node optimization (skip broadcast when all data is local)
+ *
+ * @module search/ClusterSearchCoordinator
+ */
+
+/**
+ * Configuration for ClusterSearchCoordinator.
+ */
+interface ClusterSearchConfig {
+    /** RRF constant k (default: 60) */
+    rrfK?: number;
+    /** Default timeout for node responses (ms) */
+    defaultTimeoutMs?: number;
+    /** Minimum nodes required to respond (default: 0 = all available) */
+    defaultMinResponses?: number;
+}
+
+interface ServerCoordinatorConfig {
     port: number;
-    peers: string[];
+    nodeId: string;
+    storage?: IServerStorage;
+    jwtSecret?: string;
+    host?: string;
+    clusterPort?: number;
+    peers?: string[];
+    securityPolicies?: PermissionPolicy[];
+    /** Callback to resolve dynamic peer addresses after ports are known */
+    resolvePeers?: () => string[];
+    interceptors?: IInterceptor[];
+    metricsPort?: number;
     discovery?: 'manual' | 'kubernetes';
     serviceName?: string;
     discoveryInterval?: number;
-    tls?: ClusterTLSConfig;
-    /** Heartbeat interval in milliseconds. Default: 1000 */
-    heartbeatIntervalMs?: number;
-    /** Failure detection configuration */
-    failureDetection?: Partial<FailureDetectorConfig>;
-}
-interface ClusterMember {
-    nodeId: string;
-    host: string;
-    port: number;
-    socket: WebSocket;
-    isSelf: boolean;
-}
-interface ClusterMessage {
-    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;
+    tls?: TLSConfig;
+    clusterTls?: ClusterTLSConfig;
+    /** Total event queue capacity for bounded queue (default: 10000) */
+    eventQueueCapacity?: number;
+    /** Number of event queue stripes for parallel processing (default: 4) */
+    eventStripeCount?: number;
+    /** Enable/disable backpressure (default: true) */
+    backpressureEnabled?: boolean;
+    /** How often to force sync processing (default: 100 operations) */
+    backpressureSyncFrequency?: number;
+    /** Maximum pending async operations before blocking (default: 1000) */
+    backpressureMaxPending?: number;
+    /** Backoff timeout in ms when at capacity (default: 5000) */
+    backpressureBackoffMs?: number;
+    /** Enable/disable write coalescing (default: true) */
+    writeCoalescingEnabled?: boolean;
+    /** Coalescing preset: 'conservative', 'balanced', 'highThroughput', 'aggressive' (default: 'highThroughput') */
+    writeCoalescingPreset?: CoalescingPreset;
+    /** Maximum messages to batch before forcing flush (default: 500 for highThroughput) */
+    writeCoalescingMaxBatch?: number;
+    /** Maximum delay before flushing in ms (default: 10 for highThroughput) */
+    writeCoalescingMaxDelayMs?: number;
+    /** Maximum batch size in bytes (default: 262144/256KB for highThroughput) */
+    writeCoalescingMaxBytes?: number;
+    /** WebSocket backlog for pending connections (default: 511) */
+    wsBacklog?: number;
+    /** Enable WebSocket per-message compression (default: false for CPU savings) */
+    wsCompression?: boolean;
+    /** Maximum WebSocket payload size in bytes (default: 64MB) */
+    wsMaxPayload?: number;
+    /** Maximum server connections (default: 10000) */
+    maxConnections?: number;
+    /** Server timeout in ms (default: 120000 = 2 min) */
+    serverTimeout?: number;
+    /** Keep-alive timeout in ms (default: 5000) */
+    keepAliveTimeout?: number;
+    /** Headers timeout in ms (default: 60000) */
+    headersTimeout?: number;
+    /** Enable connection rate limiting (default: true) */
+    rateLimitingEnabled?: boolean;
+    /** Maximum new connections per second (default: 100) */
+    maxConnectionsPerSecond?: number;
+    /** Maximum pending connections (default: 1000) */
+    maxPendingConnections?: number;
+    /** Enable worker pool for CPU-bound operations (default: false) */
+    workerPoolEnabled?: boolean;
+    /** Worker pool configuration */
+    workerPoolConfig?: Partial<WorkerPoolConfig>;
+    /** Default timeout for Write Concern acknowledgments in ms (default: 5000) */
+    writeAckTimeout?: number;
+    /** Enable replication to backup nodes (default: true when cluster has peers) */
+    replicationEnabled?: boolean;
+    /** Default consistency level for replication (default: EVENTUAL) */
+    defaultConsistency?: ConsistencyLevel;
+    /** Replication configuration */
+    replicationConfig?: Partial<ReplicationConfig>;
+    /** Enable event journal for audit/CDC (default: false) */
+    eventJournalEnabled?: boolean;
+    /** Event journal configuration */
+    eventJournalConfig?: Partial<Omit<EventJournalServiceConfig, 'pool'>>;
+    /** Enable full-text search for specific maps */
+    fullTextSearch?: Record<string, FullTextIndexConfig>;
+    /** Configuration for distributed search across cluster nodes */
+    distributedSearch?: ClusterSearchConfig;
 }
-declare class ClusterManager extends EventEmitter {
-    readonly config: ClusterConfig;
-    private server?;
-    private members;
-    private pendingConnections;
-    private reconnectIntervals;
-    private discoveryTimer?;
-    private heartbeatTimer?;
-    private failureDetector;
-    constructor(config: ClusterConfig);
+declare class ServerCoordinator {
+    private httpServer;
+    private metricsServer?;
+    private metricsService;
+    private wss;
+    private clients;
+    private interceptors;
+    private maps;
+    private hlc;
+    private storage?;
+    private jwtSecret;
+    private queryRegistry;
+    private cluster;
+    private partitionService;
+    private replicationPipeline?;
+    private lockManager;
+    private topicManager;
+    private securityManager;
+    private systemManager;
+    private pendingClusterQueries;
+    private gcInterval?;
+    private heartbeatCheckInterval?;
+    private gcReports;
+    private mapLoadingPromises;
+    private pendingBatchOperations;
+    private eventExecutor;
+    private backpressure;
+    private writeCoalescingEnabled;
+    private writeCoalescingOptions;
+    private rateLimiter;
+    private rateLimitingEnabled;
+    private workerPool?;
+    private merkleWorker?;
+    private crdtMergeWorker?;
+    private serializationWorker?;
+    private eventPayloadPool;
+    private taskletScheduler;
+    private writeAckManager;
+    private counterHandler;
+    private entryProcessorHandler;
+    private conflictResolverHandler;
+    private eventJournalService?;
+    private journalSubscriptions;
+    private partitionReassigner?;
+    private readReplicaHandler?;
+    private merkleTreeManager?;
+    private repairScheduler?;
+    private searchCoordinator;
+    private clusterSearchCoordinator?;
+    private distributedSubCoordinator?;
+    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>;
+    /**
+     * Wait for all pending batch operations to complete.
+     * Useful for tests that need to verify state after OP_BATCH.
+     */
+    waitForPendingBatches(): Promise<void>;
+    /** Get the actual port the server is listening on */
+    get port(): number;
+    /** Get the actual cluster port */
+    get clusterPort(): number;
+    /** Get event executor metrics for monitoring */
+    getEventExecutorMetrics(): StripeMetrics[];
+    /** Get total event executor metrics across all stripes */
+    getEventExecutorTotalMetrics(): QueueMetrics;
+    /** Get connection rate limiter stats for monitoring */
+    getRateLimiterStats(): RateLimiterStats;
+    /** Get worker pool stats for monitoring */
+    getWorkerPoolStats(): WorkerPoolStats | null;
+    /** Check if worker pool is enabled */
+    get workerPoolEnabled(): boolean;
+    /** Get MerkleWorker for external use (null if worker pool disabled) */
+    getMerkleWorker(): MerkleWorker | null;
+    /** Get CRDTMergeWorker for external use (null if worker pool disabled) */
+    getCRDTMergeWorker(): CRDTMergeWorker | null;
+    /** Get SerializationWorker for external use (null if worker pool disabled) */
+    getSerializationWorker(): SerializationWorker | null;
+    /** Get memory pool stats for monitoring GC pressure reduction */
+    getMemoryPoolStats(): {
+        eventPayloadPool: ObjectPoolStats;
+    };
+    /** Get tasklet scheduler stats for monitoring cooperative multitasking */
+    getTaskletSchedulerStats(): TaskletSchedulerStats;
+    /** Get tasklet scheduler for scheduling long-running operations */
+    getTaskletScheduler(): TaskletScheduler;
     /**
-     * Get the failure detector instance.
+     * 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)
      */
-    getFailureDetector(): FailureDetector;
-    private _actualPort;
-    /** Get the actual port the cluster is listening on */
-    get port(): number;
-    start(): Promise<number>;
-    /** Called when server is ready - registers self and initiates peer connections */
-    private onServerReady;
-    stop(): void;
+    enableFullTextSearch(mapName: string, config: FullTextIndexConfig): void;
     /**
-     * Start sending heartbeats to all peers.
+     * Disable full-text search for a map.
+     *
+     * @param mapName - Name of the map to disable FTS for
      */
-    private startHeartbeat;
+    disableFullTextSearch(mapName: string): void;
     /**
-     * Stop sending heartbeats.
+     * Check if full-text search is enabled for a map.
+     *
+     * @param mapName - Name of the map to check
+     * @returns True if FTS is enabled
      */
-    private stopHeartbeat;
+    isFullTextSearchEnabled(mapName: string): boolean;
     /**
-     * Send heartbeat to all connected peers.
+     * Get FTS index statistics for a map.
+     *
+     * @param mapName - Name of the map
+     * @returns Index stats or null if FTS not enabled
      */
-    private sendHeartbeatToAll;
+    getFullTextSearchStats(mapName: string): {
+        documentCount: number;
+        fields: string[];
+    } | null;
     /**
-     * Handle incoming heartbeat from a peer.
+     * 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 handleHeartbeat;
+    private gracefulClusterDeparture;
     /**
-     * Send current member list to a specific node (gossip protocol).
-     * Called when a new node joins to propagate cluster topology.
+     * Get list of partition IDs owned by this node
      */
-    private sendMemberList;
+    private getOwnedPartitions;
     /**
-     * Broadcast member list to all connected nodes.
-     * Called when cluster membership changes.
+     * Wait for replication pipeline to flush pending operations
      */
-    private broadcastMemberList;
+    private waitForReplicationFlush;
+    shutdown(): Promise<void>;
+    private handleConnection;
+    private handleMessage;
+    private updateClientHlc;
     /**
-     * Handle incoming member list from a peer (gossip protocol).
-     * Attempts to connect to unknown members.
+     * Broadcast partition map to all connected and authenticated clients.
+     * Called when partition topology changes (node join/leave/failover).
      */
-    private handleMemberList;
+    private broadcastPartitionMap;
     /**
-     * Handle confirmed node failure.
+     * Notify a client about a merge rejection (Phase 5.05).
+     * Finds the client by node ID and sends MERGE_REJECTED message.
      */
-    private handleNodeFailure;
-    private connectToPeers;
-    private startDiscovery;
-    private scheduleReconnect;
-    private connectToPeerWithBackoff;
-    private connectToPeer;
-    private _connectToPeerInternal;
-    private handleSocket;
-    send(nodeId: string, type: ClusterMessage['type'], payload: any): void;
-    sendToNode(nodeId: string, message: any): void;
-    getMembers(): string[];
-    isLocal(nodeId: string): boolean;
-    private buildClusterTLSOptions;
-}
-
-/**
- * MigrationManager - Manages gradual partition rebalancing
- *
- * Phase 4 Task 03: Parallel Partition Sync
- *
- * Features:
- * - Gradual rebalancing with configurable batch size
- * - State machine for migration lifecycle
- * - Backpressure via chunk acknowledgments
- * - Retry logic for failed migrations
- * - Metrics and observability
- */
-
-declare class MigrationManager extends EventEmitter {
-    private readonly config;
-    private readonly clusterManager;
-    private readonly partitionService;
-    private activeMigrations;
-    private migrationQueue;
-    private incomingMigrations;
-    private pendingChunkAcks;
-    private pendingVerifications;
-    private metrics;
-    private batchTimer;
-    private dataCollector;
-    private dataStorer;
-    constructor(clusterManager: ClusterManager, partitionService: PartitionService, config?: Partial<MigrationConfig>);
+    private notifyMergeRejection;
+    private broadcast;
     /**
-     * Set the data collector callback
-     * Called to collect all records for a partition before migration
+     * === OPTIMIZATION 2 & 3: Batched Broadcast with Serialization Caching ===
+     * Groups clients by their permission roles and serializes once per group.
+     * Also batches multiple events into a single SERVER_BATCH_EVENT message.
+     * === OPTIMIZATION 4: Subscription-based Routing ===
+     * Only sends events to clients with active subscriptions for affected maps.
      */
-    setDataCollector(collector: (partitionId: number) => Promise<Uint8Array[]>): void;
+    private broadcastBatch;
     /**
-     * Set the data storer callback
-     * Called to store received records after successful migration
+     * Helper method to get role signature for a client (for caching key)
      */
-    setDataStorer(storer: (partitionId: number, data: Uint8Array[]) => Promise<void>): void;
+    private getClientRoleSignature;
     /**
-     * Plan migration for topology change
+     * === BACKPRESSURE: Synchronous Broadcast ===
+     * Same as broadcastBatch but waits for all sends to complete.
+     * Used when backpressure forces sync processing to drain the pipeline.
      */
-    planMigration(oldDistribution: Map<number, PartitionDistribution>, newDistribution: Map<number, PartitionDistribution>): void;
+    private broadcastBatchSync;
+    private setupClusterListeners;
+    private executeLocalQuery;
     /**
-     * Start batch processing timer
+     * Convert server Query format to core Query format for indexed execution.
+     * Returns null if conversion is not possible (complex queries).
      */
-    private startBatchProcessing;
+    private convertToCoreQuery;
     /**
-     * Stop batch processing
+     * Convert predicate node to core Query format.
      */
-    private stopBatchProcessing;
+    private predicateToCoreQuery;
     /**
-     * Start next batch of migrations
+     * Convert server operator to core query type.
      */
-    startNextBatch(): Promise<void>;
+    private convertOperator;
+    private finalizeClusterQuery;
     /**
-     * Start migration for a single partition
+     * Core operation application logic shared between processLocalOp and processLocalOpForBatch.
+     * Handles map merge, storage persistence, query evaluation, and event generation.
+     *
+     * @returns Event payload for broadcasting (or null if operation failed)
      */
-    private startPartitionMigration;
+    private applyOpToMap;
     /**
-     * Split records into chunks
+     * Apply replicated operation from another node (callback for ReplicationPipeline)
+     * This is called when we receive a replicated operation as a backup node
      */
-    private chunkify;
+    private applyReplicatedOperation;
     /**
-     * Calculate checksum for a chunk using native xxhash
+     * Build OpContext for interceptors.
      */
-    private calculateChecksum;
+    private buildOpContext;
     /**
-     * Calculate checksum for all partition records using streaming xxhash
+     * Run onBeforeOp interceptors. Returns modified op or null if dropped.
      */
-    private calculatePartitionChecksum;
+    private runBeforeInterceptors;
     /**
-     * Wait for chunk acknowledgment
+     * Run onAfterOp interceptors (fire-and-forget).
      */
-    private waitForChunkAck;
+    private runAfterInterceptors;
+    private handleLockGranted;
+    private processLocalOp;
     /**
-     * Wait for migration verification
+     * === OPTIMIZATION 1: Async Batch Processing with Backpressure ===
+     * Processes validated operations asynchronously after ACK has been sent.
+     * Uses BackpressureRegulator to periodically force sync processing and
+     * prevent unbounded accumulation of async work.
      */
-    private waitForVerification;
+    private processBatchAsync;
     /**
-     * Handle successful migration completion
+     * === BACKPRESSURE: Synchronous Batch Processing ===
+     * Processes operations synchronously, waiting for broadcast completion.
+     * Used when backpressure forces sync to drain the pipeline.
      */
-    private onMigrationComplete;
+    private processBatchSync;
     /**
-     * Handle migration failure
+     * Forward operation to owner node and wait for completion.
+     * Used in sync processing mode.
      */
-    private onMigrationFailed;
+    private forwardOpAndWait;
     /**
-     * Handle MIGRATION_START message
+     * Process a single operation for batch processing.
+     * Uses shared applyOpToMap but collects events instead of broadcasting immediately.
      */
-    private handleMigrationStart;
+    private processLocalOpForBatch;
+    private handleClusterEvent;
+    getMap(name: string, typeHint?: 'LWW' | 'OR'): LWWMap<string, any> | ORMap<string, any>;
     /**
-     * Handle MIGRATION_CHUNK message
+     * Returns map after ensuring it's fully loaded from storage.
+     * Use this for queries to avoid returning empty results during initial load.
      */
-    private handleMigrationChunk;
+    getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
     /**
-     * Handle MIGRATION_COMPLETE message
+     * Phase 10.04: Get local record for anti-entropy repair
+     * Returns the LWWRecord for a key, used by RepairScheduler
      */
-    private handleMigrationComplete;
+    private getLocalRecord;
     /**
-     * Handle MIGRATION_CHUNK_ACK message
+     * Phase 10.04: Apply repaired record from anti-entropy repair
+     * Used by RepairScheduler to apply resolved conflicts
      */
-    private handleMigrationChunkAck;
+    private applyRepairRecord;
+    private loadMapFromStorage;
+    private startGarbageCollection;
     /**
-     * Handle MIGRATION_VERIFY message
+     * Starts the periodic check for dead clients (those that haven't sent PING).
      */
-    private handleMigrationVerify;
+    private startHeartbeatCheck;
     /**
-     * Reassemble chunks into continuous data
+     * Handles incoming PING message from client.
+     * Responds with PONG immediately.
      */
-    private reassemble;
+    private handlePing;
     /**
-     * Deserialize records from chunk data
+     * Checks if a client is still alive based on heartbeat.
      */
-    private deserializeRecords;
+    isClientAlive(clientId: string): boolean;
     /**
-     * Setup cluster message handlers
+     * Returns how long the client has been idle (no PING received).
+     */
+    getClientIdleTime(clientId: string): number;
+    /**
+     * Evicts clients that haven't sent a PING within the timeout period.
+     */
+    private evictDeadClients;
+    private reportLocalHlc;
+    private handleGcReport;
+    private performGarbageCollection;
+    private buildTLSOptions;
+    /**
+     * Get effective Write Concern level for an operation.
+     * Per-op writeConcern overrides batch-level.
      */
-    private setupMessageHandlers;
+    private getEffectiveWriteConcern;
     /**
-     * Check if a partition is currently migrating
+     * Convert string WriteConcern value to enum.
      */
-    isActive(partitionId: number): boolean;
+    private stringToWriteConcern;
     /**
-     * Get migration status
+     * Process batch with Write Concern tracking.
+     * Notifies WriteAckManager at each stage of processing.
      */
-    getStatus(): MigrationStatus;
+    private processBatchAsyncWithWriteConcern;
     /**
-     * Get migration metrics
+     * Synchronous batch processing with Write Concern.
      */
-    getMetrics(): MigrationMetrics;
+    private processBatchSyncWithWriteConcern;
     /**
-     * Cancel all active and queued migrations
+     * Process a single operation with Write Concern level notifications.
      */
-    cancelAll(): Promise<void>;
+    private processLocalOpWithWriteConcern;
     /**
-     * Cleanup resources (sync version for backwards compatibility)
+     * Persist operation synchronously (blocking).
+     * Used for PERSISTED Write Concern.
      */
-    close(): void;
+    private persistOpSync;
     /**
-     * Async cleanup - waits for cancellation to complete
+     * Persist operation asynchronously (fire-and-forget).
+     * Used for non-PERSISTED Write Concern levels.
      */
-    closeAsync(): Promise<void>;
+    private persistOpAsync;
 }
 
-interface PartitionDistribution {
-    owner: string;
-    backups: string[];
+interface PostgresAdapterOptions {
+    tableName?: string;
 }
-interface PartitionServiceEvents {
-    'rebalanced': (map: PartitionMap, changes: PartitionChange[]) => void;
-    'partitionMoved': (info: {
-        partitionId: number;
-        previousOwner: string;
-        newOwner: string;
-        version: number;
-    }) => void;
+declare class PostgresAdapter implements IServerStorage {
+    private pool;
+    private tableName;
+    constructor(configOrPool: PoolConfig | Pool, options?: PostgresAdapterOptions);
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
+    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
+    loadAllKeys(mapName: string): Promise<string[]>;
+    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
+    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
+    delete(mapName: string, key: string): Promise<void>;
+    deleteAll(mapName: string, keys: string[]): Promise<void>;
+    private mapRowToRecord;
+    private isORMapValue;
 }
-interface PartitionServiceConfig {
-    /** Enable gradual rebalancing (default: false for backward compatibility) */
-    gradualRebalancing: boolean;
-    /** Migration configuration */
-    migration: Partial<MigrationConfig>;
+
+/**
+ * In-memory implementation of IServerStorage.
+ * Useful for development, testing, and demos without requiring a database.
+ *
+ * Note: Data is lost when the server restarts.
+ */
+declare class MemoryServerAdapter implements IServerStorage {
+    private storage;
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    private getMap;
+    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
+    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
+    loadAllKeys(mapName: string): Promise<string[]>;
+    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
+    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
+    delete(mapName: string, key: string): Promise<void>;
+    deleteAll(mapName: string, keys: string[]): Promise<void>;
 }
-declare class PartitionService extends EventEmitter {
-    private cluster;
-    private partitions;
-    private readonly PARTITION_COUNT;
-    private readonly BACKUP_COUNT;
-    private mapVersion;
-    private lastRebalanceTime;
+
+declare class SecurityManager {
+    private policies;
+    constructor(policies?: PermissionPolicy[]);
+    addPolicy(policy: PermissionPolicy): void;
+    checkPermission(principal: Principal, mapName: string, action: PermissionType): boolean;
+    filterObject(object: any, principal: Principal, mapName: string): any;
+    private hasRole;
+    private matchesMap;
+}
+
+declare const logger: pino.Logger<never, boolean>;
+type Logger = typeof logger;
+
+/**
+ * ConnectionRateLimiter - Rate limiter for incoming WebSocket connections.
+ *
+ * Implements connection rate limiting to prevent connection storms and
+ * protect the server from being overwhelmed during high load scenarios.
+ *
+ * Features:
+ * - Limits connections per second to prevent TCP backlog exhaustion
+ * - Tracks pending connections (in-progress handshakes)
+ * - Provides graceful rejection when limits are exceeded
+ * - Auto-resets counters after cooldown period
+ */
+interface RateLimiterConfig {
+    /** Maximum new connections allowed per second (default: 100) */
+    maxConnectionsPerSecond: number;
+    /** Maximum pending connections waiting for handshake (default: 1000) */
+    maxPendingConnections: number;
+    /** Cooldown period in ms after which counters reset (default: 1000) */
+    cooldownMs: number;
+}
+interface RateLimiterStats {
+    /** Current connections per second rate */
+    connectionsPerSecond: number;
+    /** Number of connections currently pending (handshake in progress) */
+    pendingConnections: number;
+    /** Total connections established since start */
+    totalConnections: number;
+    /** Total connections rejected due to rate limiting */
+    totalRejected: number;
+}
+declare class ConnectionRateLimiter {
     private config;
-    private migrationManager;
-    constructor(cluster: ClusterManager, config?: Partial<PartitionServiceConfig>);
-    /**
-     * Handle membership change
-     */
-    private onMembershipChange;
-    getPartitionId(key: string): number;
-    getDistribution(key: string): PartitionDistribution;
-    getOwner(key: string): string;
-    isLocalOwner(key: string): boolean;
-    isLocalBackup(key: string): boolean;
-    isRelated(key: string): boolean;
-    /**
-     * Get current partition map version
-     */
-    getMapVersion(): number;
-    /**
-     * Generate full PartitionMap for client consumption
-     */
-    getPartitionMap(): PartitionMap;
+    /** Connection attempts in current window */
+    private connectionCount;
+    /** Timestamp when current window started */
+    private windowStart;
+    /** Currently pending connections (handshake in progress) */
+    private pendingCount;
+    /** Total connections established since start */
+    private totalConnections;
+    /** Total connections rejected since start */
+    private totalRejected;
+    constructor(config?: Partial<RateLimiterConfig>);
     /**
-     * Get partition info by ID
+     * Check if a new connection should be accepted.
+     * @returns true if the connection should be accepted, false if it should be rejected
      */
-    getPartitionInfo(partitionId: number): PartitionInfo | null;
+    shouldAccept(): boolean;
     /**
-     * Get owner node for a partition ID
+     * Register a connection attempt.
+     * Call this when a new connection is initiated (before handshake completes).
      */
-    getPartitionOwner(partitionId: number): string | null;
-    private rebalance;
+    onConnectionAttempt(): void;
     /**
-     * Perform gradual rebalancing using MigrationManager
+     * Register that a connection has been established (handshake complete).
+     * Call this when the connection is fully established and authenticated.
      */
-    private rebalanceGradual;
+    onConnectionEstablished(): void;
     /**
-     * Set partition owner (called after migration completes)
+     * Register that a connection has been closed.
+     * Call this when a pending connection is closed before completing handshake.
      */
-    setOwner(partitionId: number, nodeId: string): void;
+    onConnectionClosed(): void;
     /**
-     * Get backups for a partition
+     * Register that a connection was rejected.
+     * Call this when shouldAccept() returns false and the connection is rejected.
      */
-    getBackups(partitionId: number): string[];
+    onConnectionRejected(): void;
     /**
-     * Get migration status
+     * Decrease pending count when a connection times out or fails.
+     * Call this when a pending connection fails to complete handshake.
      */
-    getMigrationStatus(): MigrationStatus | null;
+    onPendingConnectionFailed(): void;
     /**
-     * Check if partition is currently migrating
+     * Get current rate limiter statistics.
      */
-    isMigrating(partitionId: number): boolean;
+    getStats(): RateLimiterStats;
     /**
-     * Check if any partition is currently migrating
+     * Reset the rate limiter state.
+     * Useful for testing or when recovering from errors.
      */
-    isRebalancing(): boolean;
+    reset(): void;
     /**
-     * Get MigrationManager for configuration
+     * Update configuration at runtime.
      */
-    getMigrationManager(): MigrationManager | null;
+    updateConfig(config: Partial<RateLimiterConfig>): void;
     /**
-     * Cancel all migrations
+     * Check if window has expired and reset if needed.
      */
-    cancelMigrations(): Promise<void>;
+    private maybeResetWindow;
+}
+
+declare class TimestampInterceptor implements IInterceptor {
+    name: string;
+    onBeforeOp(op: ServerOp, context: OpContext): Promise<ServerOp>;
+}
+
+interface RateLimitConfig {
+    windowMs: number;
+    maxOps: number;
+}
+declare class RateLimitInterceptor implements IInterceptor {
+    name: string;
+    private limits;
+    private config;
+    constructor(config?: RateLimitConfig);
+    onBeforeOp(op: ServerOp, context: OpContext): Promise<ServerOp | null>;
+    onDisconnect(context: any): Promise<void>;
+}
+
+/**
+ * Native Module Statistics
+ *
+ * Provides information about available native optimizations.
+ *
+ * Phase 3.05: Integration
+ */
+
+/**
+ * Native module availability status
+ */
+interface NativeModuleStatus {
+    /** Native xxHash64 is available and being used */
+    nativeHash: boolean;
+    /** SharedArrayBuffer is available */
+    sharedArrayBuffer: boolean;
+}
+/**
+ * Comprehensive native statistics
+ */
+interface NativeStats {
+    /** Module availability status */
+    modules: NativeModuleStatus;
+    /** Shared memory statistics (if enabled) */
+    sharedMemory: SharedMemoryStats | null;
+    /** Summary of what's being used */
+    summary: string;
 }
+/**
+ * Check which native modules are available.
+ */
+declare function getNativeModuleStatus(): NativeModuleStatus;
+/**
+ * Get native statistics including shared memory.
+ *
+ * @param sharedMemoryManager - Optional SharedMemoryManager instance
+ */
+declare function getNativeStats(sharedMemoryManager?: SharedMemoryManager): NativeStats;
+/**
+ * Log native module status to console.
+ */
+declare function logNativeStatus(): void;
 
 /**
  * LagTracker - Monitors replication lag across cluster nodes
@@ -3687,6 +4056,7 @@ declare class RepairScheduler extends EventEmitter {
     private activeRepairs;
     private scanTimer?;
     private processTimer?;
+    private initialScanTimer?;
     private started;
     private pendingRequests;
     private metrics;
@@ -3955,792 +4325,530 @@ declare class EntryProcessorHandler {
         fallbackScripts: number;
     };
     /**
-     * Clear sandbox cache.
-     */
-    clearCache(processorName?: string): void;
-    /**
-     * Dispose of the handler and its sandbox.
-     */
-    dispose(): void;
-}
-
-/**
- * Configuration for ConflictResolverService.
- */
-interface ConflictResolverServiceConfig {
-    /** Maximum resolvers per map */
-    maxResolversPerMap: number;
-    /** Enable sandboxed code execution (requires isolated-vm) */
-    enableSandboxedResolvers: boolean;
-    /** Default timeout for resolver execution in milliseconds */
-    resolverTimeoutMs: number;
-}
-/**
- * Default service configuration.
- */
-declare const DEFAULT_CONFLICT_RESOLVER_CONFIG: ConflictResolverServiceConfig;
-/**
- * Service for managing and executing conflict resolvers.
- *
- * Resolvers are executed in priority order (highest first).
- * The first resolver that returns a non-'local' action wins.
- * If all resolvers return 'local', LWW is used as fallback.
- *
- * ## Design Decisions
- *
- * ### In-Memory Storage
- * Resolvers are stored in memory only (not persisted to database).
- * This is intentional - resolvers represent application logic that should
- * be registered by clients on connection. Benefits:
- * - Simpler architecture without resolver schema migrations
- * - Clients control their own conflict resolution logic
- * - Natural cleanup when client disconnects
- *
- * ### Permission Model
- * Resolver registration requires PUT permission on the target map.
- * This aligns with the principle that if you can write to a map,
- * you can define how your writes are resolved. For stricter control,
- * implement custom permission checks in ServerCoordinator.
- *
- * ### Deletion Handling
- * Deletions (tombstones with null value) are passed through resolvers
- * with `remoteValue: null`. This allows resolvers like IMMUTABLE or
- * OWNER_ONLY to protect against unauthorized deletions.
- */
-declare class ConflictResolverService {
-    private resolvers;
-    private sandbox;
-    private config;
-    private onRejectionCallback?;
-    private disposed;
-    constructor(sandbox: ProcessorSandbox, config?: Partial<ConflictResolverServiceConfig>);
-    /**
-     * Set callback for merge rejections.
-     */
-    onRejection(callback: (rejection: MergeRejection) => void): void;
-    /**
-     * Register a resolver for a map.
-     *
-     * @param mapName The map this resolver applies to
-     * @param resolver The resolver definition
-     * @param registeredBy Optional client ID that registered this resolver
-     */
-    register<V>(mapName: string, resolver: ConflictResolverDef<V>, registeredBy?: string): void;
-    /**
-     * Unregister a resolver.
-     *
-     * @param mapName The map name
-     * @param resolverName The resolver name to unregister
-     * @param clientId Optional - only unregister if registered by this client
-     */
-    unregister(mapName: string, resolverName: string, clientId?: string): boolean;
-    /**
-     * Resolve a merge conflict using registered resolvers.
-     *
-     * @param context The merge context
-     * @returns The merge result
-     */
-    resolve<V>(context: MergeContext<V>): Promise<MergeResult<V>>;
-    /**
-     * List registered resolvers.
-     *
-     * @param mapName Optional - filter by map name
-     */
-    list(mapName?: string): Array<{
-        mapName: string;
-        name: string;
-        priority?: number;
-        keyPattern?: string;
-        registeredBy?: string;
-    }>;
-    /**
-     * Check if a map has any registered resolvers.
-     */
-    hasResolvers(mapName: string): boolean;
-    /**
-     * Get the number of registered resolvers.
-     */
-    get size(): number;
-    /**
-     * Clear all registered resolvers.
-     *
-     * @param mapName Optional - only clear resolvers for specific map
-     */
-    clear(mapName?: string): void;
-    /**
-     * Clear resolvers registered by a specific client.
-     */
-    clearByClient(clientId: string): number;
-    /**
-     * Dispose the service.
-     */
-    dispose(): void;
-    /**
-     * Match a key against a glob-like pattern.
-     * Supports * (any chars) and ? (single char).
-     */
-    private matchKeyPattern;
-    /**
-     * Compile sandboxed resolver code.
-     */
-    private compileSandboxed;
-}
-
-/**
- * Configuration for MapWithResolver.
- */
-interface MapWithResolverConfig {
-    /** Map name */
-    name: string;
-    /** Node ID for HLC */
-    nodeId: string;
-    /** Conflict resolver service */
-    resolverService: ConflictResolverService;
-    /** Callback for merge rejections */
-    onRejection?: (rejection: MergeRejection) => void;
-}
-/**
- * Result of setWithResolver operation.
- */
-interface SetWithResolverResult<V> {
-    /** Whether the value was applied */
-    applied: boolean;
-    /** The merge result */
-    result: MergeResult<V>;
-    /** The final record if applied */
-    record?: LWWRecord<V>;
-}
-/**
- * Extended LWWMap that supports custom conflict resolvers.
- *
- * This wrapper delegates merge operations to ConflictResolverService,
- * allowing custom business logic to intercept and modify merge behavior.
- */
-declare class MapWithResolver<K extends string, V> {
-    private map;
-    private resolverService;
-    private mapName;
-    private hlc;
-    private onRejection?;
-    constructor(config: MapWithResolverConfig);
-    /**
-     * Get the map name.
-     */
-    get name(): string;
-    /**
-     * Get the underlying LWWMap.
-     */
-    get rawMap(): LWWMap<K, V>;
-    /**
-     * Get a value by key.
-     */
-    get(key: K): V | undefined;
-    /**
-     * Get the full record for a key.
-     */
-    getRecord(key: K): LWWRecord<V> | undefined;
-    /**
-     * Get the timestamp for a key.
-     */
-    getTimestamp(key: K): Timestamp | undefined;
-    /**
-     * Set a value locally (no resolver).
-     * Use for server-initiated writes.
-     */
-    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
-    /**
-     * Set a value with conflict resolution.
-     * Use for client-initiated writes.
-     *
-     * @param key The key to set
-     * @param value The new value
-     * @param timestamp The client's timestamp
-     * @param remoteNodeId The client's node ID
-     * @param auth Optional authentication context
-     * @returns Result containing applied status and merge result
-     */
-    setWithResolver(key: K, value: V, timestamp: Timestamp, remoteNodeId: string, auth?: MergeContext['auth']): Promise<SetWithResolverResult<V>>;
-    /**
-     * Remove a key.
-     */
-    remove(key: K): LWWRecord<V>;
-    /**
-     * Standard merge without resolver (for sync operations).
-     */
-    merge(key: K, record: LWWRecord<V>): boolean;
-    /**
-     * Merge with resolver support.
-     * Equivalent to setWithResolver but takes a full record.
-     */
-    mergeWithResolver(key: K, record: LWWRecord<V>, remoteNodeId: string, auth?: MergeContext['auth']): Promise<SetWithResolverResult<V>>;
-    /**
-     * Clear all data.
-     */
-    clear(): void;
-    /**
-     * Get map size.
-     */
-    get size(): number;
-    /**
-     * Iterate over entries.
-     */
-    entries(): IterableIterator<[K, V]>;
-    /**
-     * Get all keys.
-     */
-    allKeys(): IterableIterator<K>;
-    /**
-     * Subscribe to changes.
-     */
-    onChange(callback: () => void): () => void;
-    /**
-     * Get MerkleTree for sync.
+     * Clear sandbox cache.
      */
-    getMerkleTree(): _topgunbuild_core.MerkleTree;
+    clearCache(processorName?: string): void;
     /**
-     * Prune old tombstones.
+     * Dispose of the handler and its sandbox.
      */
-    prune(olderThan: Timestamp): K[];
+    dispose(): void;
 }
 
 /**
- * Configuration for ConflictResolverHandler.
+ * Configuration for ConflictResolverService.
  */
-interface ConflictResolverHandlerConfig {
-    /** Node ID for identifying server-side resolvers */
-    nodeId: string;
-    /** Optional sandbox configuration override */
-    sandboxConfig?: Partial<ProcessorSandboxConfig>;
-    /** Optional resolver service configuration */
-    resolverConfig?: Partial<ConflictResolverServiceConfig>;
+interface ConflictResolverServiceConfig {
+    /** Maximum resolvers per map */
+    maxResolversPerMap: number;
+    /** Enable sandboxed code execution (requires isolated-vm) */
+    enableSandboxedResolvers: boolean;
+    /** Default timeout for resolver execution in milliseconds */
+    resolverTimeoutMs: number;
 }
 /**
- * Result of merge operation with resolver.
+ * Default service configuration.
  */
-interface MergeWithResolverResult<V> {
-    /** Whether the merge was applied */
-    applied: boolean;
-    /** The merge result details */
-    result: MergeResult<V>;
-    /** The final record if applied */
-    record?: LWWRecord<V>;
-    /** Rejection details if rejected */
-    rejection?: MergeRejection;
-}
+declare const DEFAULT_CONFLICT_RESOLVER_CONFIG: ConflictResolverServiceConfig;
 /**
- * Server-side handler for Conflict Resolver operations.
+ * Service for managing and executing conflict resolvers.
  *
- * Responsibilities:
- * - Manage conflict resolver registrations
- * - Execute resolvers during merge operations
- * - Provide merge rejection notifications
+ * Resolvers are executed in priority order (highest first).
+ * The first resolver that returns a non-'local' action wins.
+ * If all resolvers return 'local', LWW is used as fallback.
+ *
+ * ## Design Decisions
+ *
+ * ### In-Memory Storage
+ * Resolvers are stored in memory only (not persisted to database).
+ * This is intentional - resolvers represent application logic that should
+ * be registered by clients on connection. Benefits:
+ * - Simpler architecture without resolver schema migrations
+ * - Clients control their own conflict resolution logic
+ * - Natural cleanup when client disconnects
+ *
+ * ### Permission Model
+ * Resolver registration requires PUT permission on the target map.
+ * This aligns with the principle that if you can write to a map,
+ * you can define how your writes are resolved. For stricter control,
+ * implement custom permission checks in ServerCoordinator.
+ *
+ * ### Deletion Handling
+ * Deletions (tombstones with null value) are passed through resolvers
+ * with `remoteValue: null`. This allows resolvers like IMMUTABLE or
+ * OWNER_ONLY to protect against unauthorized deletions.
  */
-declare class ConflictResolverHandler {
+declare class ConflictResolverService {
+    private resolvers;
     private sandbox;
-    private resolverService;
-    /** Reserved for future use (server-side resolver identification) */
-    private readonly nodeId;
-    private rejectionListeners;
-    constructor(config: ConflictResolverHandlerConfig);
+    private config;
+    private onRejectionCallback?;
+    private disposed;
+    constructor(sandbox: ProcessorSandbox, config?: Partial<ConflictResolverServiceConfig>);
     /**
-     * Register a conflict resolver for a map.
+     * Set callback for merge rejections.
+     */
+    onRejection(callback: (rejection: MergeRejection) => void): void;
+    /**
+     * Register a resolver for a map.
      *
-     * @param mapName The map name
+     * @param mapName The map this resolver applies to
      * @param resolver The resolver definition
-     * @param clientId Optional client ID that registered this resolver
+     * @param registeredBy Optional client ID that registered this resolver
      */
-    registerResolver<V>(mapName: string, resolver: ConflictResolverDef<V>, clientId?: string): void;
+    register<V>(mapName: string, resolver: ConflictResolverDef<V>, registeredBy?: string): void;
     /**
-     * Unregister a conflict resolver.
+     * Unregister a resolver.
      *
      * @param mapName The map name
-     * @param resolverName The resolver name
+     * @param resolverName The resolver name to unregister
      * @param clientId Optional - only unregister if registered by this client
      */
-    unregisterResolver(mapName: string, resolverName: string, clientId?: string): boolean;
+    unregister(mapName: string, resolverName: string, clientId?: string): boolean;
+    /**
+     * Resolve a merge conflict using registered resolvers.
+     *
+     * @param context The merge context
+     * @returns The merge result
+     */
+    resolve<V>(context: MergeContext<V>): Promise<MergeResult<V>>;
     /**
      * List registered resolvers.
      *
      * @param mapName Optional - filter by map name
      */
-    listResolvers(mapName?: string): Array<{
+    list(mapName?: string): Array<{
         mapName: string;
         name: string;
         priority?: number;
         keyPattern?: string;
+        registeredBy?: string;
     }>;
     /**
-     * Apply a merge with conflict resolution.
-     *
-     * Deletions (tombstones) are also passed through resolvers to allow
-     * protection via IMMUTABLE, OWNER_ONLY, or similar resolvers.
-     * If no custom resolvers are registered, deletions use standard LWW.
-     *
-     * @param map The LWWMap to merge into
-     * @param mapName The map name (for resolver lookup)
-     * @param key The key being merged
-     * @param record The incoming record
-     * @param remoteNodeId The source node ID
-     * @param auth Optional authentication context
+     * Check if a map has any registered resolvers.
      */
-    mergeWithResolver<V>(map: LWWMap<string, V>, mapName: string, key: string, record: LWWRecord<V>, remoteNodeId: string, auth?: MergeContext['auth']): Promise<MergeWithResolverResult<V>>;
+    hasResolvers(mapName: string): boolean;
     /**
-     * Check if a map has custom resolvers registered.
+     * Get the number of registered resolvers.
      */
-    hasResolvers(mapName: string): boolean;
+    get size(): number;
     /**
-     * Add a listener for merge rejections.
+     * Clear all registered resolvers.
+     *
+     * @param mapName Optional - only clear resolvers for specific map
      */
-    onRejection(listener: (rejection: MergeRejection) => void): () => void;
+    clear(mapName?: string): void;
     /**
      * Clear resolvers registered by a specific client.
      */
     clearByClient(clientId: string): number;
     /**
-     * Get the number of registered resolvers.
+     * Dispose the service.
      */
-    get resolverCount(): number;
+    dispose(): void;
     /**
-     * Check if sandbox is in secure mode.
+     * Match a key against a glob-like pattern.
+     * Supports * (any chars) and ? (single char).
      */
-    isSecureMode(): boolean;
+    private matchKeyPattern;
     /**
-     * Dispose of the handler.
+     * Compile sandboxed resolver code.
      */
-    dispose(): void;
+    private compileSandboxed;
 }
 
 /**
- * IndexConfig Types
- *
- * Configuration types for server-side index management.
- * Used to define indexes per map at server startup.
- *
- * @module config/IndexConfig
- */
-/**
- * Definition of a single index on a map.
- */
-interface IndexDefinition {
-    /** Attribute name (supports dot notation for nested attributes, e.g., "user.email") */
-    attribute: string;
-    /** Index type */
-    type: 'hash' | 'navigable';
-    /**
-     * Comparator type for navigable indexes.
-     * Defaults to natural ordering (string/number).
-     */
-    comparator?: 'number' | 'string' | 'date';
-}
-/**
- * Index configuration for a specific map.
+ * Configuration for MapWithResolver.
  */
-interface MapIndexConfig {
+interface MapWithResolverConfig {
     /** Map name */
-    mapName: string;
-    /** Indexes to create on this map */
-    indexes: IndexDefinition[];
+    name: string;
+    /** Node ID for HLC */
+    nodeId: string;
+    /** Conflict resolver service */
+    resolverService: ConflictResolverService;
+    /** Callback for merge rejections */
+    onRejection?: (rejection: MergeRejection) => void;
 }
 /**
- * Server-wide index configuration.
+ * Result of setWithResolver operation.
  */
-interface ServerIndexConfig {
-    /**
-     * Auto-create indexes based on query patterns.
-     * When enabled, the server will analyze query patterns and suggest/create indexes.
-     * Default: false
-     */
-    autoIndex?: boolean;
-    /**
-     * Maximum number of auto-created indexes per map.
-     * Prevents unbounded memory growth from auto-indexing.
-     * Default: 10
-     */
-    maxAutoIndexesPerMap?: number;
-    /**
-     * Pre-configured indexes per map.
-     * These indexes are created at map initialization.
-     */
-    maps?: MapIndexConfig[];
-    /**
-     * Whether to log index usage statistics.
-     * Default: false
-     */
-    logStats?: boolean;
-    /**
-     * Interval in milliseconds for logging index statistics.
-     * Only used if logStats is true.
-     * Default: 60000 (1 minute)
-     */
-    statsLogInterval?: number;
+interface SetWithResolverResult<V> {
+    /** Whether the value was applied */
+    applied: boolean;
+    /** The merge result */
+    result: MergeResult<V>;
+    /** The final record if applied */
+    record?: LWWRecord<V>;
 }
 /**
- * Default index configuration.
- */
-declare const DEFAULT_INDEX_CONFIG: ServerIndexConfig;
-/**
- * Validate a ServerIndexConfig object.
- *
- * @param config - Config to validate
- * @returns Array of validation errors (empty if valid)
- */
-declare function validateIndexConfig(config: ServerIndexConfig): string[];
-/**
- * Merge user config with defaults.
- *
- * @param userConfig - User-provided config
- * @returns Merged config with defaults
- */
-declare function mergeWithDefaults(userConfig: Partial<ServerIndexConfig>): ServerIndexConfig;
-
-/**
- * MapFactory Implementation
- *
- * Factory for creating LWWMap or IndexedLWWMap based on configuration.
- * Used by ServerCoordinator to create maps with proper indexes.
+ * Extended LWWMap that supports custom conflict resolvers.
  *
- * @module config/MapFactory
- */
-
-/**
- * Factory for creating indexed or regular CRDT maps.
+ * This wrapper delegates merge operations to ConflictResolverService,
+ * allowing custom business logic to intercept and modify merge behavior.
  */
-declare class MapFactory {
-    private readonly config;
-    private readonly mapConfigs;
+declare class MapWithResolver<K extends string, V> {
+    private map;
+    private resolverService;
+    private mapName;
+    private hlc;
+    private onRejection?;
+    constructor(config: MapWithResolverConfig);
     /**
-     * Create a MapFactory.
-     *
-     * @param config - Server index configuration
+     * Get the map name.
      */
-    constructor(config?: Partial<ServerIndexConfig>);
+    get name(): string;
     /**
-     * Create an LWWMap or IndexedLWWMap based on configuration.
-     *
-     * @param mapName - Name of the map
-     * @param hlc - Hybrid Logical Clock instance
-     * @returns LWWMap or IndexedLWWMap depending on configuration
+     * Get the underlying LWWMap.
      */
-    createLWWMap<V>(mapName: string, hlc: HLC): LWWMap<string, V> | IndexedLWWMap<string, V>;
+    get rawMap(): LWWMap<K, V>;
     /**
-     * Create an ORMap or IndexedORMap based on configuration.
-     *
-     * @param mapName - Name of the map
-     * @param hlc - Hybrid Logical Clock instance
-     * @returns ORMap or IndexedORMap depending on configuration
+     * Get a value by key.
      */
-    createORMap<V>(mapName: string, hlc: HLC): ORMap<string, V> | IndexedORMap<string, V>;
+    get(key: K): V | undefined;
     /**
-     * Add an index to an IndexedLWWMap based on definition.
+     * Get the full record for a key.
      */
-    private addIndexToLWWMap;
+    getRecord(key: K): LWWRecord<V> | undefined;
     /**
-     * Add an index to an IndexedORMap based on definition.
+     * Get the timestamp for a key.
      */
-    private addIndexToORMap;
+    getTimestamp(key: K): Timestamp | undefined;
     /**
-     * Create an Attribute for extracting values from records.
-     * Supports dot notation for nested paths.
+     * Set a value locally (no resolver).
+     * Use for server-initiated writes.
      */
-    private createAttribute;
+    set(key: K, value: V, ttlMs?: number): LWWRecord<V>;
     /**
-     * Get a nested value from an object using dot notation.
+     * Set a value with conflict resolution.
+     * Use for client-initiated writes.
      *
-     * @param obj - Object to extract value from
-     * @param path - Dot-notation path (e.g., "user.email")
-     * @returns Value at the path or undefined
+     * @param key The key to set
+     * @param value The new value
+     * @param timestamp The client's timestamp
+     * @param remoteNodeId The client's node ID
+     * @param auth Optional authentication context
+     * @returns Result containing applied status and merge result
      */
-    private getNestedValue;
+    setWithResolver(key: K, value: V, timestamp: Timestamp, remoteNodeId: string, auth?: MergeContext['auth']): Promise<SetWithResolverResult<V>>;
     /**
-     * Create a comparator function for navigable indexes.
+     * Remove a key.
      */
-    private createComparator;
+    remove(key: K): LWWRecord<V>;
     /**
-     * Check if a map should be indexed based on configuration.
-     *
-     * @param mapName - Name of the map
-     * @returns true if map has index configuration
+     * Standard merge without resolver (for sync operations).
      */
-    hasIndexConfig(mapName: string): boolean;
+    merge(key: K, record: LWWRecord<V>): boolean;
     /**
-     * Get index configuration for a map.
-     *
-     * @param mapName - Name of the map
-     * @returns Map index config or undefined
+     * Merge with resolver support.
+     * Equivalent to setWithResolver but takes a full record.
      */
-    getMapConfig(mapName: string): MapIndexConfig | undefined;
+    mergeWithResolver(key: K, record: LWWRecord<V>, remoteNodeId: string, auth?: MergeContext['auth']): Promise<SetWithResolverResult<V>>;
     /**
-     * Get all configured map names.
-     *
-     * @returns Array of map names with index configuration
+     * Clear all data.
      */
-    getConfiguredMaps(): string[];
+    clear(): void;
     /**
-     * Get the full server index configuration.
+     * Get map size.
      */
-    getConfig(): ServerIndexConfig;
+    get size(): number;
+    /**
+     * Iterate over entries.
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * Get all keys.
+     */
+    allKeys(): IterableIterator<K>;
+    /**
+     * Subscribe to changes.
+     */
+    onChange(callback: () => void): () => void;
+    /**
+     * Get MerkleTree for sync.
+     */
+    getMerkleTree(): _topgunbuild_core.MerkleTree;
+    /**
+     * Prune old tombstones.
+     */
+    prune(olderThan: Timestamp): K[];
 }
 
 /**
- * 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.
+ * Configuration for ConflictResolverHandler.
  */
-interface SearchConfig extends FullTextIndexConfig {
+interface ConflictResolverHandlerConfig {
+    /** Node ID for identifying server-side resolvers */
+    nodeId: string;
+    /** Optional sandbox configuration override */
+    sandboxConfig?: Partial<ProcessorSandboxConfig>;
+    /** Optional resolver service configuration */
+    resolverConfig?: Partial<ConflictResolverServiceConfig>;
 }
 /**
- * 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.
+ * Result of merge operation with resolver.
  */
-interface BatchedUpdate {
-    key: string;
-    value: unknown;
-    score: number;
-    matchedTerms: string[];
-    type: SearchUpdateType;
+interface MergeWithResolverResult<V> {
+    /** Whether the merge was applied */
+    applied: boolean;
+    /** The merge result details */
+    result: MergeResult<V>;
+    /** The final record if applied */
+    record?: LWWRecord<V>;
+    /** Rejection details if rejected */
+    rejection?: MergeRejection;
 }
 /**
- * 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.
+ * Server-side handler for Conflict Resolver operations.
  *
  * 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 }
- * });
- * ```
+ * - Manage conflict resolver registrations
+ * - Execute resolvers during merge operations
+ * - Provide merge rejection notifications
  */
-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();
+declare class ConflictResolverHandler {
+    private sandbox;
+    private resolverService;
+    /** Reserved for future use (server-side resolver identification) */
+    private readonly nodeId;
+    private rejectionListeners;
+    constructor(config: ConflictResolverHandlerConfig);
     /**
-     * Set the callback for sending updates to clients.
-     * Called by ServerCoordinator during initialization.
+     * Register a conflict resolver for a map.
+     *
+     * @param mapName The map name
+     * @param resolver The resolver definition
+     * @param clientId Optional client ID that registered this resolver
+     */
+    registerResolver<V>(mapName: string, resolver: ConflictResolverDef<V>, clientId?: string): void;
+    /**
+     * Unregister a conflict resolver.
+     *
+     * @param mapName The map name
+     * @param resolverName The resolver name
+     * @param clientId Optional - only unregister if registered by this client
+     */
+    unregisterResolver(mapName: string, resolverName: string, clientId?: string): boolean;
+    /**
+     * List registered resolvers.
+     *
+     * @param mapName Optional - filter by map name
+     */
+    listResolvers(mapName?: string): Array<{
+        mapName: string;
+        name: string;
+        priority?: number;
+        keyPattern?: string;
+    }>;
+    /**
+     * Apply a merge with conflict resolution.
+     *
+     * Deletions (tombstones) are also passed through resolvers to allow
+     * protection via IMMUTABLE, OWNER_ONLY, or similar resolvers.
+     * If no custom resolvers are registered, deletions use standard LWW.
+     *
+     * @param map The LWWMap to merge into
+     * @param mapName The map name (for resolver lookup)
+     * @param key The key being merged
+     * @param record The incoming record
+     * @param remoteNodeId The source node ID
+     * @param auth Optional authentication context
+     */
+    mergeWithResolver<V>(map: LWWMap<string, V>, mapName: string, key: string, record: LWWRecord<V>, remoteNodeId: string, auth?: MergeContext['auth']): Promise<MergeWithResolverResult<V>>;
+    /**
+     * Check if a map has custom resolvers registered.
      */
-    setSendUpdateCallback(callback: SendUpdateCallback): void;
+    hasResolvers(mapName: string): boolean;
     /**
-     * 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
+     * Add a listener for merge rejections.
      */
-    setSendBatchUpdateCallback(callback: SendBatchUpdateCallback): void;
+    onRejection(listener: (rejection: MergeRejection) => void): () => void;
     /**
-     * Set the callback for retrieving document values.
-     * Called by ServerCoordinator during initialization.
+     * Clear resolvers registered by a specific client.
      */
-    setDocumentValueGetter(getter: (mapName: string, key: string) => unknown | undefined): void;
+    clearByClient(clientId: string): number;
     /**
-     * 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)
+     * Get the number of registered resolvers.
      */
-    enableSearch(mapName: string, config: SearchConfig): void;
+    get resolverCount(): number;
     /**
-     * Disable full-text search for a map.
-     *
-     * @param mapName - Name of the map to disable FTS for
+     * Check if sandbox is in secure mode.
      */
-    disableSearch(mapName: string): void;
+    isSecureMode(): boolean;
     /**
-     * Check if FTS is enabled for a map.
+     * Dispose of the handler.
      */
-    isSearchEnabled(mapName: string): boolean;
+    dispose(): void;
+}
+
+/**
+ * IndexConfig Types
+ *
+ * Configuration types for server-side index management.
+ * Used to define indexes per map at server startup.
+ *
+ * @module config/IndexConfig
+ */
+/**
+ * Definition of a single index on a map.
+ */
+interface IndexDefinition {
+    /** Attribute name (supports dot notation for nested attributes, e.g., "user.email") */
+    attribute: string;
+    /** Index type */
+    type: 'hash' | 'navigable';
     /**
-     * Get enabled map names.
+     * Comparator type for navigable indexes.
+     * Defaults to natural ordering (string/number).
      */
-    getEnabledMaps(): string[];
+    comparator?: 'number' | 'string' | 'date';
+}
+/**
+ * Index configuration for a specific map.
+ */
+interface MapIndexConfig {
+    /** Map name */
+    mapName: string;
+    /** Indexes to create on this map */
+    indexes: IndexDefinition[];
+}
+/**
+ * Server-wide index configuration.
+ */
+interface ServerIndexConfig {
     /**
-     * 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
+     * Auto-create indexes based on query patterns.
+     * When enabled, the server will analyze query patterns and suggest/create indexes.
+     * Default: false
      */
-    search(mapName: string, query: string, options?: FTSSearchOptions): SearchRespPayload;
+    autoIndex?: boolean;
     /**
-     * Handle document set/update.
-     * Called by ServerCoordinator when data changes.
-     *
-     * @param mapName - Name of the map
-     * @param key - Document key
-     * @param value - Document value
+     * Maximum number of auto-created indexes per map.
+     * Prevents unbounded memory growth from auto-indexing.
+     * Default: 10
      */
-    onDataChange(mapName: string, key: string, value: Record<string, unknown> | null | undefined, changeType: 'add' | 'update' | 'remove'): void;
+    maxAutoIndexesPerMap?: number;
     /**
-     * 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
+     * Pre-configured indexes per map.
+     * These indexes are created at map initialization.
      */
-    buildIndexFromEntries(mapName: string, entries: Iterable<[string, Record<string, unknown> | null]>): void;
+    maps?: MapIndexConfig[];
     /**
-     * Get index statistics for monitoring.
+     * Whether to log index usage statistics.
+     * Default: false
      */
-    getIndexStats(mapName: string): {
-        documentCount: number;
-        fields: string[];
-    } | null;
+    logStats?: boolean;
     /**
-     * Clear all indexes (for testing or shutdown).
+     * Interval in milliseconds for logging index statistics.
+     * Only used if logStats is true.
+     * Default: 60000 (1 minute)
      */
-    clear(): void;
+    statsLogInterval?: number;
+}
+/**
+ * Default index configuration.
+ */
+declare const DEFAULT_INDEX_CONFIG: ServerIndexConfig;
+/**
+ * Validate a ServerIndexConfig object.
+ *
+ * @param config - Config to validate
+ * @returns Array of validation errors (empty if valid)
+ */
+declare function validateIndexConfig(config: ServerIndexConfig): string[];
+/**
+ * Merge user config with defaults.
+ *
+ * @param userConfig - User-provided config
+ * @returns Merged config with defaults
+ */
+declare function mergeWithDefaults(userConfig: Partial<ServerIndexConfig>): ServerIndexConfig;
+
+/**
+ * MapFactory Implementation
+ *
+ * Factory for creating LWWMap or IndexedLWWMap based on configuration.
+ * Used by ServerCoordinator to create maps with proper indexes.
+ *
+ * @module config/MapFactory
+ */
+
+/**
+ * Factory for creating indexed or regular CRDT maps.
+ */
+declare class MapFactory {
+    private readonly config;
+    private readonly mapConfigs;
     /**
-     * Subscribe to live search results.
-     * Returns initial results and tracks the subscription for delta updates.
+     * Create a MapFactory.
      *
-     * @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
+     * @param config - Server index configuration
      */
-    subscribe(clientId: string, subscriptionId: string, mapName: string, query: string, options?: SearchOptions): ServerSearchResult[];
+    constructor(config?: Partial<ServerIndexConfig>);
     /**
-     * Unsubscribe from a live search.
+     * Create an LWWMap or IndexedLWWMap based on configuration.
      *
-     * @param subscriptionId - Subscription to remove
+     * @param mapName - Name of the map
+     * @param hlc - Hybrid Logical Clock instance
+     * @returns LWWMap or IndexedLWWMap depending on configuration
      */
-    unsubscribe(subscriptionId: string): void;
+    createLWWMap<V>(mapName: string, hlc: HLC): LWWMap<string, V> | IndexedLWWMap<string, V>;
     /**
-     * Unsubscribe all subscriptions for a client.
-     * Called when a client disconnects.
+     * Create an ORMap or IndexedORMap based on configuration.
      *
-     * @param clientId - ID of the disconnected client
+     * @param mapName - Name of the map
+     * @param hlc - Hybrid Logical Clock instance
+     * @returns ORMap or IndexedORMap depending on configuration
      */
-    unsubscribeClient(clientId: string): void;
+    createORMap<V>(mapName: string, hlc: HLC): ORMap<string, V> | IndexedORMap<string, V>;
     /**
-     * Get the number of active subscriptions.
+     * Add an index to an IndexedLWWMap based on definition.
      */
-    getSubscriptionCount(): number;
+    private addIndexToLWWMap;
     /**
-     * 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
+     * Add an index to an IndexedORMap based on definition.
      */
-    private notifySubscribers;
+    private addIndexToORMap;
     /**
-     * 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
+     * Create an Attribute for extracting values from records.
+     * Supports dot notation for nested paths.
      */
-    private scoreDocument;
+    private createAttribute;
     /**
-     * Queue a notification for batched processing.
-     * Notifications are collected and processed together after BATCH_INTERVAL.
+     * Get a nested value from an object using dot notation.
      *
-     * @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
+     * @param obj - Object to extract value from
+     * @param path - Dot-notation path (e.g., "user.email")
+     * @returns Value at the path or undefined
      */
-    queueNotification(mapName: string, key: string, value: Record<string, unknown> | null, changeType: 'add' | 'update' | 'remove'): void;
+    private getNestedValue;
     /**
-     * Schedule a flush of pending notifications.
-     * Uses setTimeout to batch notifications within BATCH_INTERVAL window.
+     * Create a comparator function for navigable indexes.
      */
-    private scheduleNotificationFlush;
+    private createComparator;
     /**
-     * Flush all pending notifications.
-     * Processes each map's notifications and sends batched updates.
+     * Check if a map should be indexed based on configuration.
+     *
+     * @param mapName - Name of the map
+     * @returns true if map has index configuration
      */
-    flushNotifications(): void;
+    hasIndexConfig(mapName: string): boolean;
     /**
-     * Process batched notifications for a single map.
-     * Computes updates for each subscription and sends as a batch.
+     * Get index configuration for a map.
      *
      * @param mapName - Name of the map
-     * @param notifications - Array of pending notifications
+     * @returns Map index config or undefined
      */
-    private processBatchedNotifications;
+    getMapConfig(mapName: string): MapIndexConfig | undefined;
     /**
-     * Compute the update for a single document change against a subscription.
-     * Returns null if no update is needed.
+     * Get all configured map names.
      *
-     * @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
+     * @returns Array of map names with index configuration
      */
-    private computeSubscriptionUpdate;
+    getConfiguredMaps(): string[];
+    /**
+     * Get the full server index configuration.
+     */
+    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_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 };