@topgunbuild/client 0.10.0 → 0.10.1

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/SyncEngine.ts
-import { HLC, LWWMap, ORMap, serialize, deserialize, evaluatePredicate } from "@topgunbuild/core";
+import { HLC, LWWMap as LWWMap2, ORMap as ORMap2, deserialize as deserialize2 } from "@topgunbuild/core";
 
 // src/utils/logger.ts
 import pino from "pino";
@@ -180,21 +180,6 @@ var SyncStateMachine = class {
   }
 };
 
-// src/errors/BackpressureError.ts
-var BackpressureError = class _BackpressureError extends Error {
-  constructor(pendingCount, maxPending) {
-    super(
-      `Backpressure limit reached: ${pendingCount}/${maxPending} pending operations. Wait for acknowledgments or increase maxPendingOps.`
-    );
-    this.pendingCount = pendingCount;
-    this.maxPending = maxPending;
-    this.name = "BackpressureError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _BackpressureError);
-    }
-  }
-};
-
 // src/BackpressureConfig.ts
 var DEFAULT_BACKPRESSURE_CONFIG = {
   maxPendingOps: 1e3,
@@ -203,233 +188,6 @@ var DEFAULT_BACKPRESSURE_CONFIG = {
   lowWaterMark: 0.5
 };
 
-// src/connection/SingleServerProvider.ts
-var DEFAULT_CONFIG = {
-  maxReconnectAttempts: 10,
-  reconnectDelayMs: 1e3,
-  backoffMultiplier: 2,
-  maxReconnectDelayMs: 3e4
-};
-var SingleServerProvider = class {
-  constructor(config) {
-    this.ws = null;
-    this.reconnectAttempts = 0;
-    this.reconnectTimer = null;
-    this.isClosing = false;
-    this.listeners = /* @__PURE__ */ new Map();
-    this.url = config.url;
-    this.config = {
-      url: config.url,
-      maxReconnectAttempts: config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts,
-      reconnectDelayMs: config.reconnectDelayMs ?? DEFAULT_CONFIG.reconnectDelayMs,
-      backoffMultiplier: config.backoffMultiplier ?? DEFAULT_CONFIG.backoffMultiplier,
-      maxReconnectDelayMs: config.maxReconnectDelayMs ?? DEFAULT_CONFIG.maxReconnectDelayMs
-    };
-  }
-  /**
-   * Connect to the WebSocket server.
-   */
-  async connect() {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
-      return;
-    }
-    this.isClosing = false;
-    return new Promise((resolve, reject) => {
-      try {
-        this.ws = new WebSocket(this.url);
-        this.ws.binaryType = "arraybuffer";
-        this.ws.onopen = () => {
-          this.reconnectAttempts = 0;
-          logger.info({ url: this.url }, "SingleServerProvider connected");
-          this.emit("connected", "default");
-          resolve();
-        };
-        this.ws.onerror = (error) => {
-          logger.error({ err: error, url: this.url }, "SingleServerProvider WebSocket error");
-          this.emit("error", error);
-        };
-        this.ws.onclose = (event) => {
-          logger.info({ url: this.url, code: event.code }, "SingleServerProvider disconnected");
-          this.emit("disconnected", "default");
-          if (!this.isClosing) {
-            this.scheduleReconnect();
-          }
-        };
-        this.ws.onmessage = (event) => {
-          this.emit("message", "default", event.data);
-        };
-        const timeoutId = setTimeout(() => {
-          if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
-            this.ws.close();
-            reject(new Error(`Connection timeout to ${this.url}`));
-          }
-        }, this.config.reconnectDelayMs * 5);
-        const originalOnOpen = this.ws.onopen;
-        const wsRef = this.ws;
-        this.ws.onopen = (ev) => {
-          clearTimeout(timeoutId);
-          if (originalOnOpen) {
-            originalOnOpen.call(wsRef, ev);
-          }
-        };
-      } catch (error) {
-        reject(error);
-      }
-    });
-  }
-  /**
-   * Get connection for a specific key.
-   * In single-server mode, key is ignored.
-   */
-  getConnection(_key) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("Not connected");
-    }
-    return this.ws;
-  }
-  /**
-   * Get any available connection.
-   */
-  getAnyConnection() {
-    return this.getConnection("");
-  }
-  /**
-   * Check if connected.
-   */
-  isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
-  }
-  /**
-   * Get connected node IDs.
-   * Single-server mode returns ['default'] when connected.
-   */
-  getConnectedNodes() {
-    return this.isConnected() ? ["default"] : [];
-  }
-  /**
-   * Subscribe to connection events.
-   */
-  on(event, handler2) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.listeners.get(event).add(handler2);
-  }
-  /**
-   * Unsubscribe from connection events.
-   */
-  off(event, handler2) {
-    this.listeners.get(event)?.delete(handler2);
-  }
-  /**
-   * Send data via the WebSocket connection.
-   * In single-server mode, key parameter is ignored.
-   */
-  send(data, _key) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-      throw new Error("Not connected");
-    }
-    this.ws.send(data);
-  }
-  /**
-   * Close the WebSocket connection.
-   */
-  async close() {
-    this.isClosing = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.onclose = null;
-      this.ws.onerror = null;
-      this.ws.onmessage = null;
-      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
-        this.ws.close();
-      }
-      this.ws = null;
-    }
-    logger.info({ url: this.url }, "SingleServerProvider closed");
-  }
-  /**
-   * Emit an event to all listeners.
-   */
-  emit(event, ...args) {
-    const handlers = this.listeners.get(event);
-    if (handlers) {
-      for (const handler2 of handlers) {
-        try {
-          handler2(...args);
-        } catch (err) {
-          logger.error({ err, event }, "Error in SingleServerProvider event handler");
-        }
-      }
-    }
-  }
-  /**
-   * Schedule a reconnection attempt with exponential backoff.
-   */
-  scheduleReconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
-      logger.error(
-        { attempts: this.reconnectAttempts, url: this.url },
-        "SingleServerProvider max reconnect attempts reached"
-      );
-      this.emit("error", new Error("Max reconnection attempts reached"));
-      return;
-    }
-    const delay = this.calculateBackoffDelay();
-    logger.info(
-      { delay, attempt: this.reconnectAttempts, url: this.url },
-      `SingleServerProvider scheduling reconnect in ${delay}ms`
-    );
-    this.reconnectTimer = setTimeout(async () => {
-      this.reconnectTimer = null;
-      this.reconnectAttempts++;
-      try {
-        await this.connect();
-        this.emit("reconnected", "default");
-      } catch (error) {
-        logger.error({ err: error }, "SingleServerProvider reconnection failed");
-        this.scheduleReconnect();
-      }
-    }, delay);
-  }
-  /**
-   * Calculate backoff delay with exponential increase.
-   */
-  calculateBackoffDelay() {
-    const { reconnectDelayMs, backoffMultiplier, maxReconnectDelayMs } = this.config;
-    let delay = reconnectDelayMs * Math.pow(backoffMultiplier, this.reconnectAttempts);
-    delay = Math.min(delay, maxReconnectDelayMs);
-    delay = delay * (0.5 + Math.random());
-    return Math.floor(delay);
-  }
-  /**
-   * Get the WebSocket URL this provider connects to.
-   */
-  getUrl() {
-    return this.url;
-  }
-  /**
-   * Get current reconnection attempt count.
-   */
-  getReconnectAttempts() {
-    return this.reconnectAttempts;
-  }
-  /**
-   * Reset reconnection counter.
-   * Called externally after successful authentication.
-   */
-  resetReconnectAttempts() {
-    this.reconnectAttempts = 0;
-  }
-};
-
 // src/ConflictResolverClient.ts
 var _ConflictResolverClient = class _ConflictResolverClient {
   // 10 seconds
@@ -661,189 +419,52 @@ var _ConflictResolverClient = class _ConflictResolverClient {
 _ConflictResolverClient.REQUEST_TIMEOUT = 1e4;
 var ConflictResolverClient = _ConflictResolverClient;
 
-// src/SyncEngine.ts
-var DEFAULT_BACKOFF_CONFIG = {
-  initialDelayMs: 1e3,
-  maxDelayMs: 3e4,
-  multiplier: 2,
-  jitter: true,
-  maxRetries: 10
-};
-var _SyncEngine = class _SyncEngine {
+// src/sync/WebSocketManager.ts
+import { serialize, deserialize } from "@topgunbuild/core";
+var WebSocketManager = class {
   constructor(config) {
-    this.websocket = null;
-    this.opLog = [];
-    this.maps = /* @__PURE__ */ new Map();
-    this.queries = /* @__PURE__ */ new Map();
-    this.topics = /* @__PURE__ */ new Map();
-    this.pendingLockRequests = /* @__PURE__ */ new Map();
-    this.lastSyncTimestamp = 0;
+    // Reconnection state
     this.reconnectTimer = null;
-    // NodeJS.Timeout
-    this.authToken = null;
-    this.tokenProvider = null;
     this.backoffAttempt = 0;
+    // Heartbeat state
     this.heartbeatInterval = null;
     this.lastPongReceived = Date.now();
     this.lastRoundTripTime = null;
-    this.backpressurePaused = false;
-    this.waitingForCapacity = [];
-    this.highWaterMarkEmitted = false;
-    this.backpressureListeners = /* @__PURE__ */ new Map();
-    // Write Concern state (Phase 5.01)
-    this.pendingWriteConcernPromises = /* @__PURE__ */ new Map();
-    // ============================================
-    // PN Counter Methods (Phase 5.2)
-    // ============================================
-    /** Counter update listeners by name */
-    this.counterUpdateListeners = /* @__PURE__ */ new Map();
-    // ============================================
-    // Entry Processor Methods (Phase 5.03)
-    // ============================================
-    /** Pending entry processor requests by requestId */
-    this.pendingProcessorRequests = /* @__PURE__ */ new Map();
-    /** Pending batch entry processor requests by requestId */
-    this.pendingBatchProcessorRequests = /* @__PURE__ */ new Map();
-    // ============================================
-    // Event Journal Methods (Phase 5.04)
-    // ============================================
-    /** Message listeners for journal and other generic messages */
-    this.messageListeners = /* @__PURE__ */ new Set();
-    // ============================================
-    // Full-Text Search Methods (Phase 11.1a)
-    // ============================================
-    /** Pending search requests by requestId */
-    this.pendingSearchRequests = /* @__PURE__ */ new Map();
-    // ============================================
-    // Hybrid Query Support (Phase 12)
-    // ============================================
-    /** Active hybrid query subscriptions */
-    this.hybridQueries = /* @__PURE__ */ new Map();
-    if (!config.serverUrl && !config.connectionProvider) {
-      throw new Error("SyncEngine requires either serverUrl or connectionProvider");
-    }
-    this.nodeId = config.nodeId;
-    this.serverUrl = config.serverUrl || "";
-    this.storageAdapter = config.storageAdapter;
-    this.hlc = new HLC(this.nodeId);
-    this.stateMachine = new SyncStateMachine();
-    this.heartbeatConfig = {
-      intervalMs: config.heartbeat?.intervalMs ?? 5e3,
-      timeoutMs: config.heartbeat?.timeoutMs ?? 15e3,
-      enabled: config.heartbeat?.enabled ?? true
-    };
-    this.backoffConfig = {
-      ...DEFAULT_BACKOFF_CONFIG,
-      ...config.backoff
-    };
-    this.backpressureConfig = {
-      ...DEFAULT_BACKPRESSURE_CONFIG,
-      ...config.backpressure
-    };
-    if (config.connectionProvider) {
-      this.connectionProvider = config.connectionProvider;
-      this.useConnectionProvider = true;
-      this.initConnectionProvider();
-    } else {
-      this.connectionProvider = new SingleServerProvider({ url: config.serverUrl });
-      this.useConnectionProvider = false;
-      this.initConnection();
-    }
-    this.conflictResolverClient = new ConflictResolverClient(this);
-    this.loadOpLog();
-  }
-  // ============================================
-  // State Machine Public API
-  // ============================================
-  /**
-   * Get the current connection state
-   */
-  getConnectionState() {
-    return this.stateMachine.getState();
-  }
-  /**
-   * Subscribe to connection state changes
-   * @returns Unsubscribe function
-   */
-  onConnectionStateChange(listener) {
-    return this.stateMachine.onStateChange(listener);
-  }
-  /**
-   * Get state machine history for debugging
-   */
-  getStateHistory(limit) {
-    return this.stateMachine.getHistory(limit);
-  }
-  // ============================================
-  // Internal State Helpers (replace boolean flags)
-  // ============================================
-  /**
-   * Check if WebSocket is connected (but may not be authenticated yet)
-   */
-  isOnline() {
-    const state = this.stateMachine.getState();
-    return state === "CONNECTING" /* CONNECTING */ || state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
-  }
-  /**
-   * Check if fully authenticated and ready for operations
-   */
-  isAuthenticated() {
-    const state = this.stateMachine.getState();
-    return state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+    this.config = config;
+    this.connectionProvider = config.connectionProvider;
   }
   /**
-   * Check if fully connected and synced
+   * Initialize the connection.
+   * Sets up event handlers and starts the connection process.
    */
-  isConnected() {
-    return this.stateMachine.getState() === "CONNECTED" /* CONNECTED */;
+  connect() {
+    this.initConnectionProvider();
   }
-  // ============================================
-  // Connection Management
-  // ============================================
   /**
-   * Initialize connection using IConnectionProvider (Phase 4.5 cluster mode).
-   * Sets up event handlers for the connection provider.
+   * Initialize connection using IConnectionProvider.
    */
   initConnectionProvider() {
-    this.stateMachine.transition("CONNECTING" /* CONNECTING */);
+    this.config.stateMachine.transition("CONNECTING" /* CONNECTING */);
     this.connectionProvider.on("connected", (_nodeId) => {
-      if (this.authToken || this.tokenProvider) {
-        logger.info("ConnectionProvider connected. Sending auth...");
-        this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
-        this.sendAuth();
-      } else {
-        logger.info("ConnectionProvider connected. Waiting for auth token...");
-        this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
-      }
+      logger.info("ConnectionProvider connected.");
+      this.config.onConnected?.();
     });
     this.connectionProvider.on("disconnected", (_nodeId) => {
       logger.info("ConnectionProvider disconnected.");
       this.stopHeartbeat();
-      this.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
+      this.config.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
+      this.config.onDisconnected?.();
     });
     this.connectionProvider.on("reconnected", (_nodeId) => {
       logger.info("ConnectionProvider reconnected.");
-      this.stateMachine.transition("CONNECTING" /* CONNECTING */);
-      if (this.authToken || this.tokenProvider) {
-        this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
-        this.sendAuth();
-      }
+      this.config.stateMachine.transition("CONNECTING" /* CONNECTING */);
+      this.config.onReconnected?.();
     });
     this.connectionProvider.on("message", (_nodeId, data) => {
-      let message;
-      if (data instanceof ArrayBuffer) {
-        message = deserialize(new Uint8Array(data));
-      } else if (data instanceof Uint8Array) {
-        message = deserialize(data);
-      } else {
-        try {
-          message = typeof data === "string" ? JSON.parse(data) : data;
-        } catch (e) {
-          logger.error({ err: e }, "Failed to parse message from ConnectionProvider");
-          return;
-        }
+      const message = this.deserializeMessage(data);
+      if (message) {
+        this.handleMessage(message);
       }
-      this.handleServerMessage(message);
     });
     this.connectionProvider.on("partitionMapUpdated", () => {
       logger.debug("Partition map updated");
@@ -853,109 +474,48 @@ var _SyncEngine = class _SyncEngine {
     });
     this.connectionProvider.connect().catch((err) => {
       logger.error({ err }, "Failed to connect via ConnectionProvider");
-      this.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
+      this.config.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
     });
   }
   /**
-   * Initialize connection using direct WebSocket (legacy single-server mode).
+   * Deserialize incoming message data.
    */
-  initConnection() {
-    this.stateMachine.transition("CONNECTING" /* CONNECTING */);
-    this.websocket = new WebSocket(this.serverUrl);
-    this.websocket.binaryType = "arraybuffer";
-    this.websocket.onopen = () => {
-      if (this.authToken || this.tokenProvider) {
-        logger.info("WebSocket connected. Sending auth...");
-        this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
-        this.sendAuth();
-      } else {
-        logger.info("WebSocket connected. Waiting for auth token...");
-        this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
-      }
-    };
-    this.websocket.onmessage = (event) => {
-      let message;
-      if (event.data instanceof ArrayBuffer) {
-        message = deserialize(new Uint8Array(event.data));
+  deserializeMessage(data) {
+    try {
+      if (data instanceof ArrayBuffer) {
+        return deserialize(new Uint8Array(data));
+      } else if (data instanceof Uint8Array) {
+        return deserialize(data);
+      } else if (typeof data === "string") {
+        return JSON.parse(data);
       } else {
-        try {
-          message = JSON.parse(event.data);
-        } catch (e) {
-          logger.error({ err: e }, "Failed to parse message");
-          return;
-        }
+        return data;
       }
-      this.handleServerMessage(message);
-    };
-    this.websocket.onclose = () => {
-      logger.info("WebSocket disconnected.");
-      this.stopHeartbeat();
-      this.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
-      this.scheduleReconnect();
-    };
-    this.websocket.onerror = (error) => {
-      logger.error({ err: error }, "WebSocket error");
-    };
-  }
-  scheduleReconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.backoffAttempt >= this.backoffConfig.maxRetries) {
-      logger.error(
-        { attempts: this.backoffAttempt },
-        "Max reconnection attempts reached. Entering ERROR state."
-      );
-      this.stateMachine.transition("ERROR" /* ERROR */);
-      return;
-    }
-    this.stateMachine.transition("BACKOFF" /* BACKOFF */);
-    const delay = this.calculateBackoffDelay();
-    logger.info({ delay, attempt: this.backoffAttempt }, `Backing off for ${delay}ms`);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.backoffAttempt++;
-      this.initConnection();
-    }, delay);
-  }
-  calculateBackoffDelay() {
-    const { initialDelayMs, maxDelayMs, multiplier, jitter } = this.backoffConfig;
-    let delay = initialDelayMs * Math.pow(multiplier, this.backoffAttempt);
-    delay = Math.min(delay, maxDelayMs);
-    if (jitter) {
-      delay = delay * (0.5 + Math.random());
+    } catch (e) {
+      logger.error({ err: e }, "Failed to parse message");
+      return null;
     }
-    return Math.floor(delay);
   }
   /**
-   * Reset backoff counter (called on successful connection)
+   * Handle incoming message.
+   * Routes PONG to internal handler, all others to SyncEngine.
    */
-  resetBackoff() {
-    this.backoffAttempt = 0;
+  handleMessage(message) {
+    if (message.type === "PONG") {
+      this.handlePong(message);
+    }
+    this.config.onMessage(message);
   }
   /**
    * Send a message through the current connection.
-   * Uses connectionProvider if in cluster mode, otherwise uses direct websocket.
-   * @param message Message object to serialize and send
-   * @param key Optional key for routing (cluster mode only)
-   * @returns true if message was sent, false otherwise
    */
   sendMessage(message, key) {
     const data = serialize(message);
-    if (this.useConnectionProvider) {
-      try {
-        this.connectionProvider.send(data, key);
-        return true;
-      } catch (err) {
-        logger.warn({ err }, "Failed to send via ConnectionProvider");
-        return false;
-      }
-    } else {
-      if (this.websocket?.readyState === WebSocket.OPEN) {
-        this.websocket.send(data);
-        return true;
-      }
+    try {
+      this.connectionProvider.send(data, key);
+      return true;
+    } catch (err) {
+      logger.warn({ err }, "Failed to send via ConnectionProvider");
       return false;
     }
   }
@@ -963,110 +523,2009 @@ var _SyncEngine = class _SyncEngine {
    * Check if we can send messages (connection is ready).
    */
   canSend() {
-    if (this.useConnectionProvider) {
-      return this.connectionProvider.isConnected();
-    }
-    return this.websocket?.readyState === WebSocket.OPEN;
+    return this.connectionProvider.isConnected();
   }
-  async loadOpLog() {
-    const storedTimestamp = await this.storageAdapter.getMeta("lastSyncTimestamp");
-    if (storedTimestamp) {
-      this.lastSyncTimestamp = storedTimestamp;
-    }
-    const pendingOps = await this.storageAdapter.getPendingOps();
-    this.opLog = pendingOps.map((op) => ({
-      ...op,
-      id: String(op.id),
-      synced: false
-    }));
-    if (this.opLog.length > 0) {
-      logger.info({ count: this.opLog.length }, "Loaded pending operations from local storage");
+  /**
+   * Check if connected to the server.
+   */
+  isOnline() {
+    const state = this.config.stateMachine.getState();
+    return state === "CONNECTING" /* CONNECTING */ || state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+  }
+  /**
+   * Get the connection provider.
+   */
+  getConnectionProvider() {
+    return this.connectionProvider;
+  }
+  /**
+   * Close the connection and clean up resources.
+   */
+  close() {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
+    this.connectionProvider.close().catch((err) => {
+      logger.error({ err }, "Error closing ConnectionProvider");
+    });
   }
-  async saveOpLog() {
-    await this.storageAdapter.setMeta("lastSyncTimestamp", this.lastSyncTimestamp);
+  /**
+   * Reset connection state for a fresh reconnection.
+   */
+  reset() {
+    this.close();
+    this.resetBackoff();
   }
-  registerMap(mapName, map) {
-    this.maps.set(mapName, map);
+  /**
+   * Subscribe to connection events.
+   */
+  on(event, handler2) {
+    this.connectionProvider.on(event, handler2);
   }
-  async recordOperation(mapName, opType, key, data) {
-    await this.checkBackpressure();
-    const opLogEntry = {
-      mapName,
-      opType,
-      key,
-      record: data.record,
-      orRecord: data.orRecord,
-      orTag: data.orTag,
-      timestamp: data.timestamp,
-      synced: false
-    };
-    const id = await this.storageAdapter.appendOpLog(opLogEntry);
-    opLogEntry.id = String(id);
-    this.opLog.push(opLogEntry);
-    this.checkHighWaterMark();
-    if (this.isAuthenticated()) {
-      this.syncPendingOperations();
-    }
-    return opLogEntry.id;
+  /**
+   * Unsubscribe from connection events.
+   */
+  off(event, handler2) {
+    this.connectionProvider.off(event, handler2);
   }
-  syncPendingOperations() {
-    const pending = this.opLog.filter((op) => !op.synced);
-    if (pending.length === 0) return;
-    logger.info({ count: pending.length }, "Syncing pending operations");
-    this.sendMessage({
-      type: "OP_BATCH",
-      payload: {
-        ops: pending
-      }
-    });
+  /**
+   * Reset backoff counter.
+   */
+  resetBackoff() {
+    this.backoffAttempt = 0;
   }
-  startMerkleSync() {
-    for (const [mapName, map] of this.maps) {
-      if (map instanceof LWWMap) {
-        logger.info({ mapName }, "Starting Merkle sync for LWWMap");
-        this.sendMessage({
-          type: "SYNC_INIT",
-          mapName,
-          lastSyncTimestamp: this.lastSyncTimestamp
-        });
-      } else if (map instanceof ORMap) {
-        logger.info({ mapName }, "Starting Merkle sync for ORMap");
-        const tree = map.getMerkleTree();
-        const rootHash = tree.getRootHash();
-        const bucketHashes = tree.getBuckets("");
-        this.sendMessage({
-          type: "ORMAP_SYNC_INIT",
-          mapName,
-          rootHash,
-          bucketHashes,
-          lastSyncTimestamp: this.lastSyncTimestamp
-        });
-      }
-    }
+  /**
+   * Get current backoff attempt count.
+   */
+  getBackoffAttempt() {
+    return this.backoffAttempt;
   }
-  setAuthToken(token) {
-    this.authToken = token;
-    this.tokenProvider = null;
-    const state = this.stateMachine.getState();
-    if (state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "CONNECTING" /* CONNECTING */) {
-      this.sendAuth();
-    } else if (state === "BACKOFF" /* BACKOFF */ || state === "DISCONNECTED" /* DISCONNECTED */) {
-      logger.info("Auth token set during backoff/disconnect. Reconnecting immediately.");
-      if (this.reconnectTimer) {
-        clearTimeout(this.reconnectTimer);
-        this.reconnectTimer = null;
-      }
-      this.resetBackoff();
-      this.initConnection();
+  /**
+   * Clear reconnect timer (for external control, e.g., when new auth token provided).
+   */
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
     }
   }
-  setTokenProvider(provider) {
-    this.tokenProvider = provider;
-    const state = this.stateMachine.getState();
-    if (state === "AUTHENTICATING" /* AUTHENTICATING */) {
-      this.sendAuth();
-    }
+  // ============================================
+  // Heartbeat Mechanism
+  // ============================================
+  /**
+   * Starts the heartbeat mechanism after successful connection.
+   */
+  startHeartbeat() {
+    if (!this.config.heartbeatConfig.enabled) {
+      return;
+    }
+    this.stopHeartbeat();
+    this.lastPongReceived = Date.now();
+    this.heartbeatInterval = setInterval(() => {
+      this.sendPing();
+      this.checkHeartbeatTimeout();
+    }, this.config.heartbeatConfig.intervalMs);
+    logger.info({ intervalMs: this.config.heartbeatConfig.intervalMs }, "Heartbeat started");
+  }
+  /**
+   * Stops the heartbeat mechanism.
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+      logger.info("Heartbeat stopped");
+    }
+  }
+  /**
+   * Sends a PING message to the server.
+   */
+  sendPing() {
+    if (this.canSend()) {
+      const pingMessage = {
+        type: "PING",
+        timestamp: Date.now()
+      };
+      this.sendMessage(pingMessage);
+    }
+  }
+  /**
+   * Handles incoming PONG message from server.
+   */
+  handlePong(msg) {
+    const now = Date.now();
+    this.lastPongReceived = now;
+    this.lastRoundTripTime = now - msg.timestamp;
+    logger.debug({
+      rtt: this.lastRoundTripTime,
+      serverTime: msg.serverTime,
+      clockSkew: msg.serverTime - (msg.timestamp + this.lastRoundTripTime / 2)
+    }, "Received PONG");
+  }
+  /**
+   * Checks if heartbeat has timed out and triggers reconnection if needed.
+   */
+  checkHeartbeatTimeout() {
+    const now = Date.now();
+    const timeSinceLastPong = now - this.lastPongReceived;
+    if (timeSinceLastPong > this.config.heartbeatConfig.timeoutMs) {
+      logger.warn({
+        timeSinceLastPong,
+        timeoutMs: this.config.heartbeatConfig.timeoutMs
+      }, "Heartbeat timeout - triggering reconnection");
+      this.stopHeartbeat();
+      this.connectionProvider.close().catch((err) => {
+        logger.error({ err }, "Error closing ConnectionProvider on heartbeat timeout");
+      });
+    }
+  }
+  /**
+   * Returns the last measured round-trip time in milliseconds.
+   */
+  getLastRoundTripTime() {
+    return this.lastRoundTripTime;
+  }
+  /**
+   * Returns true if the connection is considered healthy based on heartbeat.
+   */
+  isConnectionHealthy() {
+    const state = this.config.stateMachine.getState();
+    const isOnline = state === "CONNECTING" /* CONNECTING */ || state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+    const isAuthenticated = state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+    if (!isOnline || !isAuthenticated) {
+      return false;
+    }
+    if (!this.config.heartbeatConfig.enabled) {
+      return true;
+    }
+    const timeSinceLastPong = Date.now() - this.lastPongReceived;
+    return timeSinceLastPong < this.config.heartbeatConfig.timeoutMs;
+  }
+};
+
+// src/errors/BackpressureError.ts
+var BackpressureError = class _BackpressureError extends Error {
+  constructor(pendingCount, maxPending) {
+    super(
+      `Backpressure limit reached: ${pendingCount}/${maxPending} pending operations. Wait for acknowledgments or increase maxPendingOps.`
+    );
+    this.pendingCount = pendingCount;
+    this.maxPending = maxPending;
+    this.name = "BackpressureError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _BackpressureError);
+    }
+  }
+};
+
+// src/sync/BackpressureController.ts
+var BackpressureController = class {
+  constructor(controllerConfig) {
+    // Internal state
+    this.backpressurePaused = false;
+    this.waitingForCapacity = [];
+    this.highWaterMarkEmitted = false;
+    this.backpressureListeners = /* @__PURE__ */ new Map();
+    this.config = controllerConfig.config;
+    this.opLog = controllerConfig.opLog;
+  }
+  // ============================================
+  // Status Methods
+  // ============================================
+  /**
+   * Get the current number of pending (unsynced) operations.
+   */
+  getPendingOpsCount() {
+    return this.opLog.filter((op) => !op.synced).length;
+  }
+  /**
+   * Get the current backpressure status.
+   */
+  getBackpressureStatus() {
+    const pending = this.getPendingOpsCount();
+    const max = this.config.maxPendingOps;
+    return {
+      pending,
+      max,
+      percentage: max > 0 ? pending / max : 0,
+      isPaused: this.backpressurePaused,
+      strategy: this.config.strategy
+    };
+  }
+  /**
+   * Returns true if writes are currently paused due to backpressure.
+   */
+  isBackpressurePaused() {
+    return this.backpressurePaused;
+  }
+  // ============================================
+  // Check Methods
+  // ============================================
+  /**
+   * Check backpressure before adding a new operation.
+   * May pause, throw, or drop depending on strategy.
+   */
+  async checkBackpressure() {
+    const pendingCount = this.getPendingOpsCount();
+    if (pendingCount < this.config.maxPendingOps) {
+      return;
+    }
+    switch (this.config.strategy) {
+      case "pause":
+        await this.waitForCapacity();
+        break;
+      case "throw":
+        throw new BackpressureError(
+          pendingCount,
+          this.config.maxPendingOps
+        );
+      case "drop-oldest":
+        this.dropOldestOp();
+        break;
+    }
+  }
+  /**
+   * Check high water mark and emit event if threshold reached.
+   */
+  checkHighWaterMark() {
+    const pendingCount = this.getPendingOpsCount();
+    const threshold = Math.floor(
+      this.config.maxPendingOps * this.config.highWaterMark
+    );
+    if (pendingCount >= threshold && !this.highWaterMarkEmitted) {
+      this.highWaterMarkEmitted = true;
+      logger.warn(
+        { pending: pendingCount, max: this.config.maxPendingOps },
+        "Backpressure high water mark reached"
+      );
+      this.emitBackpressureEvent("backpressure:high", {
+        pending: pendingCount,
+        max: this.config.maxPendingOps
+      });
+    }
+  }
+  /**
+   * Check low water mark and resume paused writes if threshold reached.
+   */
+  checkLowWaterMark() {
+    const pendingCount = this.getPendingOpsCount();
+    const lowThreshold = Math.floor(
+      this.config.maxPendingOps * this.config.lowWaterMark
+    );
+    const highThreshold = Math.floor(
+      this.config.maxPendingOps * this.config.highWaterMark
+    );
+    if (pendingCount < highThreshold && this.highWaterMarkEmitted) {
+      this.highWaterMarkEmitted = false;
+    }
+    if (pendingCount <= lowThreshold) {
+      if (this.backpressurePaused) {
+        this.backpressurePaused = false;
+        logger.info(
+          { pending: pendingCount, max: this.config.maxPendingOps },
+          "Backpressure low water mark reached, resuming writes"
+        );
+        this.emitBackpressureEvent("backpressure:low", {
+          pending: pendingCount,
+          max: this.config.maxPendingOps
+        });
+        this.emitBackpressureEvent("backpressure:resumed");
+        const waiting = this.waitingForCapacity;
+        this.waitingForCapacity = [];
+        for (const resolve of waiting) {
+          resolve();
+        }
+      }
+    }
+  }
+  // ============================================
+  // Event Methods
+  // ============================================
+  /**
+   * Subscribe to backpressure events.
+   * @param event Event name: 'backpressure:high', 'backpressure:low', 'backpressure:paused', 'backpressure:resumed', 'operation:dropped'
+   * @param listener Callback function
+   * @returns Unsubscribe function
+   */
+  onBackpressure(event, listener) {
+    if (!this.backpressureListeners.has(event)) {
+      this.backpressureListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.backpressureListeners.get(event).add(listener);
+    return () => {
+      this.backpressureListeners.get(event)?.delete(listener);
+    };
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  /**
+   * Emit a backpressure event to all listeners.
+   */
+  emitBackpressureEvent(event, data) {
+    const listeners = this.backpressureListeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(data);
+        } catch (err) {
+          logger.error({ err, event }, "Error in backpressure event listener");
+        }
+      }
+    }
+  }
+  /**
+   * Wait for capacity to become available (used by 'pause' strategy).
+   */
+  async waitForCapacity() {
+    if (!this.backpressurePaused) {
+      this.backpressurePaused = true;
+      logger.warn("Backpressure paused - waiting for capacity");
+      this.emitBackpressureEvent("backpressure:paused");
+    }
+    return new Promise((resolve) => {
+      this.waitingForCapacity.push(resolve);
+    });
+  }
+  /**
+   * Drop the oldest pending operation (used by 'drop-oldest' strategy).
+   * Modifies opLog via shared reference.
+   */
+  dropOldestOp() {
+    const oldestIndex = this.opLog.findIndex((op) => !op.synced);
+    if (oldestIndex !== -1) {
+      const dropped = this.opLog[oldestIndex];
+      this.opLog.splice(oldestIndex, 1);
+      logger.warn(
+        { opId: dropped.id, mapName: dropped.mapName, key: dropped.key },
+        "Dropped oldest pending operation due to backpressure"
+      );
+      this.emitBackpressureEvent("operation:dropped", {
+        opId: dropped.id,
+        mapName: dropped.mapName,
+        opType: dropped.opType,
+        key: dropped.key
+      });
+    }
+  }
+};
+
+// src/sync/QueryManager.ts
+import { evaluatePredicate } from "@topgunbuild/core";
+var QueryManager = class {
+  constructor(config) {
+    /** Standard queries (single source of truth) */
+    this.queries = /* @__PURE__ */ new Map();
+    /** Hybrid queries with FTS support (single source of truth) */
+    this.hybridQueries = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  // ============================================
+  // Query Access Methods
+  // ============================================
+  /**
+   * Get all queries (read-only access).
+   */
+  getQueries() {
+    return this.queries;
+  }
+  /**
+   * Get all hybrid queries.
+   */
+  getHybridQueries() {
+    return this.hybridQueries;
+  }
+  /**
+   * Get a hybrid query by ID.
+   */
+  getHybridQuery(queryId) {
+    return this.hybridQueries.get(queryId);
+  }
+  // ============================================
+  // Standard Query Methods
+  // ============================================
+  /**
+   * Subscribe to a standard query.
+   * Adds to queries Map and sends subscription to server if authenticated.
+   */
+  subscribeToQuery(query) {
+    this.queries.set(query.id, query);
+    if (this.config.isAuthenticated()) {
+      this.sendQuerySubscription(query);
+    }
+  }
+  /**
+   * Unsubscribe from a query.
+   * Removes from Map and sends unsubscription to server if authenticated.
+   */
+  unsubscribeFromQuery(queryId) {
+    this.queries.delete(queryId);
+    if (this.config.isAuthenticated()) {
+      this.config.sendMessage({
+        type: "QUERY_UNSUB",
+        payload: { queryId }
+      });
+    }
+  }
+  /**
+   * Send query subscription message to server.
+   */
+  sendQuerySubscription(query) {
+    this.config.sendMessage({
+      type: "QUERY_SUB",
+      payload: {
+        queryId: query.id,
+        mapName: query.getMapName(),
+        query: query.getFilter()
+      }
+    });
+  }
+  // ============================================
+  // Hybrid Query Methods
+  // ============================================
+  /**
+   * Subscribe to a hybrid query (FTS + filter combination).
+   */
+  subscribeToHybridQuery(query) {
+    this.hybridQueries.set(query.id, query);
+    const filter = query.getFilter();
+    const mapName = query.getMapName();
+    if (query.hasFTSPredicate() && this.config.isAuthenticated()) {
+      this.sendHybridQuerySubscription(query.id, mapName, filter);
+    }
+    this.runLocalHybridQuery(mapName, filter).then((results) => {
+      query.onResult(results, "local");
+    });
+  }
+  /**
+   * Unsubscribe from a hybrid query.
+   */
+  unsubscribeFromHybridQuery(queryId) {
+    const query = this.hybridQueries.get(queryId);
+    if (query) {
+      this.hybridQueries.delete(queryId);
+      if (this.config.isAuthenticated() && query.hasFTSPredicate()) {
+        this.config.sendMessage({
+          type: "HYBRID_QUERY_UNSUBSCRIBE",
+          payload: { subscriptionId: queryId }
+        });
+      }
+    }
+  }
+  /**
+   * Send hybrid query subscription message to server.
+   */
+  sendHybridQuerySubscription(queryId, mapName, filter) {
+    this.config.sendMessage({
+      type: "HYBRID_QUERY_SUBSCRIBE",
+      payload: {
+        subscriptionId: queryId,
+        mapName,
+        predicate: filter.predicate,
+        where: filter.where,
+        sort: filter.sort,
+        limit: filter.limit,
+        cursor: filter.cursor
+      }
+    });
+  }
+  // ============================================
+  // Local Query Execution
+  // ============================================
+  /**
+   * Executes a query against local storage immediately.
+   */
+  async runLocalQuery(mapName, filter) {
+    const keys = await this.config.storageAdapter.getAllKeys();
+    const mapKeys = keys.filter((k) => k.startsWith(mapName + ":"));
+    const results = [];
+    for (const fullKey of mapKeys) {
+      const record = await this.config.storageAdapter.get(fullKey);
+      if (record && record.value) {
+        const actualKey = fullKey.slice(mapName.length + 1);
+        let matches = true;
+        if (filter.where) {
+          for (const [k, v] of Object.entries(filter.where)) {
+            if (record.value[k] !== v) {
+              matches = false;
+              break;
+            }
+          }
+        }
+        if (matches && filter.predicate) {
+          if (!evaluatePredicate(filter.predicate, record.value)) {
+            matches = false;
+          }
+        }
+        if (matches) {
+          results.push({ key: actualKey, value: record.value });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Run a local hybrid query (FTS + filter combination).
+   * For FTS predicates, returns results with score = 0 (local-only mode).
+   * Server provides actual FTS scoring.
+   */
+  async runLocalHybridQuery(mapName, filter) {
+    const results = [];
+    const allKeys = await this.config.storageAdapter.getAllKeys();
+    const mapPrefix = `${mapName}:`;
+    const entries = [];
+    for (const fullKey of allKeys) {
+      if (fullKey.startsWith(mapPrefix)) {
+        const key = fullKey.substring(mapPrefix.length);
+        const record = await this.config.storageAdapter.get(fullKey);
+        if (record) {
+          entries.push([key, record]);
+        }
+      }
+    }
+    for (const [key, record] of entries) {
+      if (record === null || record.value === null) continue;
+      const value = record.value;
+      if (filter.predicate) {
+        const matches = evaluatePredicate(filter.predicate, value);
+        if (!matches) continue;
+      }
+      if (filter.where) {
+        let whereMatches = true;
+        for (const [field, expected] of Object.entries(filter.where)) {
+          if (value[field] !== expected) {
+            whereMatches = false;
+            break;
+          }
+        }
+        if (!whereMatches) continue;
+      }
+      results.push({
+        key,
+        value,
+        score: 0,
+        // Local doesn't have FTS scoring
+        matchedTerms: []
+      });
+    }
+    if (filter.sort) {
+      results.sort((a, b) => {
+        for (const [field, direction] of Object.entries(filter.sort)) {
+          let valA;
+          let valB;
+          if (field === "_score") {
+            valA = a.score ?? 0;
+            valB = b.score ?? 0;
+          } else if (field === "_key") {
+            valA = a.key;
+            valB = b.key;
+          } else {
+            valA = a.value[field];
+            valB = b.value[field];
+          }
+          if (valA < valB) return direction === "asc" ? -1 : 1;
+          if (valA > valB) return direction === "asc" ? 1 : -1;
+        }
+        return 0;
+      });
+    }
+    let sliced = results;
+    if (filter.limit) {
+      sliced = sliced.slice(0, filter.limit);
+    }
+    return sliced;
+  }
+  // ============================================
+  // Re-subscription (after auth)
+  // ============================================
+  /**
+   * Re-subscribe all queries after authentication.
+   * Called by SyncEngine after AUTH_ACK.
+   */
+  resubscribeAll() {
+    logger.debug({ queryCount: this.queries.size, hybridCount: this.hybridQueries.size }, "QueryManager: resubscribing all queries");
+    for (const query of this.queries.values()) {
+      this.sendQuerySubscription(query);
+    }
+    for (const query of this.hybridQueries.values()) {
+      if (query.hasFTSPredicate()) {
+        this.sendHybridQuerySubscription(query.id, query.getMapName(), query.getFilter());
+      }
+    }
+  }
+};
+
+// src/sync/TopicManager.ts
+var TopicManager = class {
+  constructor(config) {
+    // Topic subscriptions (single source of truth)
+    this.topics = /* @__PURE__ */ new Map();
+    // Offline message queue
+    this.topicQueue = [];
+    this.config = config;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Subscribe to a topic.
+   * Adds to topics Map and sends subscription to server if authenticated.
+   */
+  subscribeToTopic(topic, handle) {
+    this.topics.set(topic, handle);
+    if (this.config.isAuthenticated()) {
+      this.sendTopicSubscription(topic);
+    }
+  }
+  /**
+   * Unsubscribe from a topic.
+   * Removes from Map and sends unsubscription to server if authenticated.
+   */
+  unsubscribeFromTopic(topic) {
+    this.topics.delete(topic);
+    if (this.config.isAuthenticated()) {
+      this.config.sendMessage({
+        type: "TOPIC_UNSUB",
+        payload: { topic }
+      });
+    }
+  }
+  /**
+   * Publish a message to a topic.
+   * Sends immediately if authenticated, otherwise queues for later.
+   */
+  publishTopic(topic, data) {
+    if (this.config.isAuthenticated()) {
+      this.config.sendMessage({
+        type: "TOPIC_PUB",
+        payload: { topic, data }
+      });
+    } else {
+      this.queueTopicMessage(topic, data);
+    }
+  }
+  /**
+   * Flush all queued topic messages.
+   * Called by SyncEngine after authentication.
+   */
+  flushTopicQueue() {
+    if (this.topicQueue.length === 0) return;
+    logger.info({ count: this.topicQueue.length }, "Flushing queued topic messages");
+    for (const msg of this.topicQueue) {
+      this.config.sendMessage({
+        type: "TOPIC_PUB",
+        payload: { topic: msg.topic, data: msg.data }
+      });
+    }
+    this.topicQueue = [];
+  }
+  /**
+   * Get topic queue status.
+   */
+  getTopicQueueStatus() {
+    return {
+      size: this.topicQueue.length,
+      maxSize: this.config.topicQueueConfig.maxSize
+    };
+  }
+  /**
+   * Get all subscribed topics.
+   * Used for resubscription after authentication.
+   */
+  getTopics() {
+    return this.topics.keys();
+  }
+  /**
+   * Re-subscribe all topics after authentication.
+   * Called by SyncEngine after AUTH_ACK.
+   */
+  resubscribeAll() {
+    for (const topic of this.topics.keys()) {
+      this.sendTopicSubscription(topic);
+    }
+  }
+  /**
+   * Handle incoming topic message from server.
+   */
+  handleTopicMessage(topic, data, publisherId, timestamp) {
+    const handle = this.topics.get(topic);
+    if (handle) {
+      handle.onMessage(data, { publisherId, timestamp });
+    }
+  }
+  // ============================================
+  // Private Methods
+  // ============================================
+  /**
+   * Queue a topic message for offline publishing.
+   */
+  queueTopicMessage(topic, data) {
+    const message = {
+      topic,
+      data,
+      timestamp: Date.now()
+    };
+    if (this.topicQueue.length >= this.config.topicQueueConfig.maxSize) {
+      if (this.config.topicQueueConfig.strategy === "drop-oldest") {
+        const dropped = this.topicQueue.shift();
+        logger.warn({ topic: dropped?.topic }, "Dropped oldest queued topic message (queue full)");
+      } else {
+        logger.warn({ topic }, "Dropped newest topic message (queue full)");
+        return;
+      }
+    }
+    this.topicQueue.push(message);
+    logger.debug({ topic, queueSize: this.topicQueue.length }, "Queued topic message for offline");
+  }
+  /**
+   * Send topic subscription message to server.
+   */
+  sendTopicSubscription(topic) {
+    this.config.sendMessage({
+      type: "TOPIC_SUB",
+      payload: { topic }
+    });
+  }
+};
+
+// src/sync/LockManager.ts
+var LockManager = class {
+  constructor(config) {
+    // Pending lock requests (single source of truth)
+    this.pendingLockRequests = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Request a distributed lock.
+   */
+  requestLock(name, requestId, ttl) {
+    if (!this.config.isAuthenticated()) {
+      return Promise.reject(new Error("Not connected or authenticated"));
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pendingLockRequests.has(requestId)) {
+          this.pendingLockRequests.delete(requestId);
+          reject(new Error("Lock request timed out waiting for server response"));
+        }
+      }, 3e4);
+      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
+      try {
+        const sent = this.config.sendMessage({
+          type: "LOCK_REQUEST",
+          payload: { requestId, name, ttl }
+        });
+        if (!sent) {
+          clearTimeout(timer);
+          this.pendingLockRequests.delete(requestId);
+          reject(new Error("Failed to send lock request"));
+        }
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingLockRequests.delete(requestId);
+        reject(e);
+      }
+    });
+  }
+  /**
+   * Release a distributed lock.
+   */
+  releaseLock(name, requestId, fencingToken) {
+    if (!this.config.isOnline()) return Promise.resolve(false);
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pendingLockRequests.has(requestId)) {
+          this.pendingLockRequests.delete(requestId);
+          resolve(false);
+        }
+      }, 5e3);
+      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
+      try {
+        const sent = this.config.sendMessage({
+          type: "LOCK_RELEASE",
+          payload: { requestId, name, fencingToken }
+        });
+        if (!sent) {
+          clearTimeout(timer);
+          this.pendingLockRequests.delete(requestId);
+          resolve(false);
+        }
+      } catch (e) {
+        clearTimeout(timer);
+        this.pendingLockRequests.delete(requestId);
+        resolve(false);
+      }
+    });
+  }
+  /**
+   * Handle lock granted message from server.
+   */
+  handleLockGranted(requestId, fencingToken) {
+    const req = this.pendingLockRequests.get(requestId);
+    if (req) {
+      clearTimeout(req.timer);
+      this.pendingLockRequests.delete(requestId);
+      req.resolve({ fencingToken });
+    }
+  }
+  /**
+   * Handle lock released message from server.
+   */
+  handleLockReleased(requestId, success) {
+    const req = this.pendingLockRequests.get(requestId);
+    if (req) {
+      clearTimeout(req.timer);
+      this.pendingLockRequests.delete(requestId);
+      req.resolve(success);
+    }
+  }
+};
+
+// src/sync/WriteConcernManager.ts
+var WriteConcernManager = class {
+  constructor(config) {
+    // Pending write concern promises (single source of truth)
+    this.pendingWriteConcernPromises = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Register a pending Write Concern promise for an operation.
+   * The promise will be resolved when the server sends an ACK with the operation result.
+   *
+   * @param opId - Operation ID
+   * @param timeout - Timeout in ms (default: 5000)
+   * @returns Promise that resolves with the Write Concern result
+   */
+  registerWriteConcernPromise(opId, timeout = 5e3) {
+    const actualTimeout = timeout ?? this.config.defaultTimeout ?? 5e3;
+    return new Promise((resolve, reject) => {
+      const timeoutHandle = setTimeout(() => {
+        this.pendingWriteConcernPromises.delete(opId);
+        reject(new Error(`Write Concern timeout for operation ${opId}`));
+      }, actualTimeout);
+      this.pendingWriteConcernPromises.set(opId, {
+        resolve,
+        reject,
+        timeoutHandle
+      });
+    });
+  }
+  /**
+   * Resolve a pending Write Concern promise with the server result.
+   *
+   * @param opId - Operation ID
+   * @param result - Result from server ACK
+   */
+  resolveWriteConcernPromise(opId, result) {
+    const pending = this.pendingWriteConcernPromises.get(opId);
+    if (pending) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
+      }
+      pending.resolve(result);
+      this.pendingWriteConcernPromises.delete(opId);
+    }
+  }
+  /**
+   * Cancel all pending Write Concern promises (e.g., on disconnect).
+   */
+  cancelAllWriteConcernPromises(error) {
+    for (const [opId, pending] of this.pendingWriteConcernPromises.entries()) {
+      if (pending.timeoutHandle) {
+        clearTimeout(pending.timeoutHandle);
+      }
+      pending.reject(error);
+    }
+    this.pendingWriteConcernPromises.clear();
+  }
+};
+
+// src/sync/CounterManager.ts
+var CounterManager = class {
+  constructor(config) {
+    // Counter update listeners by name
+    this.counterUpdateListeners = /* @__PURE__ */ new Map();
+    this.config = config;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Subscribe to counter updates from server.
+   * @param name Counter name
+   * @param listener Callback when counter state is updated
+   * @returns Unsubscribe function
+   */
+  onCounterUpdate(name, listener) {
+    if (!this.counterUpdateListeners.has(name)) {
+      this.counterUpdateListeners.set(name, /* @__PURE__ */ new Set());
+    }
+    this.counterUpdateListeners.get(name).add(listener);
+    return () => {
+      this.counterUpdateListeners.get(name)?.delete(listener);
+      if (this.counterUpdateListeners.get(name)?.size === 0) {
+        this.counterUpdateListeners.delete(name);
+      }
+    };
+  }
+  /**
+   * Request initial counter state from server.
+   * @param name Counter name
+   */
+  requestCounter(name) {
+    if (this.config.isAuthenticated()) {
+      this.config.sendMessage({
+        type: "COUNTER_REQUEST",
+        payload: { name }
+      });
+    }
+  }
+  /**
+   * Sync local counter state to server.
+   * @param name Counter name
+   * @param state Counter state to sync
+   */
+  syncCounter(name, state) {
+    if (this.config.isAuthenticated()) {
+      const stateObj = {
+        positive: Object.fromEntries(state.positive),
+        negative: Object.fromEntries(state.negative)
+      };
+      this.config.sendMessage({
+        type: "COUNTER_SYNC",
+        payload: {
+          name,
+          state: stateObj
+        }
+      });
+    }
+  }
+  /**
+   * Handle incoming counter update from server.
+   * Called by SyncEngine for COUNTER_UPDATE and COUNTER_RESPONSE messages.
+   */
+  handleCounterUpdate(name, stateObj) {
+    const state = {
+      positive: new Map(Object.entries(stateObj.positive)),
+      negative: new Map(Object.entries(stateObj.negative))
+    };
+    const listeners = this.counterUpdateListeners.get(name);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(state);
+        } catch (e) {
+          logger.error({ err: e, counterName: name }, "Counter update listener error");
+        }
+      }
+    }
+  }
+  /**
+   * Clean up resources.
+   * Clears all counter update listeners.
+   */
+  close() {
+    this.counterUpdateListeners.clear();
+  }
+};
+
+// src/sync/EntryProcessorClient.ts
+var DEFAULT_PROCESSOR_TIMEOUT = 3e4;
+var EntryProcessorClient = class {
+  constructor(config) {
+    // Pending entry processor requests by requestId
+    this.pendingProcessorRequests = /* @__PURE__ */ new Map();
+    // Pending batch entry processor requests by requestId
+    this.pendingBatchProcessorRequests = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_PROCESSOR_TIMEOUT;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Execute an entry processor on a single key atomically.
+   *
+   * @param mapName Name of the map
+   * @param key Key to process
+   * @param processor Processor definition
+   * @returns Promise resolving to the processor result
+   */
+  async executeOnKey(mapName, key, processor) {
+    if (!this.config.isAuthenticated()) {
+      return {
+        success: false,
+        error: "Not connected to server"
+      };
+    }
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingProcessorRequests.delete(requestId);
+        reject(new Error("Entry processor request timed out"));
+      }, this.timeoutMs);
+      this.pendingProcessorRequests.set(requestId, {
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve(result);
+        },
+        reject,
+        timeout
+      });
+      const sent = this.config.sendMessage({
+        type: "ENTRY_PROCESS",
+        requestId,
+        mapName,
+        key,
+        processor: {
+          name: processor.name,
+          code: processor.code,
+          args: processor.args
+        }
+      }, key);
+      if (!sent) {
+        this.pendingProcessorRequests.delete(requestId);
+        clearTimeout(timeout);
+        reject(new Error("Failed to send entry processor request"));
+      }
+    });
+  }
+  /**
+   * Execute an entry processor on multiple keys.
+   *
+   * @param mapName Name of the map
+   * @param keys Keys to process
+   * @param processor Processor definition
+   * @returns Promise resolving to a map of key -> result
+   */
+  async executeOnKeys(mapName, keys, processor) {
+    if (!this.config.isAuthenticated()) {
+      const results = /* @__PURE__ */ new Map();
+      const error = {
+        success: false,
+        error: "Not connected to server"
+      };
+      for (const key of keys) {
+        results.set(key, error);
+      }
+      return results;
+    }
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingBatchProcessorRequests.delete(requestId);
+        reject(new Error("Entry processor batch request timed out"));
+      }, this.timeoutMs);
+      this.pendingBatchProcessorRequests.set(requestId, {
+        resolve: (results) => {
+          clearTimeout(timeout);
+          resolve(results);
+        },
+        reject,
+        timeout
+      });
+      const sent = this.config.sendMessage({
+        type: "ENTRY_PROCESS_BATCH",
+        requestId,
+        mapName,
+        keys,
+        processor: {
+          name: processor.name,
+          code: processor.code,
+          args: processor.args
+        }
+      });
+      if (!sent) {
+        this.pendingBatchProcessorRequests.delete(requestId);
+        clearTimeout(timeout);
+        reject(new Error("Failed to send entry processor batch request"));
+      }
+    });
+  }
+  /**
+   * Handle entry processor response from server.
+   * Called by SyncEngine for ENTRY_PROCESS_RESPONSE messages.
+   */
+  handleEntryProcessResponse(message) {
+    const pending = this.pendingProcessorRequests.get(message.requestId);
+    if (pending) {
+      this.pendingProcessorRequests.delete(message.requestId);
+      pending.resolve({
+        success: message.success,
+        result: message.result,
+        newValue: message.newValue,
+        error: message.error
+      });
+    }
+  }
+  /**
+   * Handle entry processor batch response from server.
+   * Called by SyncEngine for ENTRY_PROCESS_BATCH_RESPONSE messages.
+   */
+  handleEntryProcessBatchResponse(message) {
+    const pending = this.pendingBatchProcessorRequests.get(message.requestId);
+    if (pending) {
+      this.pendingBatchProcessorRequests.delete(message.requestId);
+      const resultsMap = /* @__PURE__ */ new Map();
+      for (const [key, result] of Object.entries(message.results)) {
+        resultsMap.set(key, {
+          success: result.success,
+          result: result.result,
+          newValue: result.newValue,
+          error: result.error
+        });
+      }
+      pending.resolve(resultsMap);
+    }
+  }
+  /**
+   * Clean up resources.
+   * Clears pending timeouts without rejecting promises to match original SyncEngine behavior.
+   * Note: This may leave promises hanging, but maintains backward compatibility with tests.
+   */
+  close(error) {
+    for (const [requestId, pending] of this.pendingProcessorRequests.entries()) {
+      clearTimeout(pending.timeout);
+    }
+    this.pendingProcessorRequests.clear();
+    for (const [requestId, pending] of this.pendingBatchProcessorRequests.entries()) {
+      clearTimeout(pending.timeout);
+    }
+    this.pendingBatchProcessorRequests.clear();
+  }
+};
+
+// src/sync/SearchClient.ts
+var DEFAULT_SEARCH_TIMEOUT = 3e4;
+var SearchClient = class {
+  constructor(config) {
+    // Pending search requests by requestId
+    this.pendingSearchRequests = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.timeoutMs = config.timeoutMs ?? DEFAULT_SEARCH_TIMEOUT;
+  }
+  // ============================================
+  // Public API
+  // ============================================
+  /**
+   * Perform a one-shot BM25 search on the server.
+   *
+   * @param mapName Name of the map to search
+   * @param query Search query text
+   * @param options Search options (limit, minScore, boost)
+   * @returns Promise resolving to search results
+   */
+  async search(mapName, query, options) {
+    if (!this.config.isAuthenticated()) {
+      throw new Error("Not connected to server");
+    }
+    const requestId = crypto.randomUUID();
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingSearchRequests.delete(requestId);
+        reject(new Error("Search request timed out"));
+      }, this.timeoutMs);
+      this.pendingSearchRequests.set(requestId, {
+        resolve: (results) => {
+          clearTimeout(timeout);
+          resolve(results);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        },
+        timeout
+      });
+      const sent = this.config.sendMessage({
+        type: "SEARCH",
+        payload: {
+          requestId,
+          mapName,
+          query,
+          options
+        }
+      });
+      if (!sent) {
+        this.pendingSearchRequests.delete(requestId);
+        clearTimeout(timeout);
+        reject(new Error("Failed to send search request"));
+      }
+    });
+  }
+  /**
+   * Handle search response from server.
+   * Called by SyncEngine for SEARCH_RESP messages.
+   */
+  handleSearchResponse(payload) {
+    const pending = this.pendingSearchRequests.get(payload.requestId);
+    if (pending) {
+      this.pendingSearchRequests.delete(payload.requestId);
+      if (payload.error) {
+        pending.reject(new Error(payload.error));
+      } else {
+        pending.resolve(payload.results);
+      }
+    }
+  }
+  /**
+   * Clean up resources.
+   * Clears pending timeouts without rejecting promises to match original SyncEngine behavior.
+   * Note: This may leave promises hanging, but maintains backward compatibility with tests.
+   */
+  close(error) {
+    for (const [requestId, pending] of this.pendingSearchRequests.entries()) {
+      clearTimeout(pending.timeout);
+    }
+    this.pendingSearchRequests.clear();
+  }
+};
+
+// src/sync/MerkleSyncHandler.ts
+import { LWWMap } from "@topgunbuild/core";
+var MerkleSyncHandler = class {
+  constructor(config) {
+    this.lastSyncTimestamp = 0;
+    this.config = config;
+  }
+  /**
+   * Handle SYNC_RESET_REQUIRED message from server.
+   * Resets the map and triggers a fresh sync.
+   */
+  async handleSyncResetRequired(payload) {
+    const { mapName } = payload;
+    logger.warn({ mapName }, "Sync Reset Required due to GC Age");
+    await this.config.resetMap(mapName);
+    this.config.sendMessage({
+      type: "SYNC_INIT",
+      mapName,
+      lastSyncTimestamp: 0
+    });
+  }
+  /**
+   * Handle SYNC_RESP_ROOT message from server.
+   * Compares root hashes and requests buckets if mismatch detected.
+   */
+  async handleSyncRespRoot(payload) {
+    const { mapName, rootHash, timestamp } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof LWWMap) {
+      const localRootHash = map.getMerkleTree().getRootHash();
+      if (localRootHash !== rootHash) {
+        logger.info({ mapName, localRootHash, remoteRootHash: rootHash }, "Root hash mismatch, requesting buckets");
+        this.config.sendMessage({
+          type: "MERKLE_REQ_BUCKET",
+          payload: { mapName, path: "" }
+        });
+      } else {
+        logger.info({ mapName }, "Map is in sync");
+      }
+    }
+    if (timestamp) {
+      await this.config.onTimestampUpdate(timestamp);
+    }
+  }
+  /**
+   * Handle SYNC_RESP_BUCKETS message from server.
+   * Compares bucket hashes and requests mismatched buckets.
+   */
+  handleSyncRespBuckets(payload) {
+    const { mapName, path, buckets } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof LWWMap) {
+      const tree = map.getMerkleTree();
+      const localBuckets = tree.getBuckets(path);
+      for (const [bucketKey, remoteHash] of Object.entries(buckets)) {
+        const localHash = localBuckets[bucketKey] || 0;
+        if (localHash !== remoteHash) {
+          const newPath = path + bucketKey;
+          this.config.sendMessage({
+            type: "MERKLE_REQ_BUCKET",
+            payload: { mapName, path: newPath }
+          });
+        }
+      }
+    }
+  }
+  /**
+   * Handle SYNC_RESP_LEAF message from server.
+   * Merges leaf records into local map and persists to storage.
+   */
+  async handleSyncRespLeaf(payload) {
+    const { mapName, records } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof LWWMap) {
+      let updateCount = 0;
+      for (const { key, record } of records) {
+        const updated = map.merge(key, record);
+        if (updated) {
+          updateCount++;
+          await this.config.storageAdapter.put(`${mapName}:${key}`, record);
+        }
+      }
+      if (updateCount > 0) {
+        logger.info({ mapName, count: updateCount }, "Synced records from server");
+      }
+    }
+  }
+  /**
+   * Send SYNC_INIT message to server to start sync.
+   * Encapsulates sync init message construction.
+   */
+  sendSyncInit(mapName, lastSyncTimestamp) {
+    this.lastSyncTimestamp = lastSyncTimestamp;
+    logger.info({ mapName }, "Starting Merkle sync for LWWMap");
+    this.config.sendMessage({
+      type: "SYNC_INIT",
+      mapName,
+      lastSyncTimestamp
+    });
+  }
+  /**
+   * Get the last sync timestamp for debugging/testing.
+   */
+  getLastSyncTimestamp() {
+    return this.lastSyncTimestamp;
+  }
+};
+
+// src/sync/ORMapSyncHandler.ts
+import { ORMap } from "@topgunbuild/core";
+var ORMapSyncHandler = class {
+  constructor(config) {
+    this.lastSyncTimestamp = 0;
+    this.config = config;
+  }
+  /**
+   * Handle ORMAP_SYNC_RESP_ROOT message from server.
+   * Compares root hashes and requests buckets if mismatch detected.
+   */
+  async handleORMapSyncRespRoot(payload) {
+    const { mapName, rootHash, timestamp } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof ORMap) {
+      const localTree = map.getMerkleTree();
+      const localRootHash = localTree.getRootHash();
+      if (localRootHash !== rootHash) {
+        logger.info({ mapName, localRootHash, remoteRootHash: rootHash }, "ORMap root hash mismatch, requesting buckets");
+        this.config.sendMessage({
+          type: "ORMAP_MERKLE_REQ_BUCKET",
+          payload: { mapName, path: "" }
+        });
+      } else {
+        logger.info({ mapName }, "ORMap is in sync");
+      }
+    }
+    if (timestamp) {
+      await this.config.onTimestampUpdate(timestamp);
+    }
+  }
+  /**
+   * Handle ORMAP_SYNC_RESP_BUCKETS message from server.
+   * Compares bucket hashes and requests mismatched buckets.
+   * Also pushes local data that server doesn't have.
+   */
+  async handleORMapSyncRespBuckets(payload) {
+    const { mapName, path, buckets } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof ORMap) {
+      const tree = map.getMerkleTree();
+      const localBuckets = tree.getBuckets(path);
+      for (const [bucketKey, remoteHash] of Object.entries(buckets)) {
+        const localHash = localBuckets[bucketKey] || 0;
+        if (localHash !== remoteHash) {
+          const newPath = path + bucketKey;
+          this.config.sendMessage({
+            type: "ORMAP_MERKLE_REQ_BUCKET",
+            payload: { mapName, path: newPath }
+          });
+        }
+      }
+      for (const [bucketKey, localHash] of Object.entries(localBuckets)) {
+        if (!(bucketKey in buckets) && localHash !== 0) {
+          const newPath = path + bucketKey;
+          const keys = tree.getKeysInBucket(newPath);
+          if (keys.length > 0) {
+            await this.pushORMapDiff(mapName, keys, map);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Handle ORMAP_SYNC_RESP_LEAF message from server.
+   * Merges leaf entries into local map and pushes local diff back.
+   */
+  async handleORMapSyncRespLeaf(payload) {
+    const { mapName, entries } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof ORMap) {
+      let totalAdded = 0;
+      let totalUpdated = 0;
+      for (const entry of entries) {
+        const { key, records, tombstones } = entry;
+        const result = map.mergeKey(key, records, tombstones);
+        totalAdded += result.added;
+        totalUpdated += result.updated;
+      }
+      if (totalAdded > 0 || totalUpdated > 0) {
+        logger.info({ mapName, added: totalAdded, updated: totalUpdated }, "Synced ORMap records from server");
+      }
+      const keysToCheck = entries.map((e) => e.key);
+      await this.pushORMapDiff(mapName, keysToCheck, map);
+    }
+  }
+  /**
+   * Handle ORMAP_DIFF_RESPONSE message from server.
+   * Merges diff entries into local map.
+   */
+  async handleORMapDiffResponse(payload) {
+    const { mapName, entries } = payload;
+    const map = this.config.getMap(mapName);
+    if (map instanceof ORMap) {
+      let totalAdded = 0;
+      let totalUpdated = 0;
+      for (const entry of entries) {
+        const { key, records, tombstones } = entry;
+        const result = map.mergeKey(key, records, tombstones);
+        totalAdded += result.added;
+        totalUpdated += result.updated;
+      }
+      if (totalAdded > 0 || totalUpdated > 0) {
+        logger.info({ mapName, added: totalAdded, updated: totalUpdated }, "Merged ORMap diff from server");
+      }
+    }
+  }
+  /**
+   * Push local ORMap diff to server for the given keys.
+   * Sends local records and tombstones that the server might not have.
+   */
+  async pushORMapDiff(mapName, keys, map) {
+    const entries = [];
+    const snapshot = map.getSnapshot();
+    for (const key of keys) {
+      const recordsMap = map.getRecordsMap(key);
+      if (recordsMap && recordsMap.size > 0) {
+        const records = Array.from(recordsMap.values());
+        const tombstones = [];
+        for (const tag of snapshot.tombstones) {
+          tombstones.push(tag);
+        }
+        entries.push({
+          key,
+          records,
+          tombstones
+        });
+      }
+    }
+    if (entries.length > 0) {
+      this.config.sendMessage({
+        type: "ORMAP_PUSH_DIFF",
+        payload: {
+          mapName,
+          entries
+        }
+      });
+      logger.debug({ mapName, keyCount: entries.length }, "Pushed ORMap diff to server");
+    }
+  }
+  /**
+   * Send ORMAP_SYNC_INIT message to server to start sync.
+   * Encapsulates sync init message construction.
+   */
+  sendSyncInit(mapName, lastSyncTimestamp) {
+    this.lastSyncTimestamp = lastSyncTimestamp;
+    const map = this.config.getMap(mapName);
+    if (map instanceof ORMap) {
+      logger.info({ mapName }, "Starting Merkle sync for ORMap");
+      const tree = map.getMerkleTree();
+      const rootHash = tree.getRootHash();
+      const bucketHashes = tree.getBuckets("");
+      this.config.sendMessage({
+        type: "ORMAP_SYNC_INIT",
+        mapName,
+        rootHash,
+        bucketHashes,
+        lastSyncTimestamp
+      });
+    }
+  }
+  /**
+   * Get the last sync timestamp for debugging/testing.
+   */
+  getLastSyncTimestamp() {
+    return this.lastSyncTimestamp;
+  }
+};
+
+// src/sync/MessageRouter.ts
+var MessageRouter = class {
+  constructor(config = {}) {
+    this.handlers = config.handlers ? new Map(config.handlers) : /* @__PURE__ */ new Map();
+    this.onUnhandled = config.onUnhandled;
+  }
+  /**
+   * Register a handler for a message type.
+   * @param type - Message type to handle
+   * @param handler - Handler function
+   */
+  registerHandler(type, handler2) {
+    if (this.handlers.has(type)) {
+      logger.warn({ type }, "Overwriting existing handler for message type");
+    }
+    this.handlers.set(type, handler2);
+  }
+  /**
+   * Register multiple handlers at once.
+   * @param handlers - Record of type -> handler
+   */
+  registerHandlers(handlers) {
+    for (const [type, handler2] of Object.entries(handlers)) {
+      this.registerHandler(type, handler2);
+    }
+  }
+  /**
+   * Route a message to its registered handler.
+   * Returns true if handled, false if no handler found.
+   * @param message - Message to route
+   * @returns Promise resolving to true if handled
+   */
+  async route(message) {
+    const type = message?.type;
+    if (!type) {
+      logger.warn({ message }, "Cannot route message without type");
+      return false;
+    }
+    const handler2 = this.handlers.get(type);
+    if (!handler2) {
+      if (this.onUnhandled) {
+        this.onUnhandled(message);
+      }
+      return false;
+    }
+    try {
+      await handler2(message);
+      return true;
+    } catch (error) {
+      logger.error({ type, error }, "Error in message handler");
+      return true;
+    }
+  }
+  /**
+   * Check if a handler is registered for a message type.
+   * @param type - Message type to check
+   * @returns true if handler exists
+   */
+  hasHandler(type) {
+    return this.handlers.has(type);
+  }
+  /**
+   * Get the count of registered handlers.
+   * Useful for debugging/testing.
+   */
+  get handlerCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Get all registered message types.
+   * Useful for debugging/testing.
+   */
+  getRegisteredTypes() {
+    return Array.from(this.handlers.keys());
+  }
+};
+
+// src/sync/ClientMessageHandlers.ts
+function registerClientMessageHandlers(router, delegates, managers) {
+  router.registerHandlers({
+    // AUTH handlers
+    "AUTH_REQUIRED": () => delegates.sendAuth(),
+    "AUTH_ACK": () => delegates.handleAuthAck(),
+    "AUTH_FAIL": (msg) => delegates.handleAuthFail(msg),
+    // HEARTBEAT - handled by WebSocketManager, no-op here
+    "PONG": () => {
+    },
+    // SYNC handlers
+    "OP_ACK": (msg) => delegates.handleOpAck(msg),
+    "SYNC_RESP_ROOT": (msg) => managers.merkleSyncHandler.handleSyncRespRoot(msg.payload),
+    "SYNC_RESP_BUCKETS": (msg) => managers.merkleSyncHandler.handleSyncRespBuckets(msg.payload),
+    "SYNC_RESP_LEAF": (msg) => managers.merkleSyncHandler.handleSyncRespLeaf(msg.payload),
+    "SYNC_RESET_REQUIRED": (msg) => managers.merkleSyncHandler.handleSyncResetRequired(msg.payload),
+    // ORMAP SYNC handlers
+    "ORMAP_SYNC_RESP_ROOT": (msg) => managers.orMapSyncHandler.handleORMapSyncRespRoot(msg.payload),
+    "ORMAP_SYNC_RESP_BUCKETS": (msg) => managers.orMapSyncHandler.handleORMapSyncRespBuckets(msg.payload),
+    "ORMAP_SYNC_RESP_LEAF": (msg) => managers.orMapSyncHandler.handleORMapSyncRespLeaf(msg.payload),
+    "ORMAP_DIFF_RESPONSE": (msg) => managers.orMapSyncHandler.handleORMapDiffResponse(msg.payload),
+    // QUERY handlers
+    "QUERY_RESP": (msg) => delegates.handleQueryResp(msg),
+    "QUERY_UPDATE": (msg) => delegates.handleQueryUpdate(msg),
+    // EVENT handlers
+    "SERVER_EVENT": (msg) => delegates.handleServerEvent(msg),
+    "SERVER_BATCH_EVENT": (msg) => delegates.handleServerBatchEvent(msg),
+    // TOPIC handlers
+    "TOPIC_MESSAGE": (msg) => {
+      const { topic, data, publisherId, timestamp } = msg.payload;
+      managers.topicManager.handleTopicMessage(topic, data, publisherId, timestamp);
+    },
+    // LOCK handlers
+    "LOCK_GRANTED": (msg) => {
+      const { requestId, fencingToken } = msg.payload;
+      managers.lockManager.handleLockGranted(requestId, fencingToken);
+    },
+    "LOCK_RELEASED": (msg) => {
+      const { requestId, success } = msg.payload;
+      managers.lockManager.handleLockReleased(requestId, success);
+    },
+    // GC handler
+    "GC_PRUNE": (msg) => delegates.handleGcPrune(msg),
+    // COUNTER handlers
+    "COUNTER_UPDATE": (msg) => {
+      const { name, state } = msg.payload;
+      managers.counterManager.handleCounterUpdate(name, state);
+    },
+    "COUNTER_RESPONSE": (msg) => {
+      const { name, state } = msg.payload;
+      managers.counterManager.handleCounterUpdate(name, state);
+    },
+    // PROCESSOR handlers
+    "ENTRY_PROCESS_RESPONSE": (msg) => {
+      managers.entryProcessorClient.handleEntryProcessResponse(msg);
+    },
+    "ENTRY_PROCESS_BATCH_RESPONSE": (msg) => {
+      managers.entryProcessorClient.handleEntryProcessBatchResponse(msg);
+    },
+    // RESOLVER handlers
+    "REGISTER_RESOLVER_RESPONSE": (msg) => {
+      managers.conflictResolverClient.handleRegisterResponse(msg);
+    },
+    "UNREGISTER_RESOLVER_RESPONSE": (msg) => {
+      managers.conflictResolverClient.handleUnregisterResponse(msg);
+    },
+    "LIST_RESOLVERS_RESPONSE": (msg) => {
+      managers.conflictResolverClient.handleListResponse(msg);
+    },
+    "MERGE_REJECTED": (msg) => {
+      managers.conflictResolverClient.handleMergeRejected(msg);
+    },
+    // SEARCH handlers
+    "SEARCH_RESP": (msg) => {
+      managers.searchClient.handleSearchResponse(msg.payload);
+    },
+    "SEARCH_UPDATE": () => {
+    },
+    // HYBRID handlers
+    "HYBRID_QUERY_RESP": (msg) => delegates.handleHybridQueryResponse(msg.payload),
+    "HYBRID_QUERY_DELTA": (msg) => delegates.handleHybridQueryDelta(msg.payload)
+  });
+}
+
+// src/SyncEngine.ts
+var DEFAULT_TOPIC_QUEUE_CONFIG = {
+  maxSize: 100,
+  strategy: "drop-oldest"
+};
+var DEFAULT_BACKOFF_CONFIG = {
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  multiplier: 2,
+  jitter: true,
+  maxRetries: 10
+};
+var SyncEngine = class {
+  constructor(config) {
+    this.opLog = [];
+    this.maps = /* @__PURE__ */ new Map();
+    this.lastSyncTimestamp = 0;
+    this.authToken = null;
+    this.tokenProvider = null;
+    // ============================================
+    // Event Journal Methods
+    // ============================================
+    /** Message listeners for journal and other generic messages */
+    this.messageListeners = /* @__PURE__ */ new Set();
+    if (!config.connectionProvider) {
+      throw new Error("SyncEngine requires connectionProvider");
+    }
+    this.nodeId = config.nodeId;
+    this.storageAdapter = config.storageAdapter;
+    this.hlc = new HLC(this.nodeId);
+    this.stateMachine = new SyncStateMachine();
+    this.heartbeatConfig = {
+      intervalMs: config.heartbeat?.intervalMs ?? 5e3,
+      timeoutMs: config.heartbeat?.timeoutMs ?? 15e3,
+      enabled: config.heartbeat?.enabled ?? true
+    };
+    this.backoffConfig = {
+      ...DEFAULT_BACKOFF_CONFIG,
+      ...config.backoff
+    };
+    this.backpressureConfig = {
+      ...DEFAULT_BACKPRESSURE_CONFIG,
+      ...config.backpressure
+    };
+    this.backpressureController = new BackpressureController({
+      config: this.backpressureConfig,
+      opLog: this.opLog
+      // Pass reference, not copy
+    });
+    const topicQueueConfig = {
+      ...DEFAULT_TOPIC_QUEUE_CONFIG,
+      ...config.topicQueue
+    };
+    this.webSocketManager = new WebSocketManager({
+      connectionProvider: config.connectionProvider,
+      stateMachine: this.stateMachine,
+      backoffConfig: this.backoffConfig,
+      heartbeatConfig: this.heartbeatConfig,
+      onMessage: (msg) => this.handleServerMessage(msg),
+      onConnected: () => this.handleConnectionEstablished(),
+      onDisconnected: () => this.handleConnectionLost(),
+      onReconnected: () => this.handleReconnection()
+    });
+    this.queryManager = new QueryManager({
+      storageAdapter: this.storageAdapter,
+      sendMessage: (msg, key) => this.webSocketManager.sendMessage(msg, key),
+      isAuthenticated: () => this.isAuthenticated()
+    });
+    this.topicManager = new TopicManager({
+      topicQueueConfig,
+      sendMessage: (msg, key) => this.webSocketManager.sendMessage(msg, key),
+      isAuthenticated: () => this.isAuthenticated()
+    });
+    this.lockManager = new LockManager({
+      sendMessage: (msg, key) => this.webSocketManager.sendMessage(msg, key),
+      isAuthenticated: () => this.isAuthenticated(),
+      isOnline: () => this.isOnline()
+    });
+    this.writeConcernManager = new WriteConcernManager({
+      defaultTimeout: 5e3
+    });
+    this.counterManager = new CounterManager({
+      sendMessage: (msg) => this.sendMessage(msg),
+      isAuthenticated: () => this.isAuthenticated()
+    });
+    this.entryProcessorClient = new EntryProcessorClient({
+      sendMessage: (msg, key) => key !== void 0 ? this.sendMessage(msg, key) : this.sendMessage(msg),
+      isAuthenticated: () => this.isAuthenticated()
+    });
+    this.searchClient = new SearchClient({
+      sendMessage: (msg) => this.sendMessage(msg),
+      isAuthenticated: () => this.isAuthenticated()
+    });
+    this.merkleSyncHandler = new MerkleSyncHandler({
+      getMap: (name) => this.maps.get(name),
+      sendMessage: (msg, key) => this.webSocketManager.sendMessage(msg, key),
+      storageAdapter: this.storageAdapter,
+      hlc: this.hlc,
+      onTimestampUpdate: async (ts) => {
+        this.hlc.update(ts);
+        this.lastSyncTimestamp = ts.millis;
+        await this.saveOpLog();
+      },
+      resetMap: (name) => this.resetMap(name)
+    });
+    this.orMapSyncHandler = new ORMapSyncHandler({
+      getMap: (name) => this.maps.get(name),
+      sendMessage: (msg, key) => this.webSocketManager.sendMessage(msg, key),
+      hlc: this.hlc,
+      onTimestampUpdate: async (ts) => {
+        this.hlc.update(ts);
+        this.lastSyncTimestamp = ts.millis;
+        await this.saveOpLog();
+      }
+    });
+    this.conflictResolverClient = new ConflictResolverClient(this);
+    this.messageRouter = new MessageRouter({
+      onUnhandled: (msg) => logger.warn({ type: msg?.type }, "Unhandled message type")
+    });
+    registerClientMessageHandlers(
+      this.messageRouter,
+      {
+        sendAuth: () => this.sendAuth(),
+        handleAuthAck: () => this.handleAuthAck(),
+        handleAuthFail: (msg) => this.handleAuthFail(msg),
+        handleOpAck: (msg) => this.handleOpAck(msg),
+        handleQueryResp: (msg) => this.handleQueryResp(msg),
+        handleQueryUpdate: (msg) => this.handleQueryUpdate(msg),
+        handleServerEvent: (msg) => this.handleServerEvent(msg),
+        handleServerBatchEvent: (msg) => this.handleServerBatchEvent(msg),
+        handleGcPrune: (msg) => this.handleGcPrune(msg),
+        handleHybridQueryResponse: (payload) => this.handleHybridQueryResponse(payload),
+        handleHybridQueryDelta: (payload) => this.handleHybridQueryDelta(payload)
+      },
+      {
+        topicManager: this.topicManager,
+        lockManager: this.lockManager,
+        counterManager: this.counterManager,
+        entryProcessorClient: this.entryProcessorClient,
+        conflictResolverClient: this.conflictResolverClient,
+        searchClient: this.searchClient,
+        merkleSyncHandler: this.merkleSyncHandler,
+        orMapSyncHandler: this.orMapSyncHandler
+      }
+    );
+    this.webSocketManager.connect();
+    this.loadOpLog();
+  }
+  // ============================================
+  // Connection Callbacks (from WebSocketManager)
+  // ============================================
+  /**
+   * Called when connection is established (initial or reconnect).
+   */
+  handleConnectionEstablished() {
+    if (this.authToken || this.tokenProvider) {
+      logger.info("Connection established. Sending auth...");
+      this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
+      this.sendAuth();
+    } else {
+      logger.info("Connection established. Waiting for auth token...");
+      this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
+    }
+  }
+  /**
+   * Called when connection is lost.
+   */
+  handleConnectionLost() {
+  }
+  /**
+   * Called when reconnection succeeds.
+   */
+  handleReconnection() {
+    if (this.authToken || this.tokenProvider) {
+      this.stateMachine.transition("AUTHENTICATING" /* AUTHENTICATING */);
+      this.sendAuth();
+    }
+  }
+  // ============================================
+  // State Machine Public API
+  // ============================================
+  /**
+   * Get the current connection state
+   */
+  getConnectionState() {
+    return this.stateMachine.getState();
+  }
+  /**
+   * Subscribe to connection state changes
+   * @returns Unsubscribe function
+   */
+  onConnectionStateChange(listener) {
+    return this.stateMachine.onStateChange(listener);
+  }
+  /**
+   * Get state machine history for debugging
+   */
+  getStateHistory(limit) {
+    return this.stateMachine.getHistory(limit);
+  }
+  // ============================================
+  // Internal State Helpers (replace boolean flags)
+  // ============================================
+  /**
+   * Check if WebSocket is connected (but may not be authenticated yet)
+   */
+  isOnline() {
+    const state = this.stateMachine.getState();
+    return state === "CONNECTING" /* CONNECTING */ || state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+  }
+  /**
+   * Check if fully authenticated and ready for operations
+   */
+  isAuthenticated() {
+    const state = this.stateMachine.getState();
+    return state === "SYNCING" /* SYNCING */ || state === "CONNECTED" /* CONNECTED */;
+  }
+  /**
+   * Check if fully connected and synced
+   */
+  isConnected() {
+    return this.stateMachine.getState() === "CONNECTED" /* CONNECTED */;
+  }
+  // ============================================
+  // Message Sending (delegates to WebSocketManager)
+  // ============================================
+  /**
+   * Send a message through the current connection.
+   * Delegates to WebSocketManager.
+   */
+  sendMessage(message, key) {
+    return this.webSocketManager.sendMessage(message, key);
+  }
+  // ============================================
+  // Op Log Management
+  // ============================================
+  async loadOpLog() {
+    const storedTimestamp = await this.storageAdapter.getMeta("lastSyncTimestamp");
+    if (storedTimestamp) {
+      this.lastSyncTimestamp = storedTimestamp;
+    }
+    const pendingOps = await this.storageAdapter.getPendingOps();
+    this.opLog.length = 0;
+    for (const op of pendingOps) {
+      this.opLog.push({
+        ...op,
+        id: String(op.id),
+        synced: false
+      });
+    }
+    if (this.opLog.length > 0) {
+      logger.info({ count: this.opLog.length }, "Loaded pending operations from local storage");
+    }
+  }
+  async saveOpLog() {
+    await this.storageAdapter.setMeta("lastSyncTimestamp", this.lastSyncTimestamp);
+  }
+  registerMap(mapName, map) {
+    this.maps.set(mapName, map);
+  }
+  async recordOperation(mapName, opType, key, data) {
+    await this.backpressureController.checkBackpressure();
+    const opLogEntry = {
+      mapName,
+      opType,
+      key,
+      record: data.record,
+      orRecord: data.orRecord,
+      orTag: data.orTag,
+      timestamp: data.timestamp,
+      synced: false
+    };
+    const id = await this.storageAdapter.appendOpLog(opLogEntry);
+    opLogEntry.id = String(id);
+    this.opLog.push(opLogEntry);
+    this.backpressureController.checkHighWaterMark();
+    if (this.isAuthenticated()) {
+      this.syncPendingOperations();
+    }
+    return opLogEntry.id;
+  }
+  syncPendingOperations() {
+    const pending = this.opLog.filter((op) => !op.synced);
+    if (pending.length === 0) return;
+    logger.info({ count: pending.length }, "Syncing pending operations");
+    this.sendMessage({
+      type: "OP_BATCH",
+      payload: {
+        ops: pending
+      }
+    });
+  }
+  startMerkleSync() {
+    for (const [mapName, map] of this.maps) {
+      if (map instanceof LWWMap2) {
+        this.merkleSyncHandler.sendSyncInit(mapName, this.lastSyncTimestamp);
+      } else if (map instanceof ORMap2) {
+        this.orMapSyncHandler.sendSyncInit(mapName, this.lastSyncTimestamp);
+      }
+    }
+  }
+  setAuthToken(token) {
+    this.authToken = token;
+    this.tokenProvider = null;
+    const state = this.stateMachine.getState();
+    if (state === "AUTHENTICATING" /* AUTHENTICATING */ || state === "CONNECTING" /* CONNECTING */) {
+      this.sendAuth();
+    } else if (state === "BACKOFF" /* BACKOFF */ || state === "DISCONNECTED" /* DISCONNECTED */) {
+      logger.info("Auth token set during backoff/disconnect. Reconnecting immediately.");
+      this.webSocketManager.clearReconnectTimer();
+      this.webSocketManager.resetBackoff();
+      this.webSocketManager.connect();
+    }
+  }
+  setTokenProvider(provider) {
+    this.tokenProvider = provider;
+    const state = this.stateMachine.getState();
+    if (state === "AUTHENTICATING" /* AUTHENTICATING */) {
+      this.sendAuth();
+    }
   }
   async sendAuth() {
     if (this.tokenProvider) {
@@ -1087,545 +2546,204 @@ var _SyncEngine = class _SyncEngine {
       token
     });
   }
+  /**
+   * Subscribe to a standard query.
+   * Delegates to QueryManager.
+   */
   subscribeToQuery(query) {
-    this.queries.set(query.id, query);
-    if (this.isAuthenticated()) {
-      this.sendQuerySubscription(query);
-    }
+    this.queryManager.subscribeToQuery(query);
   }
+  /**
+   * Subscribe to a topic.
+   * Delegates to TopicManager.
+   */
   subscribeToTopic(topic, handle) {
-    this.topics.set(topic, handle);
-    if (this.isAuthenticated()) {
-      this.sendTopicSubscription(topic);
-    }
-  }
-  unsubscribeFromTopic(topic) {
-    this.topics.delete(topic);
-    if (this.isAuthenticated()) {
-      this.sendMessage({
-        type: "TOPIC_UNSUB",
-        payload: { topic }
-      });
-    }
-  }
-  publishTopic(topic, data) {
-    if (this.isAuthenticated()) {
-      this.sendMessage({
-        type: "TOPIC_PUB",
-        payload: { topic, data }
-      });
-    } else {
-      logger.warn({ topic }, "Dropped topic publish (offline)");
-    }
-  }
-  sendTopicSubscription(topic) {
-    this.sendMessage({
-      type: "TOPIC_SUB",
-      payload: { topic }
-    });
+    this.topicManager.subscribeToTopic(topic, handle);
   }
   /**
-   * Executes a query against local storage immediately
+   * Unsubscribe from a topic.
+   * Delegates to TopicManager.
    */
-  async runLocalQuery(mapName, filter) {
-    const keys = await this.storageAdapter.getAllKeys();
-    const mapKeys = keys.filter((k) => k.startsWith(mapName + ":"));
-    const results = [];
-    for (const fullKey of mapKeys) {
-      const record = await this.storageAdapter.get(fullKey);
-      if (record && record.value) {
-        const actualKey = fullKey.slice(mapName.length + 1);
-        let matches = true;
-        if (filter.where) {
-          for (const [k, v] of Object.entries(filter.where)) {
-            if (record.value[k] !== v) {
-              matches = false;
-              break;
-            }
-          }
-        }
-        if (matches && filter.predicate) {
-          if (!evaluatePredicate(filter.predicate, record.value)) {
-            matches = false;
-          }
-        }
-        if (matches) {
-          results.push({ key: actualKey, value: record.value });
-        }
-      }
-    }
-    return results;
-  }
-  unsubscribeFromQuery(queryId) {
-    this.queries.delete(queryId);
-    if (this.isAuthenticated()) {
-      this.sendMessage({
-        type: "QUERY_UNSUB",
-        payload: { queryId }
-      });
-    }
-  }
-  sendQuerySubscription(query) {
-    this.sendMessage({
-      type: "QUERY_SUB",
-      payload: {
-        queryId: query.id,
-        mapName: query.getMapName(),
-        query: query.getFilter()
-      }
-    });
-  }
-  requestLock(name, requestId, ttl) {
-    if (!this.isAuthenticated()) {
-      return Promise.reject(new Error("Not connected or authenticated"));
-    }
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pendingLockRequests.has(requestId)) {
-          this.pendingLockRequests.delete(requestId);
-          reject(new Error("Lock request timed out waiting for server response"));
-        }
-      }, 3e4);
-      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
-      try {
-        const sent = this.sendMessage({
-          type: "LOCK_REQUEST",
-          payload: { requestId, name, ttl }
-        });
-        if (!sent) {
-          clearTimeout(timer);
-          this.pendingLockRequests.delete(requestId);
-          reject(new Error("Failed to send lock request"));
-        }
-      } catch (e) {
-        clearTimeout(timer);
-        this.pendingLockRequests.delete(requestId);
-        reject(e);
-      }
-    });
-  }
-  releaseLock(name, requestId, fencingToken) {
-    if (!this.isOnline()) return Promise.resolve(false);
-    return new Promise((resolve, reject) => {
-      const timer = setTimeout(() => {
-        if (this.pendingLockRequests.has(requestId)) {
-          this.pendingLockRequests.delete(requestId);
-          resolve(false);
-        }
-      }, 5e3);
-      this.pendingLockRequests.set(requestId, { resolve, reject, timer });
-      try {
-        const sent = this.sendMessage({
-          type: "LOCK_RELEASE",
-          payload: { requestId, name, fencingToken }
-        });
-        if (!sent) {
-          clearTimeout(timer);
-          this.pendingLockRequests.delete(requestId);
-          resolve(false);
-        }
-      } catch (e) {
-        clearTimeout(timer);
-        this.pendingLockRequests.delete(requestId);
-        resolve(false);
-      }
-    });
+  unsubscribeFromTopic(topic) {
+    this.topicManager.unsubscribeFromTopic(topic);
   }
-  async handleServerMessage(message) {
-    this.emitMessage(message);
-    switch (message.type) {
-      case "BATCH": {
-        const batchData = message.data;
-        const view = new DataView(batchData.buffer, batchData.byteOffset, batchData.byteLength);
-        let offset = 0;
-        const count = view.getUint32(offset, true);
-        offset += 4;
-        for (let i = 0; i < count; i++) {
-          const msgLen = view.getUint32(offset, true);
-          offset += 4;
-          const msgData = batchData.slice(offset, offset + msgLen);
-          offset += msgLen;
-          const innerMsg = deserialize(msgData);
-          await this.handleServerMessage(innerMsg);
-        }
-        break;
-      }
-      case "AUTH_REQUIRED":
-        this.sendAuth();
-        break;
-      case "AUTH_ACK": {
-        logger.info("Authenticated successfully");
-        const wasAuthenticated = this.isAuthenticated();
-        this.stateMachine.transition("SYNCING" /* SYNCING */);
-        this.resetBackoff();
-        this.syncPendingOperations();
-        if (!wasAuthenticated) {
-          this.startHeartbeat();
-          this.startMerkleSync();
-          for (const query of this.queries.values()) {
-            this.sendQuerySubscription(query);
-          }
-          for (const topic of this.topics.keys()) {
-            this.sendTopicSubscription(topic);
-          }
-        }
-        this.stateMachine.transition("CONNECTED" /* CONNECTED */);
-        break;
-      }
-      case "PONG": {
-        this.handlePong(message);
-        break;
-      }
-      case "AUTH_FAIL":
-        logger.error({ error: message.error }, "Authentication failed");
-        this.authToken = null;
-        break;
-      case "OP_ACK": {
-        const { lastId, achievedLevel, results } = message.payload;
-        logger.info({ lastId, achievedLevel, hasResults: !!results }, "Received ACK for ops");
-        if (results && Array.isArray(results)) {
-          for (const result of results) {
-            const op = this.opLog.find((o) => o.id === result.opId);
-            if (op && !op.synced) {
-              op.synced = true;
-              logger.debug({ opId: result.opId, achievedLevel: result.achievedLevel, success: result.success }, "Op ACK with Write Concern");
-            }
-            this.resolveWriteConcernPromise(result.opId, result);
-          }
-        }
-        let maxSyncedId = -1;
-        let ackedCount = 0;
-        this.opLog.forEach((op) => {
-          if (op.id && op.id <= lastId) {
-            if (!op.synced) {
-              ackedCount++;
-            }
-            op.synced = true;
-            const idNum = parseInt(op.id, 10);
-            if (!isNaN(idNum) && idNum > maxSyncedId) {
-              maxSyncedId = idNum;
-            }
-          }
-        });
-        if (maxSyncedId !== -1) {
-          this.storageAdapter.markOpsSynced(maxSyncedId).catch((err) => logger.error({ err }, "Failed to mark ops synced"));
-        }
-        if (ackedCount > 0) {
-          this.checkLowWaterMark();
-        }
-        break;
-      }
-      case "LOCK_GRANTED": {
-        const { requestId, fencingToken } = message.payload;
-        const req = this.pendingLockRequests.get(requestId);
-        if (req) {
-          clearTimeout(req.timer);
-          this.pendingLockRequests.delete(requestId);
-          req.resolve({ fencingToken });
-        }
-        break;
-      }
-      case "LOCK_RELEASED": {
-        const { requestId, success } = message.payload;
-        const req = this.pendingLockRequests.get(requestId);
-        if (req) {
-          clearTimeout(req.timer);
-          this.pendingLockRequests.delete(requestId);
-          req.resolve(success);
-        }
-        break;
-      }
-      case "QUERY_RESP": {
-        const { queryId, results, nextCursor, hasMore, cursorStatus } = message.payload;
-        const query = this.queries.get(queryId);
-        if (query) {
-          query.onResult(results, "server");
-          query.updatePaginationInfo({ nextCursor, hasMore, cursorStatus });
-        }
-        break;
-      }
-      case "QUERY_UPDATE": {
-        const { queryId, key, value, type } = message.payload;
-        const query = this.queries.get(queryId);
-        if (query) {
-          query.onUpdate(key, type === "REMOVE" ? null : value);
-        }
-        break;
-      }
-      case "SERVER_EVENT": {
-        const { mapName, eventType, key, record, orRecord, orTag } = message.payload;
-        await this.applyServerEvent(mapName, eventType, key, record, orRecord, orTag);
-        break;
-      }
-      case "SERVER_BATCH_EVENT": {
-        const { events } = message.payload;
-        for (const event of events) {
-          await this.applyServerEvent(
-            event.mapName,
-            event.eventType,
-            event.key,
-            event.record,
-            event.orRecord,
-            event.orTag
-          );
-        }
-        break;
-      }
-      case "TOPIC_MESSAGE": {
-        const { topic, data, publisherId, timestamp } = message.payload;
-        const handle = this.topics.get(topic);
-        if (handle) {
-          handle.onMessage(data, { publisherId, timestamp });
-        }
-        break;
-      }
-      case "GC_PRUNE": {
-        const { olderThan } = message.payload;
-        logger.info({ olderThan: olderThan.millis }, "Received GC_PRUNE request");
-        for (const [name, map] of this.maps) {
-          if (map instanceof LWWMap) {
-            const removedKeys = map.prune(olderThan);
-            for (const key of removedKeys) {
-              await this.storageAdapter.remove(`${name}:${key}`);
-            }
-            if (removedKeys.length > 0) {
-              logger.info({ mapName: name, count: removedKeys.length }, "Pruned tombstones from LWWMap");
-            }
-          } else if (map instanceof ORMap) {
-            const removedTags = map.prune(olderThan);
-            if (removedTags.length > 0) {
-              logger.info({ mapName: name, count: removedTags.length }, "Pruned tombstones from ORMap");
-            }
-          }
-        }
-        break;
-      }
-      case "SYNC_RESET_REQUIRED": {
-        const { mapName } = message.payload;
-        logger.warn({ mapName }, "Sync Reset Required due to GC Age");
-        await this.resetMap(mapName);
-        this.sendMessage({
-          type: "SYNC_INIT",
-          mapName,
-          lastSyncTimestamp: 0
-        });
-        break;
-      }
-      case "SYNC_RESP_ROOT": {
-        const { mapName, rootHash, timestamp } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof LWWMap) {
-          const localRootHash = map.getMerkleTree().getRootHash();
-          if (localRootHash !== rootHash) {
-            logger.info({ mapName, localRootHash, remoteRootHash: rootHash }, "Root hash mismatch, requesting buckets");
-            this.sendMessage({
-              type: "MERKLE_REQ_BUCKET",
-              payload: { mapName, path: "" }
-            });
-          } else {
-            logger.info({ mapName }, "Map is in sync");
-          }
-        }
-        if (timestamp) {
-          this.hlc.update(timestamp);
-          this.lastSyncTimestamp = timestamp.millis;
-          await this.saveOpLog();
-        }
-        break;
-      }
-      case "SYNC_RESP_BUCKETS": {
-        const { mapName, path, buckets } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof LWWMap) {
-          const tree = map.getMerkleTree();
-          const localBuckets = tree.getBuckets(path);
-          for (const [bucketKey, remoteHash] of Object.entries(buckets)) {
-            const localHash = localBuckets[bucketKey] || 0;
-            if (localHash !== remoteHash) {
-              const newPath = path + bucketKey;
-              this.sendMessage({
-                type: "MERKLE_REQ_BUCKET",
-                payload: { mapName, path: newPath }
-              });
-            }
-          }
-        }
-        break;
-      }
-      case "SYNC_RESP_LEAF": {
-        const { mapName, records } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof LWWMap) {
-          let updateCount = 0;
-          for (const { key, record } of records) {
-            const updated = map.merge(key, record);
-            if (updated) {
-              updateCount++;
-              await this.storageAdapter.put(`${mapName}:${key}`, record);
-            }
-          }
-          if (updateCount > 0) {
-            logger.info({ mapName, count: updateCount }, "Synced records from server");
-          }
+  /**
+   * Publish a message to a topic.
+   * Delegates to TopicManager.
+   */
+  publishTopic(topic, data) {
+    this.topicManager.publishTopic(topic, data);
+  }
+  /**
+   * Get topic queue status.
+   * Delegates to TopicManager.
+   */
+  getTopicQueueStatus() {
+    return this.topicManager.getTopicQueueStatus();
+  }
+  /**
+   * Executes a query against local storage immediately.
+   * Delegates to QueryManager.
+   */
+  async runLocalQuery(mapName, filter) {
+    return this.queryManager.runLocalQuery(mapName, filter);
+  }
+  /**
+   * Unsubscribe from a query.
+   * Delegates to QueryManager.
+   */
+  unsubscribeFromQuery(queryId) {
+    this.queryManager.unsubscribeFromQuery(queryId);
+  }
+  /**
+   * Request a distributed lock.
+   * Delegates to LockManager.
+   */
+  requestLock(name, requestId, ttl) {
+    return this.lockManager.requestLock(name, requestId, ttl);
+  }
+  /**
+   * Release a distributed lock.
+   * Delegates to LockManager.
+   */
+  releaseLock(name, requestId, fencingToken) {
+    return this.lockManager.releaseLock(name, requestId, fencingToken);
+  }
+  async handleServerMessage(message) {
+    this.emitMessage(message);
+    if (message.type === "BATCH") {
+      await this.handleBatch(message);
+      return;
+    }
+    await this.messageRouter.route(message);
+    if (message.timestamp) {
+      this.hlc.update(message.timestamp);
+      this.lastSyncTimestamp = message.timestamp.millis;
+      await this.saveOpLog();
+    }
+  }
+  // ============================================
+  // Message Handler Helpers (extracted from switch)
+  // ============================================
+  async handleBatch(message) {
+    const batchData = message.data;
+    const view = new DataView(batchData.buffer, batchData.byteOffset, batchData.byteLength);
+    let offset = 0;
+    const count = view.getUint32(offset, true);
+    offset += 4;
+    for (let i = 0; i < count; i++) {
+      const msgLen = view.getUint32(offset, true);
+      offset += 4;
+      const msgData = batchData.slice(offset, offset + msgLen);
+      offset += msgLen;
+      const innerMsg = deserialize2(msgData);
+      await this.handleServerMessage(innerMsg);
+    }
+  }
+  handleAuthAck() {
+    logger.info("Authenticated successfully");
+    const wasAuthenticated = this.isAuthenticated();
+    this.stateMachine.transition("SYNCING" /* SYNCING */);
+    this.webSocketManager.resetBackoff();
+    this.syncPendingOperations();
+    this.topicManager.flushTopicQueue();
+    if (!wasAuthenticated) {
+      this.webSocketManager.startHeartbeat();
+      this.startMerkleSync();
+      this.queryManager.resubscribeAll();
+      this.topicManager.resubscribeAll();
+    }
+    this.stateMachine.transition("CONNECTED" /* CONNECTED */);
+  }
+  handleAuthFail(message) {
+    logger.error({ error: message.error }, "Authentication failed");
+    this.authToken = null;
+  }
+  handleOpAck(message) {
+    const { lastId, achievedLevel, results } = message.payload;
+    logger.info({ lastId, achievedLevel, hasResults: !!results }, "Received ACK for ops");
+    if (results && Array.isArray(results)) {
+      for (const result of results) {
+        const op = this.opLog.find((o) => o.id === result.opId);
+        if (op && !op.synced) {
+          op.synced = true;
+          logger.debug({ opId: result.opId, achievedLevel: result.achievedLevel, success: result.success }, "Op ACK with Write Concern");
         }
-        break;
+        this.writeConcernManager.resolveWriteConcernPromise(result.opId, result);
       }
-      // ============ ORMap Sync Message Handlers ============
-      case "ORMAP_SYNC_RESP_ROOT": {
-        const { mapName, rootHash, timestamp } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof ORMap) {
-          const localTree = map.getMerkleTree();
-          const localRootHash = localTree.getRootHash();
-          if (localRootHash !== rootHash) {
-            logger.info({ mapName, localRootHash, remoteRootHash: rootHash }, "ORMap root hash mismatch, requesting buckets");
-            this.sendMessage({
-              type: "ORMAP_MERKLE_REQ_BUCKET",
-              payload: { mapName, path: "" }
-            });
-          } else {
-            logger.info({ mapName }, "ORMap is in sync");
-          }
+    }
+    let maxSyncedId = -1;
+    let ackedCount = 0;
+    this.opLog.forEach((op) => {
+      if (op.id && op.id <= lastId) {
+        if (!op.synced) {
+          ackedCount++;
         }
-        if (timestamp) {
-          this.hlc.update(timestamp);
-          this.lastSyncTimestamp = timestamp.millis;
-          await this.saveOpLog();
+        op.synced = true;
+        const idNum = parseInt(op.id, 10);
+        if (!isNaN(idNum) && idNum > maxSyncedId) {
+          maxSyncedId = idNum;
         }
-        break;
       }
-      case "ORMAP_SYNC_RESP_BUCKETS": {
-        const { mapName, path, buckets } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof ORMap) {
-          const tree = map.getMerkleTree();
-          const localBuckets = tree.getBuckets(path);
-          for (const [bucketKey, remoteHash] of Object.entries(buckets)) {
-            const localHash = localBuckets[bucketKey] || 0;
-            if (localHash !== remoteHash) {
-              const newPath = path + bucketKey;
-              this.sendMessage({
-                type: "ORMAP_MERKLE_REQ_BUCKET",
-                payload: { mapName, path: newPath }
-              });
-            }
-          }
-          for (const [bucketKey, localHash] of Object.entries(localBuckets)) {
-            if (!(bucketKey in buckets) && localHash !== 0) {
-              const newPath = path + bucketKey;
-              const keys = tree.getKeysInBucket(newPath);
-              if (keys.length > 0) {
-                this.pushORMapDiff(mapName, keys, map);
-              }
-            }
-          }
+    });
+    if (maxSyncedId !== -1) {
+      this.storageAdapter.markOpsSynced(maxSyncedId).catch((err) => logger.error({ err }, "Failed to mark ops synced"));
+    }
+    if (ackedCount > 0) {
+      this.backpressureController.checkLowWaterMark();
+    }
+  }
+  handleQueryResp(message) {
+    const { queryId, results, nextCursor, hasMore, cursorStatus } = message.payload;
+    const query = this.queryManager.getQueries().get(queryId);
+    if (query) {
+      query.onResult(results, "server");
+      query.updatePaginationInfo({ nextCursor, hasMore, cursorStatus });
+    }
+  }
+  handleQueryUpdate(message) {
+    const { queryId, key, value, type } = message.payload;
+    const query = this.queryManager.getQueries().get(queryId);
+    if (query) {
+      query.onUpdate(key, type === "REMOVE" ? null : value);
+    }
+  }
+  async handleServerEvent(message) {
+    const { mapName, eventType, key, record, orRecord, orTag } = message.payload;
+    await this.applyServerEvent(mapName, eventType, key, record, orRecord, orTag);
+  }
+  async handleServerBatchEvent(message) {
+    const { events } = message.payload;
+    for (const event of events) {
+      await this.applyServerEvent(
+        event.mapName,
+        event.eventType,
+        event.key,
+        event.record,
+        event.orRecord,
+        event.orTag
+      );
+    }
+  }
+  async handleGcPrune(message) {
+    const { olderThan } = message.payload;
+    logger.info({ olderThan: olderThan.millis }, "Received GC_PRUNE request");
+    for (const [name, map] of this.maps) {
+      if (map instanceof LWWMap2) {
+        const removedKeys = map.prune(olderThan);
+        for (const key of removedKeys) {
+          await this.storageAdapter.remove(`${name}:${key}`);
         }
-        break;
-      }
-      case "ORMAP_SYNC_RESP_LEAF": {
-        const { mapName, entries } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof ORMap) {
-          let totalAdded = 0;
-          let totalUpdated = 0;
-          for (const entry of entries) {
-            const { key, records, tombstones } = entry;
-            const result = map.mergeKey(key, records, tombstones);
-            totalAdded += result.added;
-            totalUpdated += result.updated;
-          }
-          if (totalAdded > 0 || totalUpdated > 0) {
-            logger.info({ mapName, added: totalAdded, updated: totalUpdated }, "Synced ORMap records from server");
-          }
-          const keysToCheck = entries.map((e) => e.key);
-          await this.pushORMapDiff(mapName, keysToCheck, map);
+        if (removedKeys.length > 0) {
+          logger.info({ mapName: name, count: removedKeys.length }, "Pruned tombstones from LWWMap");
         }
-        break;
-      }
-      case "ORMAP_DIFF_RESPONSE": {
-        const { mapName, entries } = message.payload;
-        const map = this.maps.get(mapName);
-        if (map instanceof ORMap) {
-          let totalAdded = 0;
-          let totalUpdated = 0;
-          for (const entry of entries) {
-            const { key, records, tombstones } = entry;
-            const result = map.mergeKey(key, records, tombstones);
-            totalAdded += result.added;
-            totalUpdated += result.updated;
-          }
-          if (totalAdded > 0 || totalUpdated > 0) {
-            logger.info({ mapName, added: totalAdded, updated: totalUpdated }, "Merged ORMap diff from server");
-          }
+      } else if (map instanceof ORMap2) {
+        const removedTags = map.prune(olderThan);
+        if (removedTags.length > 0) {
+          logger.info({ mapName: name, count: removedTags.length }, "Pruned tombstones from ORMap");
         }
-        break;
-      }
-      // ============ PN Counter Message Handlers (Phase 5.2) ============
-      case "COUNTER_UPDATE": {
-        const { name, state } = message.payload;
-        logger.debug({ name }, "Received COUNTER_UPDATE");
-        this.handleCounterUpdate(name, state);
-        break;
-      }
-      case "COUNTER_RESPONSE": {
-        const { name, state } = message.payload;
-        logger.debug({ name }, "Received COUNTER_RESPONSE");
-        this.handleCounterUpdate(name, state);
-        break;
-      }
-      // ============ Entry Processor Message Handlers (Phase 5.03) ============
-      case "ENTRY_PROCESS_RESPONSE": {
-        logger.debug({ requestId: message.requestId, success: message.success }, "Received ENTRY_PROCESS_RESPONSE");
-        this.handleEntryProcessResponse(message);
-        break;
-      }
-      case "ENTRY_PROCESS_BATCH_RESPONSE": {
-        logger.debug({ requestId: message.requestId }, "Received ENTRY_PROCESS_BATCH_RESPONSE");
-        this.handleEntryProcessBatchResponse(message);
-        break;
-      }
-      // ============ Conflict Resolver Message Handlers (Phase 5.05) ============
-      case "REGISTER_RESOLVER_RESPONSE": {
-        logger.debug({ requestId: message.requestId, success: message.success }, "Received REGISTER_RESOLVER_RESPONSE");
-        this.conflictResolverClient.handleRegisterResponse(message);
-        break;
-      }
-      case "UNREGISTER_RESOLVER_RESPONSE": {
-        logger.debug({ requestId: message.requestId, success: message.success }, "Received UNREGISTER_RESOLVER_RESPONSE");
-        this.conflictResolverClient.handleUnregisterResponse(message);
-        break;
-      }
-      case "LIST_RESOLVERS_RESPONSE": {
-        logger.debug({ requestId: message.requestId }, "Received LIST_RESOLVERS_RESPONSE");
-        this.conflictResolverClient.handleListResponse(message);
-        break;
-      }
-      case "MERGE_REJECTED": {
-        logger.debug({ mapName: message.mapName, key: message.key, reason: message.reason }, "Received MERGE_REJECTED");
-        this.conflictResolverClient.handleMergeRejected(message);
-        break;
-      }
-      // ============ Full-Text Search Message Handlers (Phase 11.1a) ============
-      case "SEARCH_RESP": {
-        logger.debug({ requestId: message.payload?.requestId, resultCount: message.payload?.results?.length }, "Received SEARCH_RESP");
-        this.handleSearchResponse(message.payload);
-        break;
-      }
-      // ============ Live Search Message Handlers (Phase 11.1b) ============
-      case "SEARCH_UPDATE": {
-        logger.debug({
-          subscriptionId: message.payload?.subscriptionId,
-          key: message.payload?.key,
-          type: message.payload?.type
-        }, "Received SEARCH_UPDATE");
-        break;
       }
     }
-    if (message.timestamp) {
-      this.hlc.update(message.timestamp);
-      this.lastSyncTimestamp = message.timestamp.millis;
-      await this.saveOpLog();
-    }
   }
   getHLC() {
     return this.hlc;
@@ -1637,10 +2755,10 @@ var _SyncEngine = class _SyncEngine {
   async applyServerEvent(mapName, eventType, key, record, orRecord, orTag) {
     const localMap = this.maps.get(mapName);
     if (localMap) {
-      if (localMap instanceof LWWMap && record) {
+      if (localMap instanceof LWWMap2 && record) {
         localMap.merge(key, record);
         await this.storageAdapter.put(`${mapName}:${key}`, record);
-      } else if (localMap instanceof ORMap) {
+      } else if (localMap instanceof ORMap2) {
         if (eventType === "OR_ADD" && orRecord) {
           localMap.apply(key, orRecord);
         } else if (eventType === "OR_REMOVE" && orTag) {
@@ -1653,21 +2771,11 @@ var _SyncEngine = class _SyncEngine {
    * Closes the WebSocket connection and cleans up resources.
    */
   close() {
-    this.stopHeartbeat();
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.useConnectionProvider) {
-      this.connectionProvider.close().catch((err) => {
-        logger.error({ err }, "Error closing ConnectionProvider");
-      });
-    } else if (this.websocket) {
-      this.websocket.onclose = null;
-      this.websocket.close();
-      this.websocket = null;
-    }
-    this.cancelAllWriteConcernPromises(new Error("SyncEngine closed"));
+    this.webSocketManager.close();
+    this.writeConcernManager.cancelAllWriteConcernPromises(new Error("SyncEngine closed"));
+    this.counterManager.close();
+    this.entryProcessorClient.close(new Error("SyncEngine closed"));
+    this.searchClient.close(new Error("SyncEngine closed"));
     this.stateMachine.transition("DISCONNECTED" /* DISCONNECTED */);
     logger.info("SyncEngine closed");
   }
@@ -1678,15 +2786,11 @@ var _SyncEngine = class _SyncEngine {
   resetConnection() {
     this.close();
     this.stateMachine.reset();
-    this.resetBackoff();
-    if (this.useConnectionProvider) {
-      this.initConnectionProvider();
-    } else {
-      this.initConnection();
-    }
+    this.webSocketManager.reset();
+    this.webSocketManager.connect();
   }
   // ============================================
-  // Failover Support Methods (Phase 4.5 Task 05)
+  // Failover Support Methods
   // ============================================
   /**
    * Wait for a partition map update from the connection provider.
@@ -1699,12 +2803,13 @@ var _SyncEngine = class _SyncEngine {
   waitForPartitionMapUpdate(timeoutMs = 5e3) {
     return new Promise((resolve) => {
       const timeout = setTimeout(resolve, timeoutMs);
+      const connectionProvider = this.webSocketManager.getConnectionProvider();
       const handler2 = () => {
         clearTimeout(timeout);
-        this.connectionProvider.off("partitionMapUpdated", handler2);
+        connectionProvider.off("partitionMapUpdated", handler2);
         resolve();
       };
-      this.connectionProvider.on("partitionMapUpdated", handler2);
+      connectionProvider.on("partitionMapUpdated", handler2);
     });
   }
   /**
@@ -1717,20 +2822,21 @@ var _SyncEngine = class _SyncEngine {
    */
   waitForConnection(timeoutMs = 1e4) {
     return new Promise((resolve, reject) => {
-      if (this.connectionProvider.isConnected()) {
+      const connectionProvider = this.webSocketManager.getConnectionProvider();
+      if (connectionProvider.isConnected()) {
         resolve();
         return;
       }
       const timeout = setTimeout(() => {
-        this.connectionProvider.off("connected", handler2);
+        connectionProvider.off("connected", handler2);
         reject(new Error("Connection timeout waiting for reconnection"));
       }, timeoutMs);
       const handler2 = () => {
         clearTimeout(timeout);
-        this.connectionProvider.off("connected", handler2);
+        connectionProvider.off("connected", handler2);
         resolve();
       };
-      this.connectionProvider.on("connected", handler2);
+      connectionProvider.on("connected", handler2);
     });
   }
   /**
@@ -1765,21 +2871,21 @@ var _SyncEngine = class _SyncEngine {
    * Convenience method for failover logic.
    */
   isProviderConnected() {
-    return this.connectionProvider.isConnected();
+    return this.webSocketManager.getConnectionProvider().isConnected();
   }
   /**
    * Get the connection provider for direct access.
    * Use with caution - prefer using SyncEngine methods.
    */
   getConnectionProvider() {
-    return this.connectionProvider;
+    return this.webSocketManager.getConnectionProvider();
   }
   async resetMap(mapName) {
     const map = this.maps.get(mapName);
     if (map) {
-      if (map instanceof LWWMap) {
+      if (map instanceof LWWMap2) {
         map.clear();
-      } else if (map instanceof ORMap) {
+      } else if (map instanceof ORMap2) {
         map.clear();
       }
     }
@@ -1790,468 +2896,116 @@ var _SyncEngine = class _SyncEngine {
     }
     logger.info({ mapName, removedStorageCount: mapKeys.length }, "Reset map: Cleared memory and storage");
   }
-  // ============ Heartbeat Methods ============
-  /**
-   * Starts the heartbeat mechanism after successful connection.
-   */
-  startHeartbeat() {
-    if (!this.heartbeatConfig.enabled) {
-      return;
-    }
-    this.stopHeartbeat();
-    this.lastPongReceived = Date.now();
-    this.heartbeatInterval = setInterval(() => {
-      this.sendPing();
-      this.checkHeartbeatTimeout();
-    }, this.heartbeatConfig.intervalMs);
-    logger.info({ intervalMs: this.heartbeatConfig.intervalMs }, "Heartbeat started");
-  }
-  /**
-   * Stops the heartbeat mechanism.
-   */
-  stopHeartbeat() {
-    if (this.heartbeatInterval) {
-      clearInterval(this.heartbeatInterval);
-      this.heartbeatInterval = null;
-      logger.info("Heartbeat stopped");
-    }
-  }
-  /**
-   * Sends a PING message to the server.
-   */
-  sendPing() {
-    if (this.canSend()) {
-      const pingMessage = {
-        type: "PING",
-        timestamp: Date.now()
-      };
-      this.sendMessage(pingMessage);
-    }
-  }
-  /**
-   * Handles incoming PONG message from server.
-   */
-  handlePong(msg) {
-    const now = Date.now();
-    this.lastPongReceived = now;
-    this.lastRoundTripTime = now - msg.timestamp;
-    logger.debug({
-      rtt: this.lastRoundTripTime,
-      serverTime: msg.serverTime,
-      clockSkew: msg.serverTime - (msg.timestamp + this.lastRoundTripTime / 2)
-    }, "Received PONG");
-  }
-  /**
-   * Checks if heartbeat has timed out and triggers reconnection if needed.
-   */
-  checkHeartbeatTimeout() {
-    const now = Date.now();
-    const timeSinceLastPong = now - this.lastPongReceived;
-    if (timeSinceLastPong > this.heartbeatConfig.timeoutMs) {
-      logger.warn({
-        timeSinceLastPong,
-        timeoutMs: this.heartbeatConfig.timeoutMs
-      }, "Heartbeat timeout - triggering reconnection");
-      this.stopHeartbeat();
-      if (this.websocket) {
-        this.websocket.close();
-      }
-    }
-  }
-  /**
-   * Returns the last measured round-trip time in milliseconds.
-   * Returns null if no PONG has been received yet.
-   */
-  getLastRoundTripTime() {
-    return this.lastRoundTripTime;
-  }
-  /**
-   * Returns true if the connection is considered healthy based on heartbeat.
-   * A connection is healthy if it's online, authenticated, and has received
-   * a PONG within the timeout window.
-   */
-  isConnectionHealthy() {
-    if (!this.isOnline() || !this.isAuthenticated()) {
-      return false;
-    }
-    if (!this.heartbeatConfig.enabled) {
-      return true;
-    }
-    const timeSinceLastPong = Date.now() - this.lastPongReceived;
-    return timeSinceLastPong < this.heartbeatConfig.timeoutMs;
-  }
-  // ============ ORMap Sync Methods ============
-  /**
-   * Push local ORMap diff to server for the given keys.
-   * Sends local records and tombstones that the server might not have.
-   */
-  async pushORMapDiff(mapName, keys, map) {
-    const entries = [];
-    const snapshot = map.getSnapshot();
-    for (const key of keys) {
-      const recordsMap = map.getRecordsMap(key);
-      if (recordsMap && recordsMap.size > 0) {
-        const records = Array.from(recordsMap.values());
-        const tombstones = [];
-        for (const tag of snapshot.tombstones) {
-          tombstones.push(tag);
-        }
-        entries.push({
-          key,
-          records,
-          tombstones
-        });
-      }
-    }
-    if (entries.length > 0) {
-      this.sendMessage({
-        type: "ORMAP_PUSH_DIFF",
-        payload: {
-          mapName,
-          entries
-        }
-      });
-      logger.debug({ mapName, keyCount: entries.length }, "Pushed ORMap diff to server");
-    }
-  }
-  // ============ Backpressure Methods ============
-  /**
-   * Get the current number of pending (unsynced) operations.
-   */
-  getPendingOpsCount() {
-    return this.opLog.filter((op) => !op.synced).length;
-  }
-  /**
-   * Get the current backpressure status.
-   */
-  getBackpressureStatus() {
-    const pending = this.getPendingOpsCount();
-    const max = this.backpressureConfig.maxPendingOps;
-    return {
-      pending,
-      max,
-      percentage: max > 0 ? pending / max : 0,
-      isPaused: this.backpressurePaused,
-      strategy: this.backpressureConfig.strategy
-    };
-  }
-  /**
-   * Returns true if writes are currently paused due to backpressure.
-   */
-  isBackpressurePaused() {
-    return this.backpressurePaused;
-  }
-  /**
-   * Subscribe to backpressure events.
-   * @param event Event name: 'backpressure:high', 'backpressure:low', 'backpressure:paused', 'backpressure:resumed', 'operation:dropped'
-   * @param listener Callback function
-   * @returns Unsubscribe function
-   */
-  onBackpressure(event, listener) {
-    if (!this.backpressureListeners.has(event)) {
-      this.backpressureListeners.set(event, /* @__PURE__ */ new Set());
-    }
-    this.backpressureListeners.get(event).add(listener);
-    return () => {
-      this.backpressureListeners.get(event)?.delete(listener);
-    };
-  }
+  // ============ Heartbeat Methods (delegate to WebSocketManager) ============
   /**
-   * Emit a backpressure event to all listeners.
+   * Returns the last measured round-trip time in milliseconds.
+   * Returns null if no PONG has been received yet.
    */
-  emitBackpressureEvent(event, data) {
-    const listeners = this.backpressureListeners.get(event);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(data);
-        } catch (err) {
-          logger.error({ err, event }, "Error in backpressure event listener");
-        }
-      }
-    }
+  getLastRoundTripTime() {
+    return this.webSocketManager.getLastRoundTripTime();
   }
   /**
-   * Check backpressure before adding a new operation.
-   * May pause, throw, or drop depending on strategy.
+   * Returns true if the connection is considered healthy based on heartbeat.
+   * A connection is healthy if it's online, authenticated, and has received
+   * a PONG within the timeout window.
    */
-  async checkBackpressure() {
-    const pendingCount = this.getPendingOpsCount();
-    if (pendingCount < this.backpressureConfig.maxPendingOps) {
-      return;
-    }
-    switch (this.backpressureConfig.strategy) {
-      case "pause":
-        await this.waitForCapacity();
-        break;
-      case "throw":
-        throw new BackpressureError(
-          pendingCount,
-          this.backpressureConfig.maxPendingOps
-        );
-      case "drop-oldest":
-        this.dropOldestOp();
-        break;
-    }
+  isConnectionHealthy() {
+    return this.webSocketManager.isConnectionHealthy();
   }
+  // ============ Backpressure Methods (delegated to BackpressureController) ============
   /**
-   * Check high water mark and emit event if threshold reached.
+   * Get the current number of pending (unsynced) operations.
+   * Delegates to BackpressureController.
    */
-  checkHighWaterMark() {
-    const pendingCount = this.getPendingOpsCount();
-    const threshold = Math.floor(
-      this.backpressureConfig.maxPendingOps * this.backpressureConfig.highWaterMark
-    );
-    if (pendingCount >= threshold && !this.highWaterMarkEmitted) {
-      this.highWaterMarkEmitted = true;
-      logger.warn(
-        { pending: pendingCount, max: this.backpressureConfig.maxPendingOps },
-        "Backpressure high water mark reached"
-      );
-      this.emitBackpressureEvent("backpressure:high", {
-        pending: pendingCount,
-        max: this.backpressureConfig.maxPendingOps
-      });
-    }
+  getPendingOpsCount() {
+    return this.backpressureController.getPendingOpsCount();
   }
   /**
-   * Check low water mark and resume paused writes if threshold reached.
+   * Get the current backpressure status.
+   * Delegates to BackpressureController.
    */
-  checkLowWaterMark() {
-    const pendingCount = this.getPendingOpsCount();
-    const lowThreshold = Math.floor(
-      this.backpressureConfig.maxPendingOps * this.backpressureConfig.lowWaterMark
-    );
-    const highThreshold = Math.floor(
-      this.backpressureConfig.maxPendingOps * this.backpressureConfig.highWaterMark
-    );
-    if (pendingCount < highThreshold && this.highWaterMarkEmitted) {
-      this.highWaterMarkEmitted = false;
-    }
-    if (pendingCount <= lowThreshold) {
-      if (this.backpressurePaused) {
-        this.backpressurePaused = false;
-        logger.info(
-          { pending: pendingCount, max: this.backpressureConfig.maxPendingOps },
-          "Backpressure low water mark reached, resuming writes"
-        );
-        this.emitBackpressureEvent("backpressure:low", {
-          pending: pendingCount,
-          max: this.backpressureConfig.maxPendingOps
-        });
-        this.emitBackpressureEvent("backpressure:resumed");
-        const waiting = this.waitingForCapacity;
-        this.waitingForCapacity = [];
-        for (const resolve of waiting) {
-          resolve();
-        }
-      }
-    }
+  getBackpressureStatus() {
+    return this.backpressureController.getBackpressureStatus();
   }
   /**
-   * Wait for capacity to become available (used by 'pause' strategy).
+   * Returns true if writes are currently paused due to backpressure.
+   * Delegates to BackpressureController.
    */
-  async waitForCapacity() {
-    if (!this.backpressurePaused) {
-      this.backpressurePaused = true;
-      logger.warn("Backpressure paused - waiting for capacity");
-      this.emitBackpressureEvent("backpressure:paused");
-    }
-    return new Promise((resolve) => {
-      this.waitingForCapacity.push(resolve);
-    });
+  isBackpressurePaused() {
+    return this.backpressureController.isBackpressurePaused();
   }
   /**
-   * Drop the oldest pending operation (used by 'drop-oldest' strategy).
+   * Subscribe to backpressure events.
+   * Delegates to BackpressureController.
+   * @param event Event name: 'backpressure:high', 'backpressure:low', 'backpressure:paused', 'backpressure:resumed', 'operation:dropped'
+   * @param listener Callback function
+   * @returns Unsubscribe function
    */
-  dropOldestOp() {
-    const oldestIndex = this.opLog.findIndex((op) => !op.synced);
-    if (oldestIndex !== -1) {
-      const dropped = this.opLog[oldestIndex];
-      this.opLog.splice(oldestIndex, 1);
-      logger.warn(
-        { opId: dropped.id, mapName: dropped.mapName, key: dropped.key },
-        "Dropped oldest pending operation due to backpressure"
-      );
-      this.emitBackpressureEvent("operation:dropped", {
-        opId: dropped.id,
-        mapName: dropped.mapName,
-        opType: dropped.opType,
-        key: dropped.key
-      });
-    }
+  onBackpressure(event, listener) {
+    return this.backpressureController.onBackpressure(event, listener);
   }
   // ============================================
-  // Write Concern Methods (Phase 5.01)
+  // Write Concern Methods
   // ============================================
   /**
    * Register a pending Write Concern promise for an operation.
-   * The promise will be resolved when the server sends an ACK with the operation result.
+   * Delegates to WriteConcernManager.
    *
    * @param opId - Operation ID
    * @param timeout - Timeout in ms (default: 5000)
    * @returns Promise that resolves with the Write Concern result
    */
   registerWriteConcernPromise(opId, timeout = 5e3) {
-    return new Promise((resolve, reject) => {
-      const timeoutHandle = setTimeout(() => {
-        this.pendingWriteConcernPromises.delete(opId);
-        reject(new Error(`Write Concern timeout for operation ${opId}`));
-      }, timeout);
-      this.pendingWriteConcernPromises.set(opId, {
-        resolve,
-        reject,
-        timeoutHandle
-      });
-    });
-  }
-  /**
-   * Resolve a pending Write Concern promise with the server result.
-   *
-   * @param opId - Operation ID
-   * @param result - Result from server ACK
-   */
-  resolveWriteConcernPromise(opId, result) {
-    const pending = this.pendingWriteConcernPromises.get(opId);
-    if (pending) {
-      if (pending.timeoutHandle) {
-        clearTimeout(pending.timeoutHandle);
-      }
-      pending.resolve(result);
-      this.pendingWriteConcernPromises.delete(opId);
-    }
-  }
-  /**
-   * Cancel all pending Write Concern promises (e.g., on disconnect).
-   */
-  cancelAllWriteConcernPromises(error) {
-    for (const [opId, pending] of this.pendingWriteConcernPromises.entries()) {
-      if (pending.timeoutHandle) {
-        clearTimeout(pending.timeoutHandle);
-      }
-      pending.reject(error);
-    }
-    this.pendingWriteConcernPromises.clear();
+    return this.writeConcernManager.registerWriteConcernPromise(opId, timeout);
   }
+  // ============================================
+  // PN Counter Methods - Delegates to CounterManager
+  // ============================================
   /**
    * Subscribe to counter updates from server.
+   * Delegates to CounterManager.
    * @param name Counter name
    * @param listener Callback when counter state is updated
    * @returns Unsubscribe function
    */
   onCounterUpdate(name, listener) {
-    if (!this.counterUpdateListeners.has(name)) {
-      this.counterUpdateListeners.set(name, /* @__PURE__ */ new Set());
-    }
-    this.counterUpdateListeners.get(name).add(listener);
-    return () => {
-      this.counterUpdateListeners.get(name)?.delete(listener);
-      if (this.counterUpdateListeners.get(name)?.size === 0) {
-        this.counterUpdateListeners.delete(name);
-      }
-    };
+    return this.counterManager.onCounterUpdate(name, listener);
   }
   /**
    * Request initial counter state from server.
-   * @param name Counter name
-   */
-  requestCounter(name) {
-    if (this.isAuthenticated()) {
-      this.sendMessage({
-        type: "COUNTER_REQUEST",
-        payload: { name }
-      });
-    }
-  }
-  /**
-   * Sync local counter state to server.
-   * @param name Counter name
-   * @param state Counter state to sync
-   */
-  syncCounter(name, state) {
-    if (this.isAuthenticated()) {
-      const stateObj = {
-        positive: Object.fromEntries(state.positive),
-        negative: Object.fromEntries(state.negative)
-      };
-      this.sendMessage({
-        type: "COUNTER_SYNC",
-        payload: {
-          name,
-          state: stateObj
-        }
-      });
-    }
-  }
-  /**
-   * Handle incoming counter update from server.
-   * Called by handleServerMessage for COUNTER_UPDATE messages.
-   */
-  handleCounterUpdate(name, stateObj) {
-    const state = {
-      positive: new Map(Object.entries(stateObj.positive)),
-      negative: new Map(Object.entries(stateObj.negative))
-    };
-    const listeners = this.counterUpdateListeners.get(name);
-    if (listeners) {
-      for (const listener of listeners) {
-        try {
-          listener(state);
-        } catch (e) {
-          logger.error({ err: e, counterName: name }, "Counter update listener error");
-        }
-      }
-    }
-  }
-  /**
-   * Execute an entry processor on a single key atomically.
-   *
-   * @param mapName Name of the map
-   * @param key Key to process
-   * @param processor Processor definition
-   * @returns Promise resolving to the processor result
-   */
-  async executeOnKey(mapName, key, processor) {
-    if (!this.isAuthenticated()) {
-      return {
-        success: false,
-        error: "Not connected to server"
-      };
-    }
-    const requestId = crypto.randomUUID();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingProcessorRequests.delete(requestId);
-        reject(new Error("Entry processor request timed out"));
-      }, _SyncEngine.PROCESSOR_TIMEOUT);
-      this.pendingProcessorRequests.set(requestId, {
-        resolve: (result) => {
-          clearTimeout(timeout);
-          resolve(result);
-        },
-        reject,
-        timeout
-      });
-      const sent = this.sendMessage({
-        type: "ENTRY_PROCESS",
-        requestId,
-        mapName,
-        key,
-        processor: {
-          name: processor.name,
-          code: processor.code,
-          args: processor.args
-        }
-      }, key);
-      if (!sent) {
-        this.pendingProcessorRequests.delete(requestId);
-        clearTimeout(timeout);
-        reject(new Error("Failed to send entry processor request"));
-      }
-    });
+   * Delegates to CounterManager.
+   * @param name Counter name
+   */
+  requestCounter(name) {
+    this.counterManager.requestCounter(name);
+  }
+  /**
+   * Sync local counter state to server.
+   * Delegates to CounterManager.
+   * @param name Counter name
+   * @param state Counter state to sync
+   */
+  syncCounter(name, state) {
+    this.counterManager.syncCounter(name, state);
+  }
+  // ============================================
+  // Entry Processor Methods - Delegates to EntryProcessorClient
+  // ============================================
+  /**
+   * Execute an entry processor on a single key atomically.
+   * Delegates to EntryProcessorClient.
+   *
+   * @param mapName Name of the map
+   * @param key Key to process
+   * @param processor Processor definition
+   * @returns Promise resolving to the processor result
+   */
+  async executeOnKey(mapName, key, processor) {
+    return this.entryProcessorClient.executeOnKey(mapName, key, processor);
   }
   /**
    * Execute an entry processor on multiple keys.
+   * Delegates to EntryProcessorClient.
    *
    * @param mapName Name of the map
    * @param keys Keys to process
@@ -2259,84 +3013,7 @@ var _SyncEngine = class _SyncEngine {
    * @returns Promise resolving to a map of key -> result
    */
   async executeOnKeys(mapName, keys, processor) {
-    if (!this.isAuthenticated()) {
-      const results = /* @__PURE__ */ new Map();
-      const error = {
-        success: false,
-        error: "Not connected to server"
-      };
-      for (const key of keys) {
-        results.set(key, error);
-      }
-      return results;
-    }
-    const requestId = crypto.randomUUID();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingBatchProcessorRequests.delete(requestId);
-        reject(new Error("Entry processor batch request timed out"));
-      }, _SyncEngine.PROCESSOR_TIMEOUT);
-      this.pendingBatchProcessorRequests.set(requestId, {
-        resolve: (results) => {
-          clearTimeout(timeout);
-          resolve(results);
-        },
-        reject,
-        timeout
-      });
-      const sent = this.sendMessage({
-        type: "ENTRY_PROCESS_BATCH",
-        requestId,
-        mapName,
-        keys,
-        processor: {
-          name: processor.name,
-          code: processor.code,
-          args: processor.args
-        }
-      });
-      if (!sent) {
-        this.pendingBatchProcessorRequests.delete(requestId);
-        clearTimeout(timeout);
-        reject(new Error("Failed to send entry processor batch request"));
-      }
-    });
-  }
-  /**
-   * Handle entry processor response from server.
-   * Called by handleServerMessage for ENTRY_PROCESS_RESPONSE messages.
-   */
-  handleEntryProcessResponse(message) {
-    const pending = this.pendingProcessorRequests.get(message.requestId);
-    if (pending) {
-      this.pendingProcessorRequests.delete(message.requestId);
-      pending.resolve({
-        success: message.success,
-        result: message.result,
-        newValue: message.newValue,
-        error: message.error
-      });
-    }
-  }
-  /**
-   * Handle entry processor batch response from server.
-   * Called by handleServerMessage for ENTRY_PROCESS_BATCH_RESPONSE messages.
-   */
-  handleEntryProcessBatchResponse(message) {
-    const pending = this.pendingBatchProcessorRequests.get(message.requestId);
-    if (pending) {
-      this.pendingBatchProcessorRequests.delete(message.requestId);
-      const resultsMap = /* @__PURE__ */ new Map();
-      for (const [key, result] of Object.entries(message.results)) {
-        resultsMap.set(key, {
-          success: result.success,
-          result: result.result,
-          newValue: result.newValue,
-          error: result.error
-        });
-      }
-      pending.resolve(resultsMap);
-    }
+    return this.entryProcessorClient.executeOnKeys(mapName, keys, processor);
   }
   /**
    * Subscribe to all incoming messages.
@@ -2383,8 +3060,12 @@ var _SyncEngine = class _SyncEngine {
       }
     }
   }
+  // ============================================
+  // Full-Text Search Methods - Delegates to SearchClient
+  // ============================================
   /**
    * Perform a one-shot BM25 search on the server.
+   * Delegates to SearchClient.
    *
    * @param mapName Name of the map to search
    * @param query Search query text
@@ -2392,58 +3073,10 @@ var _SyncEngine = class _SyncEngine {
    * @returns Promise resolving to search results
    */
   async search(mapName, query, options) {
-    if (!this.isAuthenticated()) {
-      throw new Error("Not connected to server");
-    }
-    const requestId = crypto.randomUUID();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingSearchRequests.delete(requestId);
-        reject(new Error("Search request timed out"));
-      }, _SyncEngine.SEARCH_TIMEOUT);
-      this.pendingSearchRequests.set(requestId, {
-        resolve: (results) => {
-          clearTimeout(timeout);
-          resolve(results);
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          reject(error);
-        },
-        timeout
-      });
-      const sent = this.sendMessage({
-        type: "SEARCH",
-        payload: {
-          requestId,
-          mapName,
-          query,
-          options
-        }
-      });
-      if (!sent) {
-        this.pendingSearchRequests.delete(requestId);
-        clearTimeout(timeout);
-        reject(new Error("Failed to send search request"));
-      }
-    });
-  }
-  /**
-   * Handle search response from server.
-   */
-  handleSearchResponse(payload) {
-    const pending = this.pendingSearchRequests.get(payload.requestId);
-    if (pending) {
-      this.pendingSearchRequests.delete(payload.requestId);
-      if (payload.error) {
-        pending.reject(new Error(payload.error));
-      } else {
-        pending.resolve(payload.results);
-      }
-    }
+    return this.searchClient.search(mapName, query, options);
   }
   // ============================================
-  // Conflict Resolver Client (Phase 5.05)
+  // Conflict Resolver Client
   // ============================================
   /**
    * Get the conflict resolver client for registering custom resolvers
@@ -2452,132 +3085,35 @@ var _SyncEngine = class _SyncEngine {
   getConflictResolverClient() {
     return this.conflictResolverClient;
   }
-  /**
-   * Subscribe to a hybrid query (FTS + filter combination).
-   */
-  subscribeToHybridQuery(query) {
-    this.hybridQueries.set(query.id, query);
-    const filter = query.getFilter();
-    const mapName = query.getMapName();
-    if (query.hasFTSPredicate() && this.stateMachine.getState() === "CONNECTED" /* CONNECTED */) {
-      this.sendHybridQuerySubscription(query.id, mapName, filter);
-    }
-    this.runLocalHybridQuery(mapName, filter).then((results) => {
-      query.onResult(results, "local");
-    });
-  }
-  /**
-   * Unsubscribe from a hybrid query.
-   */
-  unsubscribeFromHybridQuery(queryId) {
-    const query = this.hybridQueries.get(queryId);
-    if (query) {
-      this.hybridQueries.delete(queryId);
-      if (this.stateMachine.getState() === "CONNECTED" /* CONNECTED */ && query.hasFTSPredicate()) {
-        this.sendMessage({
-          type: "HYBRID_QUERY_UNSUBSCRIBE",
-          payload: { subscriptionId: queryId }
-        });
-      }
-    }
-  }
-  /**
-   * Send hybrid query subscription to server.
-   */
-  sendHybridQuerySubscription(queryId, mapName, filter) {
-    this.sendMessage({
-      type: "HYBRID_QUERY_SUBSCRIBE",
-      payload: {
-        subscriptionId: queryId,
-        mapName,
-        predicate: filter.predicate,
-        where: filter.where,
-        sort: filter.sort,
-        limit: filter.limit,
-        cursor: filter.cursor
-        // Phase 14.1: replaces offset
-      }
-    });
-  }
-  /**
-   * Run a local hybrid query (FTS + filter combination).
-   * For FTS predicates, returns results with score = 0 (local-only mode).
-   * Server provides actual FTS scoring.
-   */
-  async runLocalHybridQuery(mapName, filter) {
-    if (!this.storageAdapter) {
-      return [];
-    }
-    const results = [];
-    const allKeys = await this.storageAdapter.getAllKeys();
-    const mapPrefix = `${mapName}:`;
-    const entries = [];
-    for (const fullKey of allKeys) {
-      if (fullKey.startsWith(mapPrefix)) {
-        const key = fullKey.substring(mapPrefix.length);
-        const record = await this.storageAdapter.get(fullKey);
-        if (record) {
-          entries.push([key, record]);
-        }
-      }
-    }
-    for (const [key, record] of entries) {
-      if (record === null || record.value === null) continue;
-      const value = record.value;
-      if (filter.predicate) {
-        const matches = evaluatePredicate(filter.predicate, value);
-        if (!matches) continue;
-      }
-      if (filter.where) {
-        let whereMatches = true;
-        for (const [field, expected] of Object.entries(filter.where)) {
-          if (value[field] !== expected) {
-            whereMatches = false;
-            break;
-          }
-        }
-        if (!whereMatches) continue;
-      }
-      results.push({
-        key,
-        value,
-        score: 0,
-        // Local doesn't have FTS scoring
-        matchedTerms: []
-      });
-    }
-    if (filter.sort) {
-      results.sort((a, b) => {
-        for (const [field, direction] of Object.entries(filter.sort)) {
-          let valA;
-          let valB;
-          if (field === "_score") {
-            valA = a.score ?? 0;
-            valB = b.score ?? 0;
-          } else if (field === "_key") {
-            valA = a.key;
-            valB = b.key;
-          } else {
-            valA = a.value[field];
-            valB = b.value[field];
-          }
-          if (valA < valB) return direction === "asc" ? -1 : 1;
-          if (valA > valB) return direction === "asc" ? 1 : -1;
-        }
-        return 0;
-      });
-    }
-    let sliced = results;
-    if (filter.limit) {
-      sliced = sliced.slice(0, filter.limit);
-    }
-    return sliced;
+  // ============================================
+  // Hybrid Query Support - Delegates to QueryManager
+  // ============================================
+  /**
+   * Subscribe to a hybrid query (FTS + filter combination).
+   * Delegates to QueryManager.
+   */
+  subscribeToHybridQuery(query) {
+    this.queryManager.subscribeToHybridQuery(query);
+  }
+  /**
+   * Unsubscribe from a hybrid query.
+   * Delegates to QueryManager.
+   */
+  unsubscribeFromHybridQuery(queryId) {
+    this.queryManager.unsubscribeFromHybridQuery(queryId);
+  }
+  /**
+   * Run a local hybrid query (FTS + filter combination).
+   * Delegates to QueryManager.
+   */
+  async runLocalHybridQuery(mapName, filter) {
+    return this.queryManager.runLocalHybridQuery(mapName, filter);
   }
   /**
    * Handle hybrid query response from server.
    */
   handleHybridQueryResponse(payload) {
-    const query = this.hybridQueries.get(payload.subscriptionId);
+    const query = this.queryManager.getHybridQuery(payload.subscriptionId);
     if (query) {
       query.onResult(payload.results, "server");
       query.updatePaginationInfo({
@@ -2591,7 +3127,7 @@ var _SyncEngine = class _SyncEngine {
    * Handle hybrid query delta update from server.
    */
   handleHybridQueryDelta(payload) {
-    const query = this.hybridQueries.get(payload.subscriptionId);
+    const query = this.queryManager.getHybridQuery(payload.subscriptionId);
     if (query) {
       if (payload.type === "LEAVE") {
         query.onUpdate(payload.key, null);
@@ -2601,14 +3137,9 @@ var _SyncEngine = class _SyncEngine {
     }
   }
 };
-/** Default timeout for entry processor requests (ms) */
-_SyncEngine.PROCESSOR_TIMEOUT = 3e4;
-/** Default timeout for search requests (ms) */
-_SyncEngine.SEARCH_TIMEOUT = 3e4;
-var SyncEngine = _SyncEngine;
 
 // src/TopGunClient.ts
-import { LWWMap as LWWMap2, ORMap as ORMap2 } from "@topgunbuild/core";
+import { LWWMap as LWWMap3, ORMap as ORMap3 } from "@topgunbuild/core";
 
 // src/utils/deepEqual.ts
 function deepEqual(a, b) {
@@ -2703,11 +3234,11 @@ var QueryHandle = class {
   constructor(syncEngine, mapName, filter = {}) {
     this.listeners = /* @__PURE__ */ new Set();
     this.currentResults = /* @__PURE__ */ new Map();
-    // Change tracking (Phase 5.1)
+    // Change tracking for delta notifications
     this.changeTracker = new ChangeTracker();
     this.pendingChanges = [];
     this.changeListeners = /* @__PURE__ */ new Set();
-    // Pagination info (Phase 14.1)
+    // Pagination info
     this._paginationInfo = { hasMore: false, cursorStatus: "none" };
     this.paginationListeners = /* @__PURE__ */ new Set();
     // Track if we've received authoritative server response
@@ -2804,7 +3335,7 @@ var QueryHandle = class {
     this.notify();
   }
   /**
-   * Subscribe to change events (Phase 5.1).
+   * Subscribe to change events.
    * Returns an unsubscribe function.
    *
    * @example
@@ -2823,7 +3354,7 @@ var QueryHandle = class {
     return () => this.changeListeners.delete(listener);
   }
   /**
-   * Get and clear pending changes (Phase 5.1).
+   * Get and clear pending changes.
    * Call this to retrieve all changes since the last consume.
    */
   consumeChanges() {
@@ -2832,26 +3363,26 @@ var QueryHandle = class {
     return changes;
   }
   /**
-   * Get last change without consuming (Phase 5.1).
+   * Get last change without consuming.
    * Returns null if no pending changes.
    */
   getLastChange() {
     return this.pendingChanges.length > 0 ? this.pendingChanges[this.pendingChanges.length - 1] : null;
   }
   /**
-   * Get all pending changes without consuming (Phase 5.1).
+   * Get all pending changes without consuming.
    */
   getPendingChanges() {
     return [...this.pendingChanges];
   }
   /**
-   * Clear all pending changes (Phase 5.1).
+   * Clear all pending changes.
    */
   clearChanges() {
     this.pendingChanges = [];
   }
   /**
-   * Reset change tracker (Phase 5.1).
+   * Reset change tracker.
    * Use when query filter changes or on reconnect.
    */
   resetChangeTracker() {
@@ -2903,7 +3434,7 @@ var QueryHandle = class {
   getMapName() {
     return this.mapName;
   }
-  // ============== Pagination Methods (Phase 14.1) ==============
+  // ============== Pagination Methods ==============
   /**
    * Get current pagination info.
    * Returns nextCursor, hasMore, and cursorStatus.
@@ -3022,7 +3553,7 @@ var TopicHandle = class {
       try {
         cb(data, context);
       } catch (e) {
-        console.error("Error in topic listener", e);
+        logger.error({ err: e, topic: this.topic, context: "listener" }, "Error in topic listener");
       }
     });
   }
@@ -3520,7 +4051,7 @@ var SearchHandle = class {
       try {
         listener(results);
       } catch (err) {
-        console.error("SearchHandle listener error:", err);
+        logger.error({ err, mapName: this.mapName, context: "listener" }, "SearchHandle listener error");
       }
     }
   }
@@ -3537,7 +4068,7 @@ var HybridQueryHandle = class {
     this.changeListeners = /* @__PURE__ */ new Set();
     // Track server data reception
     this.hasReceivedServerData = false;
-    // Pagination info (Phase 14.1)
+    // Pagination info
     this._paginationInfo = { hasMore: false, cursorStatus: "none" };
     this.paginationListeners = /* @__PURE__ */ new Set();
     this.id = crypto.randomUUID();
@@ -3754,7 +4285,7 @@ var HybridQueryHandle = class {
     }
     return false;
   }
-  // ============== Pagination Methods (Phase 14.1) ==============
+  // ============== Pagination Methods ==============
   /**
    * Get current pagination info.
    * Returns nextCursor, hasMore, and cursorStatus.
@@ -3811,7 +4342,7 @@ import {
 import {
   DEFAULT_CONNECTION_POOL_CONFIG
 } from "@topgunbuild/core";
-import { serialize as serialize2, deserialize as deserialize2 } from "@topgunbuild/core";
+import { serialize as serialize2, deserialize as deserialize3 } from "@topgunbuild/core";
 var ConnectionPool = class {
   constructor(config = {}) {
     this.listeners = /* @__PURE__ */ new Map();
@@ -4112,7 +4643,7 @@ var ConnectionPool = class {
     let message;
     try {
       if (event.data instanceof ArrayBuffer) {
-        message = deserialize2(new Uint8Array(event.data));
+        message = deserialize3(new Uint8Array(event.data));
       } else {
         message = JSON.parse(event.data);
       }
@@ -4904,16 +5435,6 @@ var ClusterClient = class {
   setAuthToken(token) {
     this.connectionPool.setAuthToken(token);
   }
-  /**
-   * Send operation with automatic routing (legacy API for cluster operations).
-   * @deprecated Use send(data, key) for IConnectionProvider interface
-   */
-  sendMessage(key, message) {
-    if (this.config.routingMode === "direct" && this.routingActive) {
-      return this.sendDirect(key, message);
-    }
-    return this.sendForward(message);
-  }
   /**
    * Send directly to partition owner
    */
@@ -5225,6 +5746,233 @@ var ClusterClient = class {
   }
 };
 
+// src/connection/SingleServerProvider.ts
+var DEFAULT_CONFIG = {
+  maxReconnectAttempts: 10,
+  reconnectDelayMs: 1e3,
+  backoffMultiplier: 2,
+  maxReconnectDelayMs: 3e4
+};
+var SingleServerProvider = class {
+  constructor(config) {
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.isClosing = false;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.url = config.url;
+    this.config = {
+      url: config.url,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? DEFAULT_CONFIG.maxReconnectAttempts,
+      reconnectDelayMs: config.reconnectDelayMs ?? DEFAULT_CONFIG.reconnectDelayMs,
+      backoffMultiplier: config.backoffMultiplier ?? DEFAULT_CONFIG.backoffMultiplier,
+      maxReconnectDelayMs: config.maxReconnectDelayMs ?? DEFAULT_CONFIG.maxReconnectDelayMs
+    };
+  }
+  /**
+   * Connect to the WebSocket server.
+   */
+  async connect() {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    this.isClosing = false;
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocket(this.url);
+        this.ws.binaryType = "arraybuffer";
+        this.ws.onopen = () => {
+          this.reconnectAttempts = 0;
+          logger.info({ url: this.url }, "SingleServerProvider connected");
+          this.emit("connected", "default");
+          resolve();
+        };
+        this.ws.onerror = (error) => {
+          logger.error({ err: error, url: this.url }, "SingleServerProvider WebSocket error");
+          this.emit("error", error);
+        };
+        this.ws.onclose = (event) => {
+          logger.info({ url: this.url, code: event.code }, "SingleServerProvider disconnected");
+          this.emit("disconnected", "default");
+          if (!this.isClosing) {
+            this.scheduleReconnect();
+          }
+        };
+        this.ws.onmessage = (event) => {
+          this.emit("message", "default", event.data);
+        };
+        const timeoutId = setTimeout(() => {
+          if (this.ws && this.ws.readyState === WebSocket.CONNECTING) {
+            this.ws.close();
+            reject(new Error(`Connection timeout to ${this.url}`));
+          }
+        }, this.config.reconnectDelayMs * 5);
+        const originalOnOpen = this.ws.onopen;
+        const wsRef = this.ws;
+        this.ws.onopen = (ev) => {
+          clearTimeout(timeoutId);
+          if (originalOnOpen) {
+            originalOnOpen.call(wsRef, ev);
+          }
+        };
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Get connection for a specific key.
+   * In single-server mode, key is ignored.
+   */
+  getConnection(_key) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected");
+    }
+    return this.ws;
+  }
+  /**
+   * Get any available connection.
+   */
+  getAnyConnection() {
+    return this.getConnection("");
+  }
+  /**
+   * Check if connected.
+   */
+  isConnected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  /**
+   * Get connected node IDs.
+   * Single-server mode returns ['default'] when connected.
+   */
+  getConnectedNodes() {
+    return this.isConnected() ? ["default"] : [];
+  }
+  /**
+   * Subscribe to connection events.
+   */
+  on(event, handler2) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler2);
+  }
+  /**
+   * Unsubscribe from connection events.
+   */
+  off(event, handler2) {
+    this.listeners.get(event)?.delete(handler2);
+  }
+  /**
+   * Send data via the WebSocket connection.
+   * In single-server mode, key parameter is ignored.
+   */
+  send(data, _key) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected");
+    }
+    this.ws.send(data);
+  }
+  /**
+   * Close the WebSocket connection.
+   */
+  async close() {
+    this.isClosing = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      if (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+    logger.info({ url: this.url }, "SingleServerProvider closed");
+  }
+  /**
+   * Emit an event to all listeners.
+   */
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler2 of handlers) {
+        try {
+          handler2(...args);
+        } catch (err) {
+          logger.error({ err, event }, "Error in SingleServerProvider event handler");
+        }
+      }
+    }
+  }
+  /**
+   * Schedule a reconnection attempt with exponential backoff.
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      logger.error(
+        { attempts: this.reconnectAttempts, url: this.url },
+        "SingleServerProvider max reconnect attempts reached"
+      );
+      this.emit("error", new Error("Max reconnection attempts reached"));
+      return;
+    }
+    const delay = this.calculateBackoffDelay();
+    logger.info(
+      { delay, attempt: this.reconnectAttempts, url: this.url },
+      `SingleServerProvider scheduling reconnect in ${delay}ms`
+    );
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      this.reconnectAttempts++;
+      try {
+        await this.connect();
+        this.emit("reconnected", "default");
+      } catch (error) {
+        logger.error({ err: error }, "SingleServerProvider reconnection failed");
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  /**
+   * Calculate backoff delay with exponential increase.
+   */
+  calculateBackoffDelay() {
+    const { reconnectDelayMs, backoffMultiplier, maxReconnectDelayMs } = this.config;
+    let delay = reconnectDelayMs * Math.pow(backoffMultiplier, this.reconnectAttempts);
+    delay = Math.min(delay, maxReconnectDelayMs);
+    delay = delay * (0.5 + Math.random());
+    return Math.floor(delay);
+  }
+  /**
+   * Get the WebSocket URL this provider connects to.
+   */
+  getUrl() {
+    return this.url;
+  }
+  /**
+   * Get current reconnection attempt count.
+   */
+  getReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Reset reconnection counter.
+   * Called externally after successful authentication.
+   */
+  resetReconnectAttempts() {
+    this.reconnectAttempts = 0;
+  }
+};
+
 // src/TopGunClient.ts
 var DEFAULT_CLUSTER_CONFIG = {
   connectionsPerNode: 1,
@@ -5280,9 +6028,10 @@ var TopGunClient = class {
       });
       logger.info({ seeds: this.clusterConfig.seeds }, "TopGunClient initialized in cluster mode");
     } else {
+      const singleServerProvider = new SingleServerProvider({ url: config.serverUrl });
       this.syncEngine = new SyncEngine({
         nodeId: this.nodeId,
-        serverUrl: config.serverUrl,
+        connectionProvider: singleServerProvider,
         storageAdapter: this.storageAdapter,
         backoff: config.backoff,
         backpressure: config.backpressure
@@ -5358,12 +6107,12 @@ var TopGunClient = class {
   getMap(name) {
     if (this.maps.has(name)) {
       const map = this.maps.get(name);
-      if (map instanceof LWWMap2) {
+      if (map instanceof LWWMap3) {
         return map;
       }
       throw new Error(`Map ${name} exists but is not an LWWMap`);
     }
-    const lwwMap = new LWWMap2(this.syncEngine.getHLC());
+    const lwwMap = new LWWMap3(this.syncEngine.getHLC());
     this.maps.set(name, lwwMap);
     this.syncEngine.registerMap(name, lwwMap);
     this.storageAdapter.getAllKeys().then(async (keys) => {
@@ -5402,12 +6151,12 @@ var TopGunClient = class {
   getORMap(name) {
     if (this.maps.has(name)) {
       const map = this.maps.get(name);
-      if (map instanceof ORMap2) {
+      if (map instanceof ORMap3) {
         return map;
       }
       throw new Error(`Map ${name} exists but is not an ORMap`);
     }
-    const orMap = new ORMap2(this.syncEngine.getHLC());
+    const orMap = new ORMap3(this.syncEngine.getHLC());
     this.maps.set(name, orMap);
     this.syncEngine.registerMap(name, orMap);
     this.restoreORMap(name, orMap);
@@ -5623,7 +6372,7 @@ var TopGunClient = class {
     return this.syncEngine.onBackpressure(event, listener);
   }
   // ============================================
-  // Full-Text Search API (Phase 11.1a)
+  // Full-Text Search API
   // ============================================
   /**
    * Perform a one-shot BM25 search on the server.
@@ -5653,7 +6402,7 @@ var TopGunClient = class {
     return this.syncEngine.search(mapName, query, options);
   }
   // ============================================
-  // Live Search API (Phase 11.1b)
+  // Live Search API
   // ============================================
   /**
    * Subscribe to live search results with real-time updates.
@@ -5693,7 +6442,7 @@ var TopGunClient = class {
     return new SearchHandle(this.syncEngine, mapName, query, options);
   }
   // ============================================
-  // Hybrid Query API (Phase 12)
+  // Hybrid Query API
   // ============================================
   /**
    * Create a hybrid query combining FTS with traditional filters.
@@ -5730,7 +6479,7 @@ var TopGunClient = class {
     return new HybridQueryHandle(this.syncEngine, mapName, filter);
   }
   // ============================================
-  // Entry Processor API (Phase 5.03)
+  // Entry Processor API
   // ============================================
   /**
    * Execute an entry processor on a single key atomically.
@@ -5767,7 +6516,7 @@ var TopGunClient = class {
     const result = await this.syncEngine.executeOnKey(mapName, key, processor);
     if (result.success && result.newValue !== void 0) {
       const map = this.maps.get(mapName);
-      if (map instanceof LWWMap2) {
+      if (map instanceof LWWMap3) {
         map.set(key, result.newValue);
       }
     }
@@ -5804,7 +6553,7 @@ var TopGunClient = class {
   async executeOnKeys(mapName, keys, processor) {
     const results = await this.syncEngine.executeOnKeys(mapName, keys, processor);
     const map = this.maps.get(mapName);
-    if (map instanceof LWWMap2) {
+    if (map instanceof LWWMap3) {
       for (const [key, result] of results) {
         if (result.success && result.newValue !== void 0) {
           map.set(key, result.newValue);
@@ -5851,7 +6600,7 @@ var TopGunClient = class {
     return this.journalReader;
   }
   // ============================================
-  // Conflict Resolver API (Phase 5.05)
+  // Conflict Resolver API
   // ============================================
   /**
    * Get the conflict resolver client for registering custom merge resolvers.
@@ -6110,7 +6859,7 @@ var TopGun = class {
       nodeId: config.nodeId
     });
     this.initPromise = this.client.start().catch((err) => {
-      console.error("Failed to start TopGun client:", err);
+      logger.error({ err, context: "client_start" }, "Failed to start TopGun client");
       throw err;
     });
     return new Proxy(this, handler);
@@ -6165,7 +6914,7 @@ var CollectionWrapper = class {
 };
 
 // src/crypto/EncryptionManager.ts
-import { serialize as serialize4, deserialize as deserialize3 } from "@topgunbuild/core";
+import { serialize as serialize4, deserialize as deserialize4 } from "@topgunbuild/core";
 var _EncryptionManager = class _EncryptionManager {
   /**
    * Encrypts data using AES-GCM.
@@ -6201,9 +6950,9 @@ var _EncryptionManager = class _EncryptionManager {
         key,
         record.data
       );
-      return deserialize3(new Uint8Array(plaintextBuffer));
+      return deserialize4(new Uint8Array(plaintextBuffer));
     } catch (err) {
-      console.error("Decryption failed", err);
+      logger.error({ err, context: "decryption" }, "Decryption failed");
       throw new Error("Failed to decrypt data: " + err);
     }
   }
@@ -6325,7 +7074,7 @@ var EncryptedStorageAdapter = class {
 };
 
 // src/index.ts
-import { LWWMap as LWWMap3, Predicates } from "@topgunbuild/core";
+import { LWWMap as LWWMap4, Predicates } from "@topgunbuild/core";
 export {
   BackpressureError,
   ChangeTracker,
@@ -6338,7 +7087,7 @@ export {
   EventJournalReader,
   HybridQueryHandle,
   IDBAdapter,
-  LWWMap3 as LWWMap,
+  LWWMap4 as LWWMap,
   PNCounterHandle,
   PartitionRouter,
   Predicates,