@topgunbuild/server 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -1,8 +1,1387 @@
-import { LWWRecord, ORMapRecord, Principal, PermissionPolicy, LWWMap, ORMap, PermissionType } from '@topgunbuild/core';
+import { Timestamp, LWWRecord, ORMapRecord, Principal, PermissionPolicy, LWWMap, ORMap, PermissionType } from '@topgunbuild/core';
 import { WebSocket } from 'ws';
 import { PoolConfig, Pool } from 'pg';
 import pino from 'pino';
 
+/**
+ * TaskletScheduler — Cooperative multitasking for long-running operations.
+ *
+ * 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
+ */
+/**
+ * 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;
+    /**
+     * Execute one chunk of work.
+     * Should check time budget and return appropriate state.
+     */
+    call(): ProgressState;
+    /**
+     * Get the result after tasklet is DONE.
+     * Only valid when call() returns 'DONE'.
+     */
+    getResult(): T;
+    /**
+     * Called when tasklet is cancelled before completion.
+     */
+    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);
+    /**
+     * Schedule a tasklet for execution.
+     * Returns a promise that resolves when the tasklet completes.
+     */
+    schedule<T>(tasklet: Tasklet<T>): Promise<T>;
+    /**
+     * Run a tasklet synchronously (blocking).
+     * Useful for small operations or when cooperative scheduling isn't needed.
+     */
+    runSync<T>(tasklet: Tasklet<T>): T;
+    /**
+     * Cancel a specific tasklet by name pattern.
+     * Returns the number of tasklets cancelled.
+     */
+    cancel(namePattern: string | RegExp): number;
+    /**
+     * Cancel all running tasklets.
+     */
+    cancelAll(): number;
+    /**
+     * Get scheduler statistics.
+     */
+    getStats(): TaskletSchedulerStats;
+    /**
+     * Reset statistics.
+     */
+    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;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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[];
+}
+/**
+ * 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 {
+    /**
+     * Size of each buffer chunk in bytes.
+     * Larger chunks = fewer allocations, but more memory waste.
+     * Default: 64KB (65536)
+     */
+    chunkSize?: number;
+    /**
+     * Initial number of buffers to pre-allocate.
+     * Default: 16
+     */
+    initialSize?: number;
+    /**
+     * Maximum buffers to keep in pool.
+     * Excess buffers are released to GC.
+     * Default: 256
+     */
+    maxSize?: number;
+    /**
+     * Auto-shrink pool when idle buffers exceed this ratio.
+     * Default: true
+     */
+    autoShrink?: boolean;
+    /**
+     * Shrink threshold - shrink if (available / maxSize) > threshold.
+     * Default: 0.75 (75% idle)
+     */
+    shrinkThreshold?: number;
+    /**
+     * Enable metrics collection.
+     * Default: true
+     */
+    metricsEnabled?: boolean;
+}
+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);
+    /**
+     * Acquire a buffer from the pool.
+     * Creates new buffer if pool is empty.
+     *
+     * @returns A Uint8Array of exactly chunkSize bytes
+     */
+    acquire(): Uint8Array;
+    /**
+     * Release a buffer back to the pool.
+     * Buffer contents are cleared before returning to pool.
+     *
+     * @param buffer - The buffer to release
+     */
+    release(buffer: Uint8Array): void;
+    /**
+     * 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
+     */
+    acquireSize(minSize: number): Uint8Array;
+    /**
+     * Get current pool statistics.
+     */
+    getStats(): BufferPoolStats;
+    /**
+     * Clear all buffers from pool.
+     * Use for shutdown or memory pressure situations.
+     */
+    clear(): void;
+    /**
+     * Manually trigger shrink operation.
+     * Removes excess idle buffers to reduce memory footprint.
+     */
+    shrink(): void;
+    /**
+     * Pre-warm pool by creating buffers up to specified count.
+     * Called automatically in constructor.
+     *
+     * @param count - Number of buffers to create
+     */
+    prewarm(count?: number): void;
+    /**
+     * Reset all metrics to zero.
+     * Useful for testing or periodic metric collection.
+     */
+    resetStats(): void;
+    /**
+     * Get configuration values.
+     */
+    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;
+
+/**
+ * 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> {
+    /**
+     * Factory function to create new objects.
+     * Called when pool is empty.
+     */
+    factory: () => T;
+    /**
+     * Reset function to clean object before reuse.
+     * Should clear all fields to initial state.
+     */
+    reset: (obj: T) => void;
+    /**
+     * Optional validator to check if object is reusable.
+     * Return false to discard corrupted objects.
+     */
+    validate?: (obj: T) => boolean;
+    /**
+     * Initial pool size.
+     * Default: 32
+     */
+    initialSize?: number;
+    /**
+     * Maximum pool size.
+     * Excess objects are discarded.
+     * Default: 512
+     */
+    maxSize?: number;
+    /**
+     * Name for debugging/metrics.
+     */
+    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;
+}
+
+/**
+ * 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;
+}
+/**
+ * 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;
+
+/**
+ * RecordPool - Pre-configured ObjectPool for LWW/OR record objects.
+ * Phase 2.04: Object Pool Implementation
+ *
+ * Reduces GC pressure when processing CRDT operations.
+ */
+
+/**
+ * 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;
+
+/**
+ * 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;
+}
+
+/**
+ * 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 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;
+}
+
+/**
+ * Merkle Worker Types
+ * Phase 1.03: MerkleWorker Implementation
+ */
+
+/**
+ * Entry for Merkle hash computation (LWWMap style)
+ */
+interface MerkleHashEntry {
+    key: string;
+    timestamp: Timestamp;
+}
+/**
+ * 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>[];
@@ -160,6 +1539,122 @@ interface ClusterTLSConfig extends TLSConfig {
     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
+ */
+declare const coalescingPresets: {
+    /**
+     * Conservative defaults - good for low-latency workloads.
+     * Minimizes batching delay at the cost of more network calls.
+     * Use for: gaming, real-time chat, interactive applications.
+     */
+    readonly conservative: {
+        readonly maxBatchSize: 100;
+        readonly maxDelayMs: 5;
+        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: 8;
+        readonly maxBatchBytes: 131072;
+    };
+    /**
+     * High throughput - optimized for write-heavy workloads.
+     * Higher batching for better network utilization.
+     * Use for: data ingestion, logging, IoT data streams.
+     */
+    readonly highThroughput: {
+        readonly maxBatchSize: 500;
+        readonly maxDelayMs: 10;
+        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: 15;
+        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;
@@ -178,6 +1673,54 @@ interface ServerCoordinatorConfig {
     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;
 }
 declare class ServerCoordinator {
     private httpServer;
@@ -202,6 +1745,20 @@ declare class ServerCoordinator {
     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;
@@ -209,20 +1766,113 @@ declare class ServerCoordinator {
     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;
     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;
+    /**
+     * 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>;
     /**
@@ -257,6 +1907,38 @@ declare class ServerCoordinator {
     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 {
@@ -312,6 +1994,98 @@ declare class SecurityManager {
 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>;
@@ -330,4 +2104,47 @@ declare class RateLimitInterceptor implements IInterceptor {
     onDisconnect(context: any): Promise<void>;
 }
 
-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 };
+/**
+ * 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;
+
+export { BufferPool, type BufferPoolConfig, type BufferPoolStats, type CoalescingPreset, type CoalescingWriterMetrics, type CoalescingWriterOptions, type ConnectionContext, ConnectionRateLimiter, FilterTasklet, ForEachTasklet, type IInterceptor, type IServerStorage, IteratorTasklet, type IteratorTaskletConfig, type Logger, MapTasklet, MemoryServerAdapter, type NativeModuleStatus, type NativeStats, type ORMapTombstones, type ORMapValue, ObjectPool, type ObjectPoolConfig, type ObjectPoolStats, type OpContext, type PooledEventPayload, type PooledMessage, type PooledRecord, type PooledTimestamp, PostgresAdapter, type PostgresAdapterOptions, type ProgressState, RateLimitInterceptor, type RateLimiterConfig, type RateLimiterStats, ReduceTasklet, 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 };