@topgunbuild/server 0.2.0 → 0.3.0

package/dist/index.d.mts

@@ -1,333 +1,3051 @@
-import { LWWRecord, ORMapRecord, Principal, PermissionPolicy, LWWMap, ORMap, PermissionType } from '@topgunbuild/core';
+import { Timestamp, LWWRecord, ORMapRecord, Principal, PermissionPolicy, ConsistencyLevel, ReplicationConfig, LWWMap, ORMap, PermissionType, MigrationConfig, MigrationStatus, MigrationMetrics, PartitionMap, PartitionInfo, PartitionChange, ReplicationLag, ReplicationHealth, ReplicationResult } from '@topgunbuild/core';
 import { WebSocket } from 'ws';
 import { PoolConfig, Pool } from 'pg';
 import pino from 'pino';
+import { EventEmitter } from 'events';
 
-type ORMapValue<V> = {
-    type: 'OR';
-    records: ORMapRecord<V>[];
-};
-type ORMapTombstones = {
-    type: 'OR_TOMBSTONES';
-    tags: string[];
-};
-type StorageValue<V> = LWWRecord<V> | ORMapValue<V> | ORMapTombstones;
 /**
- * Server Persistence Interface (MapStore).
- * Aligned with specifications/06_SERVER_INTEGRATIONS.md
+ * TaskletScheduler — Cooperative multitasking for long-running operations.
  *
- * Note: We include mapName in all methods because a single storage adapter
- * instance typically handles multiple maps in the system (e.g. single DB connection).
+ * Inspired by Hazelcast's Tasklet pattern, this scheduler allows long operations
+ * to yield control back to the event loop periodically, preventing event loop
+ * blocking and maintaining responsiveness.
+ *
+ * Key concepts:
+ * - Tasklet: A unit of work that can be paused and resumed
+ * - Time budget: Maximum time a tasklet can run before yielding
+ * - Cooperative scheduling: Tasklets voluntarily yield when time budget is exhausted
  */
-interface IServerStorage {
+/**
+ * Progress state returned by a tasklet after each execution step.
+ */
+type ProgressState = 'DONE' | 'MADE_PROGRESS' | 'NO_PROGRESS';
+/**
+ * Interface for a tasklet that can be scheduled.
+ */
+interface Tasklet<T = void> {
+    /** Unique name for logging/metrics */
+    readonly name: string;
     /**
-     * Initialize the storage connection.
+     * Execute one chunk of work.
+     * Should check time budget and return appropriate state.
      */
-    initialize(): Promise<void>;
+    call(): ProgressState;
     /**
-     * Close the storage connection.
+     * Get the result after tasklet is DONE.
+     * Only valid when call() returns 'DONE'.
      */
-    close(): Promise<void>;
+    getResult(): T;
     /**
-     * Loads the value of a given key.
-     * Called when a client requests a key that is not in the Server RAM (if using partial loading),
-     * or during sync.
+     * Called when tasklet is cancelled before completion.
      */
-    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
+    onCancel?(): void;
+}
+/**
+ * Configuration for TaskletScheduler.
+ */
+interface TaskletSchedulerConfig {
+    /** Default time budget per tasklet execution in ms (default: 5) */
+    defaultTimeBudgetMs?: number;
+    /** Maximum concurrent tasklets (default: 10) */
+    maxConcurrent?: number;
+    /** Interval between scheduler ticks in ms (default: 1) */
+    tickIntervalMs?: number;
+    /** Enable metrics collection (default: true) */
+    metricsEnabled?: boolean;
+}
+/**
+ * Metrics for monitoring scheduler performance.
+ */
+interface TaskletSchedulerStats {
+    /** Total tasklets scheduled */
+    totalScheduled: number;
+    /** Tasklets currently running */
+    activeTasklets: number;
+    /** Tasklets completed successfully */
+    completedTasklets: number;
+    /** Tasklets cancelled */
+    cancelledTasklets: number;
+    /** Total iterations across all tasklets */
+    totalIterations: number;
+    /** Average iterations per tasklet */
+    avgIterationsPerTasklet: number;
+    /** Tasklets that completed in a single iteration */
+    singleIterationCompletions: number;
+    /** Time spent in tasklet execution (ms) */
+    totalExecutionTimeMs: number;
+}
+/**
+ * TaskletScheduler manages cooperative multitasking for long-running operations.
+ *
+ * Usage:
+ * ```typescript
+ * const scheduler = new TaskletScheduler();
+ *
+ * // Schedule a tasklet
+ * const result = await scheduler.schedule(new QueryExecutionTasklet(records, query));
+ *
+ * // Cancel all running tasklets
+ * scheduler.cancelAll();
+ *
+ * // Shutdown scheduler
+ * scheduler.shutdown();
+ * ```
+ */
+declare class TaskletScheduler {
+    private readonly config;
+    private readonly activeTasklets;
+    private tickTimer;
+    private isRunning;
+    private isShuttingDown;
+    private totalScheduled;
+    private completedTasklets;
+    private cancelledTasklets;
+    private totalIterations;
+    private singleIterationCompletions;
+    private totalExecutionTimeMs;
+    constructor(config?: TaskletSchedulerConfig);
     /**
-     * Loads multiple keys.
-     * Optimization for batch requests.
+     * Schedule a tasklet for execution.
+     * Returns a promise that resolves when the tasklet completes.
      */
-    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
+    schedule<T>(tasklet: Tasklet<T>): Promise<T>;
     /**
-     * Loads all keys from the store for a specific map.
-     * Used for pre-loading the cache on startup or understanding dataset size.
+     * Run a tasklet synchronously (blocking).
+     * Useful for small operations or when cooperative scheduling isn't needed.
      */
-    loadAllKeys(mapName: string): Promise<string[]>;
+    runSync<T>(tasklet: Tasklet<T>): T;
     /**
-     * Stores the key-value pair.
+     * Cancel a specific tasklet by name pattern.
+     * Returns the number of tasklets cancelled.
      */
-    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
+    cancel(namePattern: string | RegExp): number;
     /**
-     * Stores multiple entries.
-     * Used for efficient batch writes to the DB.
+     * Cancel all running tasklets.
      */
-    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
+    cancelAll(): number;
     /**
-     * Deletes the entry with the given key.
+     * Get scheduler statistics.
      */
-    delete(mapName: string, key: string): Promise<void>;
+    getStats(): TaskletSchedulerStats;
     /**
-     * Deletes multiple entries.
+     * Reset statistics.
      */
-    deleteAll(mapName: string, keys: string[]): Promise<void>;
+    resetStats(): void;
+    /**
+     * Shutdown the scheduler.
+     * Cancels all running tasklets and stops the tick timer.
+     */
+    shutdown(): void;
+    /**
+     * Check if scheduler is running.
+     */
+    get running(): boolean;
+    /**
+     * Get number of active tasklets.
+     */
+    get activeCount(): number;
+    private startScheduler;
+    private stopScheduler;
+    private scheduleTick;
+    private tick;
+    private completeTasklet;
+    private failTasklet;
+    private cancelTasklet;
 }
 
-interface ServerOp {
-    mapName: string;
-    key: string;
-    opType: 'PUT' | 'REMOVE' | 'OR_ADD' | 'OR_REMOVE';
-    record?: LWWRecord<any>;
-    orRecord?: ORMapRecord<any>;
-    orTag?: string;
-    id?: string;
+/**
+ * IteratorTasklet — Base class for tasklets that iterate over collections.
+ *
+ * Provides cooperative iteration with time-budgeted chunks.
+ * Subclasses implement processItem() to handle each item.
+ */
+
+/**
+ * Configuration for iterator tasklets.
+ */
+interface IteratorTaskletConfig {
+    /** Time budget per iteration in ms (default: 5) */
+    timeBudgetMs?: number;
+    /** Maximum items to process per iteration (default: 1000) */
+    maxItemsPerIteration?: number;
 }
-interface ConnectionContext {
-    clientId: string;
-    socket?: WebSocket;
-    principal?: Principal;
-    isAuthenticated: boolean;
+/**
+ * Abstract base class for iterator-based tasklets.
+ *
+ * Usage:
+ * ```typescript
+ * class MyTasklet extends IteratorTasklet<[string, Record], Record[]> {
+ *     constructor(map: Map<string, Record>) {
+ *         super('my-tasklet', map.entries());
+ *     }
+ *
+ *     protected processItem([key, record]: [string, Record]): void {
+ *         if (matchesCriteria(record)) {
+ *             this.results.push(record);
+ *         }
+ *     }
+ *
+ *     getResult(): Record[] {
+ *         return this.results;
+ *     }
+ * }
+ * ```
+ */
+declare abstract class IteratorTasklet<TItem, TResult> implements Tasklet<TResult> {
+    abstract readonly name: string;
+    protected readonly config: Required<IteratorTaskletConfig>;
+    protected readonly iterator: Iterator<TItem>;
+    protected itemsProcessed: number;
+    protected isDone: boolean;
+    constructor(iterator: Iterator<TItem>, config?: IteratorTaskletConfig);
+    /**
+     * Process a single item from the iterator.
+     * Override this in subclasses.
+     */
+    protected abstract processItem(item: TItem): void;
+    /**
+     * Get the final result after iteration completes.
+     */
+    abstract getResult(): TResult;
+    /**
+     * Execute one chunk of iteration.
+     */
+    call(): ProgressState;
+    /**
+     * Called when tasklet is cancelled.
+     */
+    onCancel(): void;
+    /**
+     * Get number of items processed so far.
+     */
+    get processed(): number;
 }
-interface OpContext extends ConnectionContext {
-    fromCluster: boolean;
-    originalSenderId?: string;
+/**
+ * Simple iterator tasklet that collects items matching a predicate.
+ */
+declare class FilterTasklet<T> extends IteratorTasklet<T, T[]> {
+    readonly name: string;
+    protected readonly results: T[];
+    private readonly predicate;
+    constructor(name: string, iterator: Iterator<T>, predicate: (item: T) => boolean, config?: IteratorTaskletConfig);
+    protected processItem(item: T): void;
+    getResult(): T[];
 }
-interface IInterceptor {
+/**
+ * Iterator tasklet that transforms items.
+ */
+declare class MapTasklet<TIn, TOut> extends IteratorTasklet<TIn, TOut[]> {
+    readonly name: string;
+    protected readonly results: TOut[];
+    private readonly mapper;
+    constructor(name: string, iterator: Iterator<TIn>, mapper: (item: TIn) => TOut, config?: IteratorTaskletConfig);
+    protected processItem(item: TIn): void;
+    getResult(): TOut[];
+}
+/**
+ * Iterator tasklet that applies a function to each item (side effects).
+ */
+declare class ForEachTasklet<T> extends IteratorTasklet<T, number> {
+    readonly name: string;
+    private readonly action;
+    constructor(name: string, iterator: Iterator<T>, action: (item: T) => void, config?: IteratorTaskletConfig);
+    protected processItem(item: T): void;
+    getResult(): number;
+}
+/**
+ * Iterator tasklet that reduces items to a single value.
+ */
+declare class ReduceTasklet<T, TAccum> extends IteratorTasklet<T, TAccum> {
+    readonly name: string;
+    private accumulator;
+    private readonly reducer;
+    constructor(name: string, iterator: Iterator<T>, initialValue: TAccum, reducer: (acc: TAccum, item: T) => TAccum, config?: IteratorTaskletConfig);
+    protected processItem(item: T): void;
+    getResult(): TAccum;
+}
+
+/**
+ * BufferPool - High-performance buffer reuse for serialization operations.
+ * Phase 2.03: Memory Pooling
+ *
+ * Reduces GC pressure by reusing pre-allocated Uint8Array buffers instead of
+ * creating new ones for each serialization operation.
+ *
+ * Reference: Hazelcast MemoryAllocator pattern
+ */
+interface BufferPoolConfig {
     /**
-     * Name of the interceptor for logging and debugging.
+     * Size of each buffer chunk in bytes.
+     * Larger chunks = fewer allocations, but more memory waste.
+     * Default: 64KB (65536)
      */
-    name: string;
+    chunkSize?: number;
     /**
-     * Called when a new client connects.
-     * Throwing an error here will reject the connection.
+     * Initial number of buffers to pre-allocate.
+     * Default: 16
      */
-    onConnection?(context: ConnectionContext): Promise<void>;
+    initialSize?: number;
     /**
-     * Called when a client disconnects.
+     * Maximum buffers to keep in pool.
+     * Excess buffers are released to GC.
+     * Default: 256
      */
-    onDisconnect?(context: ConnectionContext): Promise<void>;
+    maxSize?: number;
     /**
-     * Called before an operation is applied to the local map/storage.
-     * Return the (possibly modified) op.
-     * Return null to silently drop the operation (no error sent to client, no persistence).
-     * Throwing an error will reject the operation and notify the client.
+     * Auto-shrink pool when idle buffers exceed this ratio.
+     * Default: true
      */
-    onBeforeOp?(op: ServerOp, context: OpContext): Promise<ServerOp | null>;
+    autoShrink?: boolean;
     /**
-     * Called after an operation has been successfully applied and stored.
+     * Shrink threshold - shrink if (available / maxSize) > threshold.
+     * Default: 0.75 (75% idle)
      */
-    onAfterOp?(op: ServerOp, context: OpContext): Promise<void>;
+    shrinkThreshold?: number;
+    /**
+     * Enable metrics collection.
+     * Default: true
+     */
+    metricsEnabled?: boolean;
 }
-
-interface TLSConfig {
+interface BufferPoolStats {
+    /** Buffers currently available in pool */
+    available: number;
+    /** Buffers currently in use */
+    inUse: number;
+    /** Total buffers ever created */
+    created: number;
+    /** Total times a buffer was reused */
+    reused: number;
+    /** Reuse ratio: reused / (created + reused) */
+    reuseRatio: number;
+    /** Total bytes in pool (available buffers only) */
+    poolSizeBytes: number;
+    /** Peak concurrent usage */
+    peakUsage: number;
+    /** Times pool was exhausted (had to create new buffer) */
+    misses: number;
+    /** Chunk size configuration */
+    chunkSize: number;
+    /** Max pool size configuration */
+    maxSize: number;
+}
+/**
+ * High-performance buffer pool for serialization operations.
+ *
+ * Usage:
+ * ```typescript
+ * const pool = new BufferPool({ chunkSize: 64 * 1024 });
+ * const buffer = pool.acquire();
+ * // ... use buffer for serialization ...
+ * pool.release(buffer);
+ * ```
+ *
+ * Thread Safety:
+ * This pool is designed for single-threaded use (Node.js main thread).
+ * For worker threads, create separate pools or copy buffers.
+ */
+declare class BufferPool {
+    private readonly pool;
+    private readonly chunkSize;
+    private readonly maxSize;
+    private readonly autoShrink;
+    private readonly shrinkThreshold;
+    private readonly metricsEnabled;
+    private inUseCount;
+    private createdCount;
+    private reusedCount;
+    private peakUsage;
+    private missCount;
+    private readonly pooledBuffers;
+    private readonly releasedBuffers;
+    constructor(config?: BufferPoolConfig);
     /**
-     * Enable TLS for client-facing server (HTTPS + WSS)
-     * @default false
+     * Acquire a buffer from the pool.
+     * Creates new buffer if pool is empty.
+     *
+     * @returns A Uint8Array of exactly chunkSize bytes
      */
-    enabled: boolean;
+    acquire(): Uint8Array;
     /**
-     * Path to certificate file (PEM format)
-     * Supports chain certificates
+     * Release a buffer back to the pool.
+     * Buffer contents are cleared before returning to pool.
+     *
+     * @param buffer - The buffer to release
      */
-    certPath: string;
+    release(buffer: Uint8Array): void;
     /**
-     * Path to private key file (PEM format)
+     * Acquire a buffer of specific minimum size.
+     * May return a buffer larger than requested.
+     * For sizes > chunkSize, creates new buffer (not pooled).
+     *
+     * @param minSize - Minimum required size in bytes
+     * @returns A Uint8Array of at least minSize bytes
      */
-    keyPath: string;
+    acquireSize(minSize: number): Uint8Array;
     /**
-     * Path to CA certificate for verifying client certificates
-     * Required for mTLS
-     * @optional
+     * Get current pool statistics.
      */
-    caCertPath?: string;
+    getStats(): BufferPoolStats;
     /**
-     * Minimum TLS version
-     * @default 'TLSv1.2'
+     * Clear all buffers from pool.
+     * Use for shutdown or memory pressure situations.
      */
-    minVersion?: 'TLSv1.2' | 'TLSv1.3';
+    clear(): void;
     /**
-     * List of allowed cipher suites
-     * @optional - use Node.js defaults if not specified
+     * Manually trigger shrink operation.
+     * Removes excess idle buffers to reduce memory footprint.
      */
-    ciphers?: string;
+    shrink(): void;
     /**
-     * Passphrase for encrypted private key
-     * @optional
+     * Pre-warm pool by creating buffers up to specified count.
+     * Called automatically in constructor.
+     *
+     * @param count - Number of buffers to create
      */
-    passphrase?: string;
-}
-interface ClusterTLSConfig extends TLSConfig {
+    prewarm(count?: number): void;
     /**
-     * Require client certificate (mTLS)
-     * @default false
+     * Reset all metrics to zero.
+     * Useful for testing or periodic metric collection.
      */
-    requireClientCert?: boolean;
+    resetStats(): void;
     /**
-     * Verify peer certificates
-     * Can be disabled in development for self-signed certs
-     * @default true
+     * Get configuration values.
      */
-    rejectUnauthorized?: boolean;
+    getConfig(): Readonly<Required<BufferPoolConfig>>;
+    private createBuffer;
+    private shouldShrink;
 }
+/**
+ * Get or create the global buffer pool.
+ * Uses default configuration (64KB chunks, 256 max).
+ */
+declare function getGlobalBufferPool(): BufferPool;
+/**
+ * Replace the global buffer pool with a custom instance.
+ * Useful for testing or custom configurations.
+ *
+ * @param pool - New pool instance, or null to reset to default
+ */
+declare function setGlobalBufferPool(pool: BufferPool | null): void;
 
-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;
-}
-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 lockManager;
-    private topicManager;
-    private securityManager;
-    private systemManager;
-    private pendingClusterQueries;
-    private gcInterval?;
-    private heartbeatCheckInterval?;
-    private gcReports;
-    private mapLoadingPromises;
-    private _actualPort;
-    private _actualClusterPort;
-    private _readyPromise;
-    private _readyResolve;
-    constructor(config: ServerCoordinatorConfig);
-    /** Wait for server to be fully ready (ports assigned) */
-    ready(): Promise<void>;
-    /** Get the actual port the server is listening on */
-    get port(): number;
-    /** Get the actual cluster port */
-    get clusterPort(): number;
-    shutdown(): Promise<void>;
-    private handleConnection;
-    private handleMessage;
-    private updateClientHlc;
-    private broadcast;
-    private setupClusterListeners;
-    private executeLocalQuery;
-    private finalizeClusterQuery;
-    private handleLockGranted;
-    private processLocalOp;
-    private handleClusterEvent;
-    getMap(name: string, typeHint?: 'LWW' | 'OR'): LWWMap<string, any> | ORMap<string, any>;
+/**
+ * ObjectPool - Generic object pooling for reducing GC pressure.
+ * Phase 2.04: Object Pool Implementation
+ *
+ * Reuses objects instead of creating new ones in hot paths.
+ * Works with any plain data structure type.
+ */
+interface ObjectPoolConfig<T> {
     /**
-     * Returns map after ensuring it's fully loaded from storage.
-     * Use this for queries to avoid returning empty results during initial load.
+     * Factory function to create new objects.
+     * Called when pool is empty.
      */
-    getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
-    private loadMapFromStorage;
-    private startGarbageCollection;
+    factory: () => T;
     /**
-     * Starts the periodic check for dead clients (those that haven't sent PING).
+     * Reset function to clean object before reuse.
+     * Should clear all fields to initial state.
      */
-    private startHeartbeatCheck;
+    reset: (obj: T) => void;
     /**
-     * Handles incoming PING message from client.
-     * Responds with PONG immediately.
+     * Optional validator to check if object is reusable.
+     * Return false to discard corrupted objects.
      */
-    private handlePing;
+    validate?: (obj: T) => boolean;
     /**
-     * Checks if a client is still alive based on heartbeat.
+     * Initial pool size.
+     * Default: 32
      */
-    isClientAlive(clientId: string): boolean;
+    initialSize?: number;
     /**
-     * Returns how long the client has been idle (no PING received).
+     * Maximum pool size.
+     * Excess objects are discarded.
+     * Default: 512
      */
-    getClientIdleTime(clientId: string): number;
+    maxSize?: number;
     /**
-     * Evicts clients that haven't sent a PING within the timeout period.
+     * Name for debugging/metrics.
      */
-    private evictDeadClients;
-    private reportLocalHlc;
-    private handleGcReport;
-    private performGarbageCollection;
-    private buildTLSOptions;
+    name?: string;
+}
+interface ObjectPoolStats {
+    /** Pool name */
+    name: string;
+    /** Objects currently available */
+    available: number;
+    /** Objects currently in use */
+    inUse: number;
+    /** Total objects created */
+    created: number;
+    /** Total times an object was reused */
+    reused: number;
+    /** Reuse ratio */
+    reuseRatio: number;
+    /** Objects discarded (failed validation) */
+    discarded: number;
+    /** Max pool size */
+    maxSize: number;
+    /** Peak concurrent usage */
+    peakUsage: number;
+}
+/**
+ * Generic object pool for reusing plain data structures.
+ *
+ * Usage:
+ * ```typescript
+ * const pool = new ObjectPool({
+ *   factory: () => ({ name: '', value: 0 }),
+ *   reset: (obj) => { obj.name = ''; obj.value = 0; },
+ * });
+ *
+ * const obj = pool.acquire();
+ * obj.name = 'test';
+ * obj.value = 42;
+ * // ... use obj ...
+ * pool.release(obj);
+ * ```
+ *
+ * Important:
+ * - Only use for plain data objects
+ * - Don't pool objects with closures or event listeners
+ * - Don't keep references after release
+ */
+declare class ObjectPool<T> {
+    private readonly pool;
+    private readonly factory;
+    private readonly resetFn;
+    private readonly validate?;
+    private readonly maxSize;
+    private readonly name;
+    private inUseCount;
+    private createdCount;
+    private reusedCount;
+    private discardedCount;
+    private peakUsage;
+    private readonly releasedObjects;
+    constructor(config: ObjectPoolConfig<T>);
+    /**
+     * Acquire an object from the pool.
+     * Creates new object via factory if pool is empty.
+     *
+     * @returns A clean, ready-to-use object
+     */
+    acquire(): T;
+    /**
+     * Release an object back to the pool.
+     * Object is reset before returning to pool.
+     *
+     * @param obj - The object to release
+     */
+    release(obj: T): void;
+    /**
+     * Acquire multiple objects at once.
+     * More efficient than multiple acquire() calls.
+     *
+     * @param count - Number of objects to acquire
+     * @returns Array of objects
+     */
+    acquireBatch(count: number): T[];
+    /**
+     * Release multiple objects at once.
+     *
+     * @param objects - Objects to release
+     */
+    releaseBatch(objects: T[]): void;
+    /**
+     * Get pool statistics.
+     */
+    getStats(): ObjectPoolStats;
+    /**
+     * Clear all objects from pool.
+     */
+    clear(): void;
+    /**
+     * Pre-warm pool with objects.
+     *
+     * @param count - Number of objects to create
+     */
+    prewarm(count?: number): void;
+    /**
+     * Reset statistics.
+     */
+    resetStats(): void;
+    private createObject;
 }
 
-interface PostgresAdapterOptions {
-    tableName?: string;
+/**
+ * MessagePool - Pre-configured ObjectPool for message objects.
+ * Phase 2.04: Object Pool Implementation
+ *
+ * Reduces GC pressure when processing incoming messages.
+ */
+
+/**
+ * Pooled message structure matching common message format.
+ */
+interface PooledMessage {
+    type: string;
+    payload: unknown;
+    timestamp: number | null;
+    clientId: string | null;
+    mapName: string | null;
+    key: string | null;
 }
-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;
+/**
+ * Create a new MessagePool instance.
+ *
+ * @param config - Pool configuration
+ * @returns Configured ObjectPool for messages
+ */
+declare function createMessagePool(config?: {
+    maxSize?: number;
+    initialSize?: number;
+}): ObjectPool<PooledMessage>;
+/**
+ * Get or create the global message pool.
+ */
+declare function getGlobalMessagePool(): ObjectPool<PooledMessage>;
+/**
+ * Replace the global message pool (for testing).
+ */
+declare function setGlobalMessagePool(pool: ObjectPool<PooledMessage> | null): void;
+
+/**
+ * TimestampPool - Pre-configured ObjectPool for HLC timestamp objects.
+ * Phase 2.04: Object Pool Implementation
+ *
+ * Reduces GC pressure for frequent timestamp operations.
+ * Timestamps are created on every operation (set, merge, etc.).
+ */
+
+/**
+ * Pooled timestamp structure matching HLC format.
+ */
+interface PooledTimestamp {
+    millis: number;
+    counter: number;
+    nodeId: string;
 }
+/**
+ * Create a new TimestampPool instance.
+ *
+ * @param config - Pool configuration
+ * @returns Configured ObjectPool for timestamps
+ */
+declare function createTimestampPool(config?: {
+    maxSize?: number;
+    initialSize?: number;
+}): ObjectPool<PooledTimestamp>;
+/**
+ * Get or create the global timestamp pool.
+ */
+declare function getGlobalTimestampPool(): ObjectPool<PooledTimestamp>;
+/**
+ * Replace the global timestamp pool (for testing).
+ */
+declare function setGlobalTimestampPool(pool: ObjectPool<PooledTimestamp> | null): void;
 
 /**
- * In-memory implementation of IServerStorage.
- * Useful for development, testing, and demos without requiring a database.
+ * RecordPool - Pre-configured ObjectPool for LWW/OR record objects.
+ * Phase 2.04: Object Pool Implementation
  *
- * Note: Data is lost when the server restarts.
+ * Reduces GC pressure when processing CRDT operations.
  */
-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>;
+
+/**
+ * Pooled record structure matching LWWRecord format.
+ */
+interface PooledRecord<T = unknown> {
+    value: T | null;
+    timestamp: PooledTimestamp | null;
+    ttlMs?: number;
+}
+/**
+ * Pooled event payload structure.
+ */
+interface PooledEventPayload {
+    mapName: string;
+    key: string;
+    eventType: string;
+    record: PooledRecord | null;
+    orRecord: PooledRecord | null;
+    orTag: string | null;
 }
+/**
+ * Create a new RecordPool instance.
+ *
+ * @param config - Pool configuration
+ * @returns Configured ObjectPool for records
+ */
+declare function createRecordPool<T = unknown>(config?: {
+    maxSize?: number;
+    initialSize?: number;
+}): ObjectPool<PooledRecord<T>>;
+/**
+ * Create a new EventPayloadPool instance.
+ *
+ * @param config - Pool configuration
+ * @returns Configured ObjectPool for event payloads
+ */
+declare function createEventPayloadPool(config?: {
+    maxSize?: number;
+    initialSize?: number;
+}): ObjectPool<PooledEventPayload>;
+/**
+ * Get or create the global record pool.
+ */
+declare function getGlobalRecordPool(): ObjectPool<PooledRecord>;
+/**
+ * Replace the global record pool (for testing).
+ */
+declare function setGlobalRecordPool(pool: ObjectPool<PooledRecord> | null): void;
+/**
+ * Get or create the global event payload pool.
+ */
+declare function getGlobalEventPayloadPool(): ObjectPool<PooledEventPayload>;
+/**
+ * Replace the global event payload pool (for testing).
+ */
+declare function setGlobalEventPayloadPool(pool: ObjectPool<PooledEventPayload> | null): 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;
+/**
+ * WorkerPool Types
+ * Phase 1.02: Worker Threads Implementation
+ */
+/**
+ * Configuration for WorkerPool
+ */
+interface WorkerPoolConfig {
+    /** Minimum number of workers (default: 2) */
+    minWorkers?: number;
+    /** Maximum number of workers (default: os.cpus().length - 1) */
+    maxWorkers?: number;
+    /** Task execution timeout in ms (default: 5000) */
+    taskTimeout?: number;
+    /** Worker idle timeout before termination in ms (default: 30000) */
+    idleTimeout?: number;
+    /** Enable worker restart on crash (default: true) */
+    autoRestart?: boolean;
+    /** Custom worker script path (for testing or custom workers) */
+    workerScript?: string;
+}
+/**
+ * Task types supported by workers
+ */
+type WorkerTaskType = 'merkle-hash' | 'merkle-hash-ormap' | 'merkle-diff' | 'merkle-rebuild' | 'merkle-rebuild-ormap' | 'lww-merge' | 'ormap-merge' | 'serialize' | 'deserialize';
+/**
+ * Task priority levels
+ */
+type TaskPriority = 'high' | 'normal' | 'low';
+/**
+ * Task to be executed by a worker
+ */
+interface WorkerTask<TPayload = unknown, TResult = unknown> {
+    /** Unique task ID */
+    id: string;
+    /** Task type for routing to correct handler */
+    type: WorkerTaskType;
+    /** Task payload (must be serializable) */
+    payload: TPayload;
+    /** Priority (default: 'normal') */
+    priority?: TaskPriority;
+    /** Internal: Expected result type marker */
+    _resultType?: TResult;
+}
+/**
+ * Pool statistics
+ */
+interface WorkerPoolStats {
+    /** Number of workers currently executing tasks */
+    activeWorkers: number;
+    /** Number of workers waiting for tasks */
+    idleWorkers: number;
+    /** Number of tasks in queue */
+    pendingTasks: number;
+    /** Total tasks completed successfully */
+    completedTasks: number;
+    /** Total tasks that failed */
+    failedTasks: number;
+    /** Average task execution time in ms */
+    avgTaskDuration: number;
 }
 
-declare const logger: pino.Logger<never, boolean>;
-type Logger = typeof logger;
+/**
+ * WorkerPool Implementation
+ * Phase 1.02: Worker Threads Implementation
+ *
+ * Manages a pool of worker threads for CPU-bound operations.
+ * Features:
+ * - Auto-scaling (minWorkers to maxWorkers)
+ * - Priority queue (high > normal > low)
+ * - Task timeouts
+ * - Worker crash recovery
+ * - Graceful shutdown
+ */
 
-declare class TimestampInterceptor implements IInterceptor {
-    name: string;
-    onBeforeOp(op: ServerOp, context: OpContext): Promise<ServerOp>;
+declare class WorkerPool {
+    private readonly config;
+    private readonly workers;
+    private readonly taskQueue;
+    private readonly pendingTasks;
+    private workerIdCounter;
+    private isShuttingDown;
+    private isShutdown;
+    private completedTaskCount;
+    private failedTaskCount;
+    private totalTaskDuration;
+    private idleCheckInterval?;
+    constructor(config?: WorkerPoolConfig);
+    /**
+     * Resolve the worker script path based on environment
+     */
+    private resolveWorkerScript;
+    /**
+     * Submit a task to the pool
+     */
+    submit<TPayload, TResult>(task: WorkerTask<TPayload, TResult>): Promise<TResult>;
+    /**
+     * Get current pool statistics
+     */
+    getStats(): WorkerPoolStats;
+    /**
+     * Gracefully shutdown all workers
+     */
+    shutdown(timeout?: number): Promise<void>;
+    /**
+     * Check if pool is accepting tasks
+     */
+    isRunning(): boolean;
+    private initializeWorkers;
+    private createWorker;
+    private findIdleWorker;
+    private assignTaskToWorker;
+    private enqueueTask;
+    private tryScaleUp;
+    private handleWorkerResponse;
+    private handleTaskTimeout;
+    private handleWorkerError;
+    private handleWorkerExit;
+    private startIdleCheck;
+    private checkIdleWorkers;
 }
 
-interface RateLimitConfig {
-    windowMs: number;
-    maxOps: number;
+/**
+ * Merkle Worker Types
+ * Phase 1.03: MerkleWorker Implementation
+ */
+
+/**
+ * Entry for Merkle hash computation (LWWMap style)
+ */
+interface MerkleHashEntry {
+    key: string;
+    timestamp: Timestamp;
 }
-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>;
+/**
+ * Entry for ORMap Merkle hash computation
+ */
+interface ORMapMerkleHashEntry {
+    key: string;
+    records: Array<{
+        tag: string;
+        timestamp: Timestamp;
+    }>;
+}
+/**
+ * Payload for merkle-hash task (LWWMap)
+ */
+interface MerkleHashPayload {
+    entries: MerkleHashEntry[];
+    depth?: number;
+}
+/**
+ * Result of merkle-hash task
+ */
+interface MerkleHashResult {
+    /** Map of key -> hash for each entry */
+    hashes: Array<[string, number]>;
+    /** Root hash of all entries */
+    rootHash: number;
+    /** Bucket structure: path -> { hash, keys } */
+    buckets: Array<[string, {
+        hash: number;
+        keys: string[];
+    }]>;
+}
+/**
+ * Payload for merkle-hash-ormap task
+ */
+interface ORMapMerkleHashPayload {
+    entries: ORMapMerkleHashEntry[];
+    depth?: number;
+}
+/**
+ * Result of merkle-hash-ormap task
+ */
+interface ORMapMerkleHashResult {
+    /** Map of key -> hash for each entry */
+    hashes: Array<[string, number]>;
+    /** Root hash of all entries */
+    rootHash: number;
+    /** Bucket structure: path -> { hash, keys } */
+    buckets: Array<[string, {
+        hash: number;
+        keys: string[];
+    }]>;
+}
+/**
+ * Bucket info for diff comparison
+ */
+interface BucketInfo {
+    hash: number;
+    keys: string[];
+}
+/**
+ * Payload for merkle-diff task
+ */
+interface MerkleDiffPayload {
+    /** Local buckets: path -> bucket info */
+    localBuckets: Array<[string, BucketInfo]>;
+    /** Remote buckets: path -> bucket info */
+    remoteBuckets: Array<[string, BucketInfo]>;
+}
+/**
+ * Result of merkle-diff task
+ */
+interface MerkleDiffResult {
+    /** Keys that exist on remote but not locally */
+    missingLocal: string[];
+    /** Keys that exist locally but not on remote */
+    missingRemote: string[];
+    /** Paths where buckets differ (need deeper comparison) */
+    differingPaths: string[];
+}
+/**
+ * Payload for merkle-rebuild task (LWWMap)
+ */
+interface MerkleRebuildPayload {
+    records: Array<{
+        key: string;
+        timestamp: Timestamp;
+    }>;
+    depth?: number;
+}
+/**
+ * Payload for merkle-rebuild-ormap task
+ */
+interface ORMapMerkleRebuildPayload {
+    records: Array<{
+        key: string;
+        tags: Array<{
+            tag: string;
+            timestamp: Timestamp;
+        }>;
+    }>;
+    depth?: number;
+}
+/**
+ * Result of merkle-rebuild task
+ */
+interface MerkleRebuildResult {
+    /** Root hash of rebuilt tree */
+    rootHash: number;
+    /** All buckets in the tree */
+    buckets: Array<[string, {
+        hash: number;
+        keys: string[];
+    }]>;
+}
+
+/**
+ * MerkleWorker - High-level API for Merkle tree operations in worker threads
+ * Phase 1.03: MerkleWorker Implementation
+ *
+ * Provides a clean interface for CPU-intensive Merkle tree operations.
+ * Delegates actual work to worker threads via WorkerPool.
+ */
+
+/**
+ * MerkleWorker provides methods for Merkle tree operations.
+ * Automatically decides whether to use worker threads based on workload size.
+ */
+declare class MerkleWorker {
+    private readonly pool;
+    private readonly workerScript;
+    constructor(pool: WorkerPool);
+    private resolveMerkleWorkerScript;
+    /**
+     * Compute hashes for a batch of LWWMap entries.
+     * Uses worker thread if entries count exceeds threshold.
+     */
+    computeHashes(payload: MerkleHashPayload): Promise<MerkleHashResult>;
+    /**
+     * Compute hashes for a batch of ORMap entries.
+     * Uses worker thread if entries count exceeds threshold.
+     */
+    computeORMapHashes(payload: ORMapMerkleHashPayload): Promise<ORMapMerkleHashResult>;
+    /**
+     * Find differences between local and remote Merkle trees.
+     */
+    diff(payload: MerkleDiffPayload): Promise<MerkleDiffResult>;
+    /**
+     * Rebuild Merkle tree from LWWMap records.
+     * Always uses worker thread as this is typically a heavy operation.
+     */
+    rebuild(payload: MerkleRebuildPayload): Promise<MerkleRebuildResult>;
+    /**
+     * Rebuild Merkle tree from ORMap records.
+     */
+    rebuildORMap(payload: ORMapMerkleRebuildPayload): Promise<MerkleRebuildResult>;
+    private computeHashesInline;
+    private computeORMapHashesInline;
+    private diffInline;
+    private rebuildInline;
+    private rebuildORMapInline;
+    private hashString;
+    private buildTree;
+}
+
+/**
+ * CRDT Worker Types
+ * Phase 1.04: CRDTMergeWorker Implementation
+ */
+
+/**
+ * Single LWW record for merge
+ */
+interface LWWMergeRecord {
+    key: string;
+    value: unknown;
+    timestamp: Timestamp;
+    ttlMs?: number;
+}
+/**
+ * Existing state for a key (for merge comparison)
+ * Note: value is optional since we only need timestamp for comparison
+ */
+interface LWWExistingRecord {
+    key: string;
+    timestamp: Timestamp;
+    value?: unknown;
+    ttlMs?: number;
+}
+/**
+ * Payload for lww-merge task
+ */
+interface LWWMergePayload {
+    mapName: string;
+    /** Records to merge */
+    records: LWWMergeRecord[];
+    /** Current state of affected keys (for comparison) */
+    existingState: LWWExistingRecord[];
+}
+/**
+ * Result of lww-merge task
+ */
+interface LWWMergeResult {
+    /** Records that should be applied (newer than existing) */
+    toApply: Array<{
+        key: string;
+        value: unknown;
+        timestamp: Timestamp;
+        ttlMs?: number;
+    }>;
+    /** Number of records skipped (older timestamp) */
+    skipped: number;
+    /** Keys with concurrent updates (same timestamp, different nodeId) */
+    conflicts: string[];
+}
+/**
+ * Single ORMap item for merge
+ */
+interface ORMapMergeItem {
+    key: string;
+    value: unknown;
+    timestamp: Timestamp;
+    tag: string;
+    ttlMs?: number;
+}
+/**
+ * Single ORMap tombstone for merge
+ */
+interface ORMapMergeTombstone {
+    tag: string;
+    timestamp: Timestamp;
+}
+/**
+ * Payload for ormap-merge task
+ */
+interface ORMapMergePayload {
+    mapName: string;
+    /** Items to merge */
+    items: ORMapMergeItem[];
+    /** Tombstones to merge */
+    tombstones: ORMapMergeTombstone[];
+    /** Existing tags in the map (for tombstone check) */
+    existingTags: string[];
+    /** Existing tombstones (to avoid re-adding deleted items) */
+    existingTombstones: string[];
+}
+/**
+ * Result of ormap-merge task
+ */
+interface ORMapMergeResult {
+    /** Items that should be applied */
+    itemsToApply: Array<{
+        key: string;
+        value: unknown;
+        timestamp: Timestamp;
+        tag: string;
+        ttlMs?: number;
+    }>;
+    /** Tombstones that should be applied */
+    tombstonesToApply: string[];
+    /** Tags that need to be removed due to new tombstones */
+    tagsToRemove: string[];
+    /** Number of items skipped */
+    itemsSkipped: number;
+    /** Number of tombstones skipped */
+    tombstonesSkipped: number;
+}
+
+/**
+ * CRDTMergeWorker - High-level API for CRDT merge operations in worker threads
+ * Phase 1.04: CRDTMergeWorker Implementation
+ *
+ * Provides a clean interface for CPU-intensive CRDT merge operations.
+ * Delegates actual work to worker threads via WorkerPool for large batches.
+ */
+
+/**
+ * CRDTMergeWorker provides methods for CRDT merge operations.
+ * Automatically decides whether to use worker threads based on batch size.
+ */
+declare class CRDTMergeWorker {
+    private readonly pool;
+    /** Threshold for using worker (operations below this go to main thread) */
+    static readonly BATCH_THRESHOLD = 10;
+    constructor(pool: WorkerPool);
+    /**
+     * Decide if batch should go to worker
+     */
+    shouldUseWorker(batchSize: number): boolean;
+    /**
+     * Merge LWW records
+     * @param payload - Records to merge and existing state
+     * @returns Which records should be applied
+     */
+    mergeLWW(payload: LWWMergePayload): Promise<LWWMergeResult>;
+    /**
+     * Merge ORMap items and tombstones
+     * @param payload - Items, tombstones, and existing state
+     * @returns Which items/tombstones should be applied
+     */
+    mergeORMap(payload: ORMapMergePayload): Promise<ORMapMergeResult>;
+    private mergeLWWInline;
+    private mergeORMapInline;
+}
+
+/**
+ * SerializationWorker - High-level API for serialization operations in worker threads
+ * Phase 1.07: SerializationWorker Implementation
+ *
+ * Provides a clean interface for CPU-intensive serialization/deserialization.
+ * Delegates actual work to worker threads via WorkerPool for large payloads.
+ *
+ * Uses base64 encoding to transfer binary data through postMessage.
+ * This adds ~33% overhead but is necessary since Uint8Array cannot be
+ * directly transferred through structured clone algorithm for our use case.
+ */
+
+/**
+ * SerializationWorker provides methods for serialization operations.
+ * Automatically decides whether to use worker threads based on payload size.
+ */
+declare class SerializationWorker {
+    private readonly pool;
+    private readonly workerScript;
+    /** Threshold for using worker (items below this go to main thread) */
+    static readonly BATCH_THRESHOLD = 10;
+    /** Size threshold for using worker (bytes) */
+    static readonly SIZE_THRESHOLD: number;
+    constructor(pool: WorkerPool);
+    private resolveWorkerScript;
+    /**
+     * Decide if batch should go to worker based on count or size
+     */
+    shouldUseWorker(items: unknown[]): boolean;
+    /**
+     * Serialize multiple objects to MessagePack binary format.
+     * Uses worker thread for large batches.
+     *
+     * @param items - Objects to serialize
+     * @returns Array of Uint8Array containing serialized data
+     */
+    serializeBatch(items: unknown[]): Promise<Uint8Array[]>;
+    /**
+     * Deserialize multiple MessagePack binary payloads to objects.
+     * Uses worker thread for large batches.
+     *
+     * @param items - Binary data to deserialize
+     * @returns Array of deserialized objects
+     */
+    deserializeBatch<T = unknown>(items: Uint8Array[]): Promise<T[]>;
+    /**
+     * Serialize a single object (always inline, too small for worker)
+     */
+    serialize(data: unknown): Uint8Array;
+    /**
+     * Deserialize a single payload (always inline, too small for worker)
+     */
+    deserialize<T = unknown>(data: Uint8Array | ArrayBuffer): T;
+    private serializeBatchInline;
+    private deserializeBatchInline;
+}
+
+/**
+ * SharedMemoryManager - Zero-copy data transfer between main thread and workers
+ *
+ * Uses SharedArrayBuffer with Atomics for synchronization.
+ * Provides slot-based allocation for concurrent operations.
+ *
+ * Phase 3.04: SharedArrayBuffer Integration
+ */
+interface SharedMemoryConfig {
+    /**
+     * Size of shared buffer in bytes.
+     * Default: 16MB
+     */
+    bufferSize?: number;
+    /**
+     * Number of slots for concurrent operations.
+     * Each slot can hold one transfer.
+     * Default: 256
+     */
+    slotCount?: number;
+    /**
+     * Reserved bytes per slot for metadata (length, status, etc).
+     * Default: 16 (must be multiple of 8 for alignment)
+     */
+    metadataSize?: number;
+}
+interface SharedMemoryStats {
+    /** Total buffer size in bytes */
+    totalSize: number;
+    /** Number of slots */
+    slotCount: number;
+    /** Size of each slot in bytes */
+    slotSize: number;
+    /** Currently allocated slots */
+    allocatedSlots: number;
+    /** Available slots */
+    availableSlots: number;
+    /** Peak concurrent allocations */
+    peakUsage: number;
+    /** Total allocations since creation */
+    totalAllocations: number;
+    /** Total releases since creation */
+    totalReleases: number;
+}
+interface SharedSlot {
+    /** Slot index */
+    index: number;
+    /** View into shared buffer for this slot's data area */
+    dataView: Uint8Array;
+    /** Maximum data size (excluding metadata) */
+    maxDataSize: number;
+}
+/**
+ * Slot status values (stored in first 4 bytes of slot metadata)
+ */
+declare enum SlotStatus {
+    FREE = 0,// Slot is available
+    ALLOCATED = 1,// Slot is allocated, no data yet
+    DATA_READY = 2,// Data written, ready for reading
+    PROCESSING = 3,// Worker is processing
+    RESULT_READY = 4,// Worker has written result
+    ERROR = 255
+}
+/**
+ * Manages shared memory for zero-copy data transfer between threads.
+ *
+ * Usage:
+ * 1. Main thread allocates a slot
+ * 2. Main thread writes data to slot
+ * 3. Main thread sends slot index to worker via postMessage
+ * 4. Worker reads data from shared memory (zero-copy)
+ * 5. Worker writes result to slot
+ * 6. Main thread reads result (zero-copy)
+ * 7. Main thread releases slot
+ */
+declare class SharedMemoryManager {
+    private readonly buffer;
+    private readonly statusArray;
+    private readonly slotSize;
+    private readonly slotCount;
+    private readonly metadataSize;
+    private readonly freeSlots;
+    private allocatedCount;
+    private peakUsage;
+    private totalAllocations;
+    private totalReleases;
+    constructor(config?: SharedMemoryConfig);
+    /**
+     * Get offset in Int32Array for slot status.
+     * Status is at the beginning of each slot's metadata.
+     */
+    private getStatusOffset;
+    /**
+     * Get byte offset for slot length field.
+     */
+    private getLengthOffset;
+    /**
+     * Get byte offset for slot data (after metadata).
+     */
+    private getDataOffset;
+    /**
+     * Allocate a slot for data transfer.
+     * Returns null if no slots available.
+     */
+    allocate(): SharedSlot | null;
+    /**
+     * Release a slot back to the pool.
+     */
+    release(slot: SharedSlot): void;
+    /**
+     * Write data to a slot and signal it's ready.
+     * Returns false if data is too large.
+     */
+    writeData(slot: SharedSlot, data: Uint8Array): boolean;
+    /**
+     * Read data length from a slot.
+     */
+    getDataLength(slotIndex: number): number;
+    /**
+     * Get data view for a slot (for reading).
+     */
+    getDataView(slotIndex: number): Uint8Array;
+    /**
+     * Get slot status.
+     */
+    getStatus(slotIndex: number): SlotStatus;
+    /**
+     * Wait for a specific status with timeout.
+     * Returns the actual status (may differ if timeout occurred).
+     */
+    waitForStatus(slotIndex: number, expectedStatus: SlotStatus, timeoutMs?: number): SlotStatus;
+    /**
+     * Wait for result and read it.
+     * Returns null on timeout or error.
+     */
+    waitForResult(slot: SharedSlot, timeoutMs?: number): Uint8Array | null;
+    /**
+     * Get the SharedArrayBuffer for passing to workers.
+     */
+    getBuffer(): SharedArrayBuffer;
+    /**
+     * Get configuration needed by workers.
+     */
+    getWorkerConfig(): SharedWorkerConfig;
+    /**
+     * Get statistics.
+     */
+    getStats(): SharedMemoryStats;
+    /**
+     * Check if SharedArrayBuffer is available in current environment.
+     */
+    static isAvailable(): boolean;
+    /**
+     * Shutdown and release resources.
+     * Resets all slots to FREE status.
+     */
+    shutdown(): void;
+}
+/**
+ * Configuration passed to workers for shared memory access.
+ */
+interface SharedWorkerConfig {
+    sharedBuffer: SharedArrayBuffer;
+    slotSize: number;
+    slotCount: number;
+    metadataSize: number;
+}
+
+interface QueueMetrics {
+    enqueued: number;
+    dequeued: number;
+    rejected: number;
+    currentSize: number;
+}
+
+interface StripeMetrics {
+    stripe: number;
+    metrics: QueueMetrics;
+}
+
+type ORMapValue<V> = {
+    type: 'OR';
+    records: ORMapRecord<V>[];
+};
+type ORMapTombstones = {
+    type: 'OR_TOMBSTONES';
+    tags: string[];
+};
+type StorageValue<V> = LWWRecord<V> | ORMapValue<V> | ORMapTombstones;
+/**
+ * Server Persistence Interface (MapStore).
+ * Aligned with specifications/06_SERVER_INTEGRATIONS.md
+ *
+ * Note: We include mapName in all methods because a single storage adapter
+ * instance typically handles multiple maps in the system (e.g. single DB connection).
+ */
+interface IServerStorage {
+    /**
+     * Initialize the storage connection.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Close the storage connection.
+     */
+    close(): Promise<void>;
+    /**
+     * Loads the value of a given key.
+     * Called when a client requests a key that is not in the Server RAM (if using partial loading),
+     * or during sync.
+     */
+    load(mapName: string, key: string): Promise<StorageValue<any> | undefined>;
+    /**
+     * Loads multiple keys.
+     * Optimization for batch requests.
+     */
+    loadAll(mapName: string, keys: string[]): Promise<Map<string, StorageValue<any>>>;
+    /**
+     * Loads all keys from the store for a specific map.
+     * Used for pre-loading the cache on startup or understanding dataset size.
+     */
+    loadAllKeys(mapName: string): Promise<string[]>;
+    /**
+     * Stores the key-value pair.
+     */
+    store(mapName: string, key: string, record: StorageValue<any>): Promise<void>;
+    /**
+     * Stores multiple entries.
+     * Used for efficient batch writes to the DB.
+     */
+    storeAll(mapName: string, records: Map<string, StorageValue<any>>): Promise<void>;
+    /**
+     * Deletes the entry with the given key.
+     */
+    delete(mapName: string, key: string): Promise<void>;
+    /**
+     * Deletes multiple entries.
+     */
+    deleteAll(mapName: string, keys: string[]): Promise<void>;
+}
+
+interface ServerOp {
+    mapName: string;
+    key: string;
+    opType: 'PUT' | 'REMOVE' | 'OR_ADD' | 'OR_REMOVE';
+    record?: LWWRecord<any>;
+    orRecord?: ORMapRecord<any>;
+    orTag?: string;
+    id?: string;
+}
+interface ConnectionContext {
+    clientId: string;
+    socket?: WebSocket;
+    principal?: Principal;
+    isAuthenticated: boolean;
+}
+interface OpContext extends ConnectionContext {
+    fromCluster: boolean;
+    originalSenderId?: string;
+}
+interface IInterceptor {
+    /**
+     * Name of the interceptor for logging and debugging.
+     */
+    name: string;
+    /**
+     * Called when a new client connects.
+     * Throwing an error here will reject the connection.
+     */
+    onConnection?(context: ConnectionContext): Promise<void>;
+    /**
+     * Called when a client disconnects.
+     */
+    onDisconnect?(context: ConnectionContext): Promise<void>;
+    /**
+     * Called before an operation is applied to the local map/storage.
+     * Return the (possibly modified) op.
+     * Return null to silently drop the operation (no error sent to client, no persistence).
+     * Throwing an error will reject the operation and notify the client.
+     */
+    onBeforeOp?(op: ServerOp, context: OpContext): Promise<ServerOp | null>;
+    /**
+     * Called after an operation has been successfully applied and stored.
+     */
+    onAfterOp?(op: ServerOp, context: OpContext): Promise<void>;
+}
+
+interface TLSConfig {
+    /**
+     * Enable TLS for client-facing server (HTTPS + WSS)
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Path to certificate file (PEM format)
+     * Supports chain certificates
+     */
+    certPath: string;
+    /**
+     * Path to private key file (PEM format)
+     */
+    keyPath: string;
+    /**
+     * Path to CA certificate for verifying client certificates
+     * Required for mTLS
+     * @optional
+     */
+    caCertPath?: string;
+    /**
+     * Minimum TLS version
+     * @default 'TLSv1.2'
+     */
+    minVersion?: 'TLSv1.2' | 'TLSv1.3';
+    /**
+     * List of allowed cipher suites
+     * @optional - use Node.js defaults if not specified
+     */
+    ciphers?: string;
+    /**
+     * Passphrase for encrypted private key
+     * @optional
+     */
+    passphrase?: string;
+}
+interface ClusterTLSConfig extends TLSConfig {
+    /**
+     * Require client certificate (mTLS)
+     * @default false
+     */
+    requireClientCert?: boolean;
+    /**
+     * Verify peer certificates
+     * Can be disabled in development for self-signed certs
+     * @default true
+     */
+    rejectUnauthorized?: boolean;
+}
+
+interface CoalescingWriterOptions {
+    /**
+     * Maximum messages to batch before forcing flush.
+     * Default: 100
+     */
+    maxBatchSize: number;
+    /**
+     * Maximum time to wait before flushing (ms).
+     * Default: 5 (similar to Nagle's algorithm)
+     */
+    maxDelayMs: number;
+    /**
+     * Maximum batch size in bytes.
+     * Default: 65536 (64KB)
+     */
+    maxBatchBytes: number;
+    /**
+     * Optional BufferPool for batch buffer reuse.
+     * If not provided, uses the global buffer pool.
+     */
+    bufferPool?: BufferPool;
+}
+/**
+ * Extended metrics for CoalescingWriter performance analysis.
+ */
+interface CoalescingWriterMetrics {
+    /** Total messages sent */
+    messagesSent: number;
+    /** Total batches sent */
+    batchesSent: number;
+    /** Total bytes sent */
+    bytesSent: number;
+    /** Average messages per batch */
+    avgMessagesPerBatch: number;
+    /** Average bytes per batch */
+    avgBytesPerBatch: number;
+    /** Messages currently in queue */
+    pendingMessages: number;
+    /** Bytes currently pending */
+    pendingBytes: number;
+    /** Count of flushes triggered by size limits (batch full or bytes exceeded) */
+    immediateFlushes: number;
+    /** Count of flushes triggered by timer expiration */
+    timedFlushes: number;
+    /** Ratio of actual batch size to maxBatchSize (0-1, higher = better utilization) */
+    batchUtilization: number;
+    /** Ratio of immediate flushes to total flushes (high = batches filling up quickly) */
+    immediateFlushRatio: number;
+    /** Count of pooled buffer acquisitions (for monitoring buffer pool usage) */
+    pooledBuffersUsed: number;
+    /** Count of oversized (non-pooled) buffers that were allocated directly */
+    oversizedBuffers: number;
+}
+
+/**
+ * Preset configurations for CoalescingWriter.
+ * Based on Hazelcast OutboxImpl (batch size 2048) and real-world benchmarking.
+ *
+ * Trade-offs:
+ * - Larger batch size = higher throughput, higher latency
+ * - Longer delay = more messages per batch, higher latency
+ * - Larger maxBatchBytes = handles larger payloads, more memory
+ *
+ * NOTE: A/B testing (Dec 2024) showed maxDelayMs is the primary bottleneck:
+ * - 10ms delay: ~10K ops/sec, p50=11ms
+ * - 1ms delay:  ~18K ops/sec, p50=8ms  (+80% throughput)
+ * - 0ms (disabled): ~18K ops/sec, p50=2ms (best latency)
+ */
+declare const coalescingPresets: {
+    /**
+     * Low latency - optimized for minimal response time.
+     * Best for: gaming, real-time chat, interactive applications.
+     * Benchmark: p50=2ms, ~18K ops/sec
+     */
+    readonly lowLatency: {
+        readonly maxBatchSize: 100;
+        readonly maxDelayMs: 1;
+        readonly maxBatchBytes: 65536;
+    };
+    /**
+     * Conservative - good balance of latency and batching.
+     * Use for: general purpose with latency sensitivity.
+     */
+    readonly conservative: {
+        readonly maxBatchSize: 100;
+        readonly maxDelayMs: 2;
+        readonly maxBatchBytes: 65536;
+    };
+    /**
+     * Balanced - good for most workloads.
+     * Reasonable trade-off between throughput and latency.
+     * Use for: mixed read/write applications, general purpose.
+     */
+    readonly balanced: {
+        readonly maxBatchSize: 300;
+        readonly maxDelayMs: 2;
+        readonly maxBatchBytes: 131072;
+    };
+    /**
+     * High throughput - optimized for write-heavy workloads.
+     * Higher batching for better network utilization.
+     * Use for: data ingestion, logging, IoT data streams.
+     * Benchmark: p50=7ms, ~18K ops/sec
+     */
+    readonly highThroughput: {
+        readonly maxBatchSize: 500;
+        readonly maxDelayMs: 2;
+        readonly maxBatchBytes: 262144;
+    };
+    /**
+     * Aggressive - maximum batching for batch processing.
+     * Closest to Hazelcast's OutboxImpl (batch size 2048).
+     * Use for: batch imports, bulk operations, offline sync.
+     */
+    readonly aggressive: {
+        readonly maxBatchSize: 1000;
+        readonly maxDelayMs: 5;
+        readonly maxBatchBytes: 524288;
+    };
+};
+/**
+ * Available preset names for type safety.
+ */
+type CoalescingPreset = keyof typeof coalescingPresets;
+/**
+ * Get preset configuration by name.
+ * @param preset - Preset name
+ * @returns CoalescingWriterOptions
+ */
+declare function getCoalescingPreset(preset: CoalescingPreset): CoalescingWriterOptions;
+
+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>;
+}
+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 _actualPort;
+    private _actualClusterPort;
+    private _readyPromise;
+    private _readyResolve;
+    constructor(config: ServerCoordinatorConfig);
+    /** 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;
+    shutdown(): Promise<void>;
+    private handleConnection;
+    private handleMessage;
+    private updateClientHlc;
+    /**
+     * Broadcast partition map to all connected and authenticated clients.
+     * Called when partition topology changes (node join/leave/failover).
+     */
+    private broadcastPartitionMap;
+    private broadcast;
+    /**
+     * === 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.
+     */
+    private broadcastBatch;
+    /**
+     * Helper method to get role signature for a client (for caching key)
+     */
+    private getClientRoleSignature;
+    /**
+     * === BACKPRESSURE: Synchronous Broadcast ===
+     * Same as broadcastBatch but waits for all sends to complete.
+     * Used when backpressure forces sync processing to drain the pipeline.
+     */
+    private broadcastBatchSync;
+    private setupClusterListeners;
+    private executeLocalQuery;
+    private finalizeClusterQuery;
+    /**
+     * 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 applyOpToMap;
+    /**
+     * Broadcast event to cluster members (excluding self).
+     */
+    private broadcastToCluster;
+    /**
+     * Apply replicated operation from another node (callback for ReplicationPipeline)
+     * This is called when we receive a replicated operation as a backup node
+     */
+    private applyReplicatedOperation;
+    /**
+     * Build OpContext for interceptors.
+     */
+    private buildOpContext;
+    /**
+     * Run onBeforeOp interceptors. Returns modified op or null if dropped.
+     */
+    private runBeforeInterceptors;
+    /**
+     * Run onAfterOp interceptors (fire-and-forget).
+     */
+    private runAfterInterceptors;
+    private handleLockGranted;
+    private processLocalOp;
+    /**
+     * === 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 processBatchAsync;
+    /**
+     * === BACKPRESSURE: Synchronous Batch Processing ===
+     * Processes operations synchronously, waiting for broadcast completion.
+     * Used when backpressure forces sync to drain the pipeline.
+     */
+    private processBatchSync;
+    /**
+     * Forward operation to owner node and wait for completion.
+     * Used in sync processing mode.
+     */
+    private forwardOpAndWait;
+    /**
+     * Process a single operation for batch processing.
+     * Uses shared applyOpToMap but collects events instead of broadcasting immediately.
+     */
+    private processLocalOpForBatch;
+    private handleClusterEvent;
+    getMap(name: string, typeHint?: 'LWW' | 'OR'): LWWMap<string, any> | ORMap<string, any>;
+    /**
+     * Returns map after ensuring it's fully loaded from storage.
+     * Use this for queries to avoid returning empty results during initial load.
+     */
+    getMapAsync(name: string, typeHint?: 'LWW' | 'OR'): Promise<LWWMap<string, any> | ORMap<string, any>>;
+    private loadMapFromStorage;
+    private startGarbageCollection;
+    /**
+     * Starts the periodic check for dead clients (those that haven't sent PING).
+     */
+    private startHeartbeatCheck;
+    /**
+     * Handles incoming PING message from client.
+     * Responds with PONG immediately.
+     */
+    private handlePing;
+    /**
+     * Checks if a client is still alive based on heartbeat.
+     */
+    isClientAlive(clientId: string): boolean;
+    /**
+     * 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 getEffectiveWriteConcern;
+    /**
+     * Convert string WriteConcern value to enum.
+     */
+    private stringToWriteConcern;
+    /**
+     * Process batch with Write Concern tracking.
+     * Notifies WriteAckManager at each stage of processing.
+     */
+    private processBatchAsyncWithWriteConcern;
+    /**
+     * Synchronous batch processing with Write Concern.
+     */
+    private processBatchSyncWithWriteConcern;
+    /**
+     * Process a single operation with Write Concern level notifications.
+     */
+    private processLocalOpWithWriteConcern;
+    /**
+     * Persist operation synchronously (blocking).
+     * Used for PERSISTED Write Concern.
+     */
+    private persistOpSync;
+    /**
+     * Persist operation asynchronously (fire-and-forget).
+     * Used for non-PERSISTED Write Concern levels.
+     */
+    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>);
+    /**
+     * Check if a new connection should be accepted.
+     * @returns true if the connection should be accepted, false if it should be rejected
+     */
+    shouldAccept(): boolean;
+    /**
+     * Register a connection attempt.
+     * Call this when a new connection is initiated (before handshake completes).
+     */
+    onConnectionAttempt(): void;
+    /**
+     * Register that a connection has been established (handshake complete).
+     * Call this when the connection is fully established and authenticated.
+     */
+    onConnectionEstablished(): void;
+    /**
+     * Register that a connection has been closed.
+     * Call this when a pending connection is closed before completing handshake.
+     */
+    onConnectionClosed(): void;
+    /**
+     * Register that a connection was rejected.
+     * Call this when shouldAccept() returns false and the connection is rejected.
+     */
+    onConnectionRejected(): void;
+    /**
+     * Decrease pending count when a connection times out or fails.
+     * Call this when a pending connection fails to complete handshake.
+     */
+    onPendingConnectionFailed(): void;
+    /**
+     * Get current rate limiter statistics.
+     */
+    getStats(): RateLimiterStats;
+    /**
+     * Reset the rate limiter state.
+     * Useful for testing or when recovering from errors.
+     */
+    reset(): void;
+    /**
+     * Update configuration at runtime.
+     */
+    updateConfig(config: Partial<RateLimiterConfig>): void;
+    /**
+     * Check if window has expired and reset if needed.
+     */
+    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 class FailureDetector extends EventEmitter {
+    private config;
+    private nodeStates;
+    private monitoringNodes;
+    private checkTimer?;
+    private confirmationTimers;
+    private started;
+    constructor(config?: Partial<FailureDetectorConfig>);
+    /**
+     * Start the failure detector monitoring loop.
+     */
+    start(): void;
+    /**
+     * Stop the failure detector and clean up.
+     */
+    stop(): void;
+    /**
+     * Start monitoring a node.
+     */
+    startMonitoring(nodeId: string): void;
+    /**
+     * Stop monitoring a node.
+     */
+    stopMonitoring(nodeId: string): void;
+    /**
+     * Record a heartbeat from a node.
+     * This updates the node's state and clears any suspicion.
+     */
+    recordHeartbeat(nodeId: string): void;
+    /**
+     * Check all monitored nodes for failure.
+     */
+    private checkAllNodes;
+    /**
+     * Schedule failure confirmation after suspicion timeout.
+     */
+    private scheduleConfirmation;
+    /**
+     * Confirm node failure after confirmation timeout.
+     */
+    private confirmFailure;
+    /**
+     * 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.
+     */
+    calculatePhi(nodeId: string): number;
+    /**
+     * Calculate mean of an array of numbers.
+     */
+    private calculateMean;
+    /**
+     * Calculate variance of an array of numbers.
+     */
+    private calculateVariance;
+    /**
+     * Get list of currently suspected nodes.
+     */
+    getSuspectedNodes(): string[];
+    /**
+     * Get list of confirmed failed nodes.
+     */
+    getConfirmedFailedNodes(): string[];
+    /**
+     * Check if a specific node is suspected.
+     */
+    isSuspected(nodeId: string): boolean;
+    /**
+     * Check if a specific node's failure is confirmed.
+     */
+    isConfirmedFailed(nodeId: string): boolean;
+    /**
+     * Get the current phi value for a node.
+     */
+    getPhi(nodeId: string): number;
+    /**
+     * Get all monitored nodes.
+     */
+    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' | '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';
+    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);
+    /**
+     * Get the failure detector instance.
+     */
+    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;
+    /**
+     * Start sending heartbeats to all peers.
+     */
+    private startHeartbeat;
+    /**
+     * Stop sending heartbeats.
+     */
+    private stopHeartbeat;
+    /**
+     * Send heartbeat to all connected peers.
+     */
+    private sendHeartbeatToAll;
+    /**
+     * Handle incoming heartbeat from a peer.
+     */
+    private handleHeartbeat;
+    /**
+     * Handle confirmed node failure.
+     */
+    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>);
+    /**
+     * Set the data collector callback
+     * Called to collect all records for a partition before migration
+     */
+    setDataCollector(collector: (partitionId: number) => Promise<Uint8Array[]>): void;
+    /**
+     * Set the data storer callback
+     * Called to store received records after successful migration
+     */
+    setDataStorer(storer: (partitionId: number, data: Uint8Array[]) => Promise<void>): void;
+    /**
+     * Plan migration for topology change
+     */
+    planMigration(oldDistribution: Map<number, PartitionDistribution>, newDistribution: Map<number, PartitionDistribution>): void;
+    /**
+     * Start batch processing timer
+     */
+    private startBatchProcessing;
+    /**
+     * Stop batch processing
+     */
+    private stopBatchProcessing;
+    /**
+     * Start next batch of migrations
+     */
+    startNextBatch(): Promise<void>;
+    /**
+     * Start migration for a single partition
+     */
+    private startPartitionMigration;
+    /**
+     * Split records into chunks
+     */
+    private chunkify;
+    /**
+     * Calculate checksum for a chunk using native xxhash
+     */
+    private calculateChecksum;
+    /**
+     * Calculate checksum for all partition records using streaming xxhash
+     */
+    private calculatePartitionChecksum;
+    /**
+     * Wait for chunk acknowledgment
+     */
+    private waitForChunkAck;
+    /**
+     * Wait for migration verification
+     */
+    private waitForVerification;
+    /**
+     * Handle successful migration completion
+     */
+    private onMigrationComplete;
+    /**
+     * Handle migration failure
+     */
+    private onMigrationFailed;
+    /**
+     * Handle MIGRATION_START message
+     */
+    private handleMigrationStart;
+    /**
+     * Handle MIGRATION_CHUNK message
+     */
+    private handleMigrationChunk;
+    /**
+     * Handle MIGRATION_COMPLETE message
+     */
+    private handleMigrationComplete;
+    /**
+     * Handle MIGRATION_CHUNK_ACK message
+     */
+    private handleMigrationChunkAck;
+    /**
+     * Handle MIGRATION_VERIFY message
+     */
+    private handleMigrationVerify;
+    /**
+     * Reassemble chunks into continuous data
+     */
+    private reassemble;
+    /**
+     * Deserialize records from chunk data
+     */
+    private deserializeRecords;
+    /**
+     * Setup cluster message handlers
+     */
+    private setupMessageHandlers;
+    /**
+     * Check if a partition is currently migrating
+     */
+    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;
+    /**
+     * Get current partition map version
+     */
+    getMapVersion(): number;
+    /**
+     * Generate full PartitionMap for client consumption
+     */
+    getPartitionMap(): PartitionMap;
+    /**
+     * Get partition info by ID
+     */
+    getPartitionInfo(partitionId: number): PartitionInfo | null;
+    /**
+     * Get owner node for a partition ID
+     */
+    getPartitionOwner(partitionId: number): string | null;
+    private rebalance;
+    /**
+     * Perform gradual rebalancing using MigrationManager
+     */
+    private rebalanceGradual;
+    /**
+     * Set partition owner (called after migration completes)
+     */
+    setOwner(partitionId: number, nodeId: string): void;
+    /**
+     * Get backups for a partition
+     */
+    getBackups(partitionId: number): string[];
+    /**
+     * Get migration status
+     */
+    getMigrationStatus(): MigrationStatus | null;
+    /**
+     * Check if partition is currently migrating
+     */
+    isMigrating(partitionId: number): boolean;
+    /**
+     * Check if any partition is currently migrating
+     */
+    isRebalancing(): boolean;
+    /**
+     * Get MigrationManager for configuration
+     */
+    getMigrationManager(): MigrationManager | null;
+    /**
+     * Cancel all migrations
+     */
+    cancelMigrations(): Promise<void>;
+}
+
+/**
+ * LagTracker - Monitors replication lag across cluster nodes
+ *
+ * Phase 4 Task 04: Async Replication Pipeline
+ *
+ * Features:
+ * - Tracks replication lag per node
+ * - Maintains historical lag data for percentile calculations
+ * - Identifies unhealthy and laggy nodes
+ * - Provides health metrics for monitoring
+ */
+
+interface LagInfo {
+    current: number;
+    history: number[];
+    lastUpdate: number;
+    pendingOps: number;
+}
+interface LagTrackerConfig {
+    /** Number of lag samples to keep in history (default: 100) */
+    historySize: number;
+    /** Threshold in ms for considering a node laggy (default: 5000) */
+    laggyThresholdMs: number;
+    /** Threshold in ms for considering a node unhealthy (default: 30000) */
+    unhealthyThresholdMs: number;
+}
+declare const DEFAULT_LAG_TRACKER_CONFIG: LagTrackerConfig;
+declare class LagTracker {
+    private readonly config;
+    private lagByNode;
+    constructor(config?: Partial<LagTrackerConfig>);
+    /**
+     * Update lag measurement for a node
+     */
+    update(nodeId: string, lagMs: number): void;
+    /**
+     * Record acknowledgment from a node (lag effectively becomes 0)
+     */
+    recordAck(nodeId: string): void;
+    /**
+     * Increment pending operations counter for a node
+     */
+    incrementPending(nodeId: string): void;
+    /**
+     * Get lag statistics for a specific node
+     */
+    getLag(nodeId: string): ReplicationLag;
+    /**
+     * Get pending operations count for a node
+     */
+    getPendingOps(nodeId: string): number;
+    /**
+     * Get overall replication health status
+     */
+    getHealth(): ReplicationHealth;
+    /**
+     * Get average lag across all tracked nodes
+     */
+    getAverageLag(): number;
+    /**
+     * Check if a specific node is considered healthy
+     */
+    isNodeHealthy(nodeId: string): boolean;
+    /**
+     * Check if a specific node is considered laggy
+     */
+    isNodeLaggy(nodeId: string): boolean;
+    /**
+     * Remove a node from tracking
+     */
+    removeNode(nodeId: string): void;
+    /**
+     * Get all tracked node IDs
+     */
+    getTrackedNodes(): string[];
+    /**
+     * Get raw lag info for a node (for advanced monitoring)
+     */
+    getRawLagInfo(nodeId: string): LagInfo | undefined;
+    /**
+     * Clear all tracking data
+     */
+    clear(): void;
+    /**
+     * Export metrics in Prometheus format
+     */
+    toPrometheusMetrics(): string;
+}
+
+/**
+ * ReplicationPipeline - Manages async replication with configurable consistency levels
+ *
+ * Phase 4 Task 04: Async Replication Pipeline
+ *
+ * Features:
+ * - Three consistency levels: STRONG, QUORUM, EVENTUAL
+ * - Async replication queue for high throughput
+ * - Backpressure handling with queue limits
+ * - Retry logic for failed replications
+ * - Integration with LagTracker for monitoring
+ * - Pluggable operation applier for storage integration
+ */
+
+/**
+ * Callback to apply replicated operation to local storage
+ * @param operation - The operation to apply
+ * @param opId - Unique operation ID
+ * @param sourceNode - Node that originated the operation
+ * @returns Promise<boolean> - true if applied successfully
+ */
+type OperationApplier = (operation: unknown, opId: string, sourceNode: string) => Promise<boolean>;
+declare class ReplicationPipeline extends EventEmitter {
+    private readonly config;
+    private readonly clusterManager;
+    private readonly partitionService;
+    private readonly lagTracker;
+    private readonly nodeId;
+    private replicationQueue;
+    private pendingAcks;
+    private queueProcessorTimer;
+    private operationApplier;
+    constructor(clusterManager: ClusterManager, partitionService: PartitionService, config?: Partial<ReplicationConfig>);
+    /**
+     * Set the operation applier callback
+     * This is called when replicated operations are received from other nodes
+     */
+    setOperationApplier(applier: OperationApplier): void;
+    /**
+     * Replicate operation to backup nodes
+     */
+    replicate(operation: unknown, opId: string, key: string, options?: {
+        consistency?: ConsistencyLevel;
+        timeout?: number;
+    }): Promise<ReplicationResult>;
+    /**
+     * STRONG: Wait for all replicas to acknowledge
+     */
+    private replicateStrong;
+    /**
+     * QUORUM: Wait for majority of replicas
+     */
+    private replicateQuorum;
+    /**
+     * EVENTUAL: Fire-and-forget with queue
+     */
+    private replicateEventual;
+    /**
+     * Add task to replication queue
+     */
+    private enqueue;
+    /**
+     * Start queue processor
+     */
+    private startQueueProcessor;
+    /**
+     * Stop queue processor
+     */
+    private stopQueueProcessor;
+    /**
+     * Process replication queue for a node
+     */
+    private processQueue;
+    /**
+     * Send replication message to a node
+     */
+    private sendReplication;
+    /**
+     * Setup cluster message handlers
+     */
+    private setupMessageHandlers;
+    /**
+     * Handle incoming replication request (on backup node)
+     */
+    private handleReplication;
+    /**
+     * Handle incoming batch replication (on backup node)
+     */
+    private handleReplicationBatch;
+    /**
+     * Handle replication acknowledgment (on owner node)
+     */
+    private handleReplicationAck;
+    /**
+     * Handle batch acknowledgment (on owner node)
+     */
+    private handleReplicationBatchAck;
+    /**
+     * Get replication lag for a specific node
+     */
+    getLag(nodeId: string): ReplicationLag;
+    /**
+     * Get overall replication health
+     */
+    getHealth(): ReplicationHealth;
+    /**
+     * Get queue size for a specific node
+     */
+    getQueueSize(nodeId: string): number;
+    /**
+     * Get total pending operations across all nodes
+     */
+    getTotalPending(): number;
+    /**
+     * Check if a node is considered synced (low lag)
+     */
+    isSynced(nodeId: string, maxLagMs?: number): boolean;
+    /**
+     * Get LagTracker for advanced monitoring
+     */
+    getLagTracker(): LagTracker;
+    /**
+     * Export metrics in Prometheus format
+     */
+    toPrometheusMetrics(): string;
+    /**
+     * Cleanup resources
+     */
+    close(): void;
+}
+
+declare class LockManager extends EventEmitter {
+    private locks;
+    private checkInterval;
+    private static readonly MIN_TTL;
+    private static readonly MAX_TTL;
+    constructor();
+    stop(): void;
+    acquire(name: string, clientId: string, requestId: string, ttl: number): {
+        granted: boolean;
+        fencingToken?: number;
+        error?: string;
+    };
+    release(name: string, clientId: string, fencingToken: number): boolean;
+    handleClientDisconnect(clientId: string): void;
+    private grantLock;
+    private processNext;
+    private cleanupExpiredLocks;
+}
+
+/**
+ * ClusterCoordinator - Unified cluster integration layer
+ *
+ * Phase 4 Task 06: System Integration
+ *
+ * Coordinates all cluster components:
+ * - ClusterManager: P2P WebSocket mesh
+ * - PartitionService: Consistent hashing & routing
+ * - MigrationManager: Gradual rebalancing
+ * - ReplicationPipeline: Async replication with consistency levels
+ * - LagTracker: Replication health monitoring
+ */
+
+interface ClusterCoordinatorConfig {
+    /** Cluster node configuration */
+    cluster: ClusterConfig;
+    /** Enable gradual partition rebalancing (default: true) */
+    gradualRebalancing: boolean;
+    /** Migration configuration for gradual rebalancing */
+    migration: Partial<MigrationConfig>;
+    /** Replication configuration */
+    replication: Partial<ReplicationConfig>;
+    /** Enable async replication pipeline (default: true) */
+    replicationEnabled: boolean;
+    /** Data collector callback for migrations */
+    dataCollector?: (partitionId: number) => Promise<Uint8Array[]>;
+    /** Data storer callback for incoming migrations */
+    dataStorer?: (partitionId: number, data: Uint8Array[]) => Promise<void>;
+}
+declare const DEFAULT_CLUSTER_COORDINATOR_CONFIG: Omit<ClusterCoordinatorConfig, 'cluster'>;
+interface ClusterCoordinatorEvents {
+    'started': () => void;
+    'stopped': () => void;
+    'member:joined': (nodeId: string) => void;
+    'member:left': (nodeId: string) => void;
+    'partition:rebalanced': (map: PartitionMap, changes: PartitionChange[]) => void;
+    'partition:moved': (info: {
+        partitionId: number;
+        previousOwner: string;
+        newOwner: string;
+        version: number;
+    }) => void;
+    'migration:started': (partitionId: number, targetNode: string) => void;
+    'migration:completed': (partitionId: number) => void;
+    'migration:failed': (partitionId: number, error: Error) => void;
+    'replication:unhealthy': (nodeId: string) => void;
+    'replication:healthy': (nodeId: string) => void;
+    'error': (error: Error) => void;
+}
+declare class ClusterCoordinator extends EventEmitter {
+    private readonly config;
+    private clusterManager;
+    private partitionService;
+    private replicationPipeline;
+    private lagTracker;
+    private started;
+    private actualPort;
+    constructor(config: ClusterCoordinatorConfig);
+    /**
+     * Start the cluster coordinator
+     */
+    start(): Promise<number>;
+    /**
+     * Stop the cluster coordinator
+     */
+    stop(): Promise<void>;
+    /**
+     * Get local node ID
+     */
+    getNodeId(): string;
+    /**
+     * Get cluster port
+     */
+    getPort(): number;
+    /**
+     * Get all cluster members
+     */
+    getMembers(): string[];
+    /**
+     * Check if this is the local node
+     */
+    isLocal(nodeId: string): boolean;
+    /**
+     * Check if coordinator is started
+     */
+    isStarted(): boolean;
+    /**
+     * Get current partition map
+     */
+    getPartitionMap(): PartitionMap;
+    /**
+     * Get partition map version
+     */
+    getPartitionMapVersion(): number;
+    /**
+     * Get partition ID for a key
+     */
+    getPartitionId(key: string): number;
+    /**
+     * Get owner node for a key
+     */
+    getOwner(key: string): string;
+    /**
+     * Check if this node owns the key
+     */
+    isLocalOwner(key: string): boolean;
+    /**
+     * Check if this node is a backup for the key
+     */
+    isLocalBackup(key: string): boolean;
+    /**
+     * Get backup nodes for a partition
+     */
+    getBackups(partitionId: number): string[];
+    /**
+     * Check if partition is currently migrating
+     */
+    isMigrating(partitionId: number): boolean;
+    /**
+     * Check if any rebalancing is in progress
+     */
+    isRebalancing(): boolean;
+    /**
+     * Get migration status
+     */
+    getMigrationStatus(): MigrationStatus | null;
+    /**
+     * Get migration metrics
+     */
+    getMigrationMetrics(): MigrationMetrics | null;
+    /**
+     * Cancel all active migrations
+     */
+    cancelMigrations(): Promise<void>;
+    /**
+     * Set data collector for migrations
+     */
+    setDataCollector(collector: (partitionId: number) => Promise<Uint8Array[]>): void;
+    /**
+     * Set data storer for incoming migrations
+     */
+    setDataStorer(storer: (partitionId: number, data: Uint8Array[]) => Promise<void>): void;
+    /**
+     * Replicate an operation to backup nodes
+     */
+    replicate(operation: unknown, opId: string, key: string, options?: {
+        consistency?: ConsistencyLevel;
+        timeout?: number;
+    }): Promise<ReplicationResult>;
+    /**
+     * Get replication health status
+     */
+    getReplicationHealth(): ReplicationHealth;
+    /**
+     * Get replication lag for a specific node
+     */
+    getReplicationLag(nodeId: string): ReplicationLag;
+    /**
+     * Check if a node is healthy for replication
+     */
+    isNodeHealthy(nodeId: string): boolean;
+    /**
+     * Check if a node is laggy
+     */
+    isNodeLaggy(nodeId: string): boolean;
+    /**
+     * Send message to a specific node
+     */
+    send(nodeId: string, message: unknown): void;
+    /**
+     * Broadcast message to all nodes
+     */
+    broadcast(message: unknown): void;
+    /**
+     * Get underlying ClusterManager
+     */
+    getClusterManager(): ClusterManager;
+    /**
+     * Get underlying PartitionService
+     */
+    getPartitionService(): PartitionService;
+    /**
+     * Get underlying ReplicationPipeline
+     */
+    getReplicationPipeline(): ReplicationPipeline | null;
+    /**
+     * Get underlying LagTracker
+     */
+    getLagTracker(): LagTracker;
+    /**
+     * Get all metrics in Prometheus format
+     */
+    getPrometheusMetrics(): string;
+    private setupEventHandlers;
 }
 
-export { type ConnectionContext, type IInterceptor, type IServerStorage, type Logger, MemoryServerAdapter, type ORMapTombstones, type ORMapValue, type OpContext, PostgresAdapter, type PostgresAdapterOptions, RateLimitInterceptor, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerOp, type StorageValue, TimestampInterceptor, logger };
+export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type ClusterConfig, ClusterCoordinator, type ClusterCoordinatorConfig, type ClusterCoordinatorEvents, ClusterManager, type ClusterMember, type ClusterMessage, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, type ConnectionContext, ConnectionRateLimiter, DEFAULT_CLUSTER_COORDINATOR_CONFIG, DEFAULT_LAG_TRACKER_CONFIG, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, IteratorTasklet, type IteratorTaskletConfig, type LagInfo, LagTracker, type LagTrackerConfig, LockManager, type Logger, MapTasklet, MemoryServerAdapter, MigrationManager, type NativeModuleStatus, type NativeStats, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PartitionDistribution, PartitionService, type PartitionServiceConfig, type PartitionServiceEvents, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, ReduceTasklet, ReplicationPipeline, SecurityManager, ServerCoordinator, type ServerCoordinatorConfig, type ServerOp, 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, setGlobalBufferPool, setGlobalEventPayloadPool, setGlobalMessagePool, setGlobalRecordPool, setGlobalTimestampPool };