@synclib-io/sync 0.1.0

package/dist/index.js

@@ -0,0 +1,2843 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChannelRole: () => ChannelRole,
+  ConnectionState: () => ConnectionState,
+  MessageFactory: () => MessageFactory,
+  RepairDirection: () => RepairDirection,
+  SyncClient: () => SyncClient,
+  SyncReadyState: () => SyncReadyState,
+  SyncState: () => SyncState,
+  WebSocketManager: () => WebSocketManager
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sync-client.ts
+var import_core = require("@synclib-io/core");
+
+// src/connection/websocket-manager.ts
+var import_phoenix = require("phoenix");
+
+// src/protocol/message.ts
+var MessageFactory = {
+  /**
+   * Create a HelloMessage
+   */
+  hello(clientId, schemaVersion = 0, lastSeqnum, metadata) {
+    return {
+      type: "hello",
+      client_id: clientId,
+      schema_version: schemaVersion,
+      last_seqnum: lastSeqnum,
+      metadata,
+      toMap() {
+        return {
+          type: "hello",
+          client_id: this.client_id,
+          schema_version: this.schema_version,
+          ...this.last_seqnum !== void 0 && { last_seqnum: this.last_seqnum },
+          ...this.metadata && { metadata: this.metadata }
+        };
+      }
+    };
+  },
+  /**
+   * Create a ChangeMessage from a synclib Change object
+   */
+  fromChange(change) {
+    return {
+      type: "change",
+      table: change.tableName,
+      operation: change.operation,
+      row_id: change.rowId,
+      data: change.data ? JSON.parse(change.data) : void 0,
+      seqnum: change.seqnum,
+      timestamp: /* @__PURE__ */ new Date(),
+      toMap() {
+        return {
+          type: "change",
+          table: this.table,
+          operation: this.operation,
+          row_id: this.row_id,
+          ...this.data && { data: this.data },
+          ...this.seqnum !== void 0 && { seqnum: this.seqnum },
+          ...this.timestamp && { timestamp: this.timestamp.toISOString() }
+        };
+      }
+    };
+  },
+  /**
+   * Create a ChangesBatchMessage
+   */
+  changesBatch(changes, fromSeqnum, toSeqnum) {
+    return {
+      type: "changes_batch",
+      changes,
+      from_seqnum: fromSeqnum,
+      to_seqnum: toSeqnum,
+      toMap() {
+        return {
+          type: "changes_batch",
+          changes: this.changes.map((c) => c.toMap()),
+          ...this.from_seqnum !== void 0 && { from_seqnum: this.from_seqnum },
+          ...this.to_seqnum !== void 0 && { to_seqnum: this.to_seqnum }
+        };
+      }
+    };
+  },
+  /**
+   * Create a RequestChangesMessage
+   */
+  requestChanges(sinceSeqnum, limit, table) {
+    return {
+      type: "request_changes",
+      since_seqnum: sinceSeqnum,
+      limit,
+      table,
+      toMap() {
+        return {
+          type: "request_changes",
+          since_seqnum: this.since_seqnum ?? 0,
+          ...this.limit !== void 0 && { limit: this.limit },
+          ...this.table && { table: this.table }
+        };
+      }
+    };
+  },
+  /**
+   * Create a SchemaConfirmMessage
+   */
+  schemaConfirm(version) {
+    return {
+      type: "schema_migrated",
+      version,
+      toMap() {
+        return {
+          type: "schema_migrated",
+          version: this.version
+        };
+      }
+    };
+  },
+  /**
+   * Parse a message from a map
+   */
+  fromMap(map) {
+    const type = map.type;
+    switch (type) {
+      case "change":
+        return {
+          type: "change",
+          table: map.table,
+          operation: map.operation,
+          row_id: map.row_id,
+          data: map.data,
+          seqnum: map.seqnum,
+          timestamp: map.timestamp ? typeof map.timestamp === "string" ? new Date(map.timestamp) : new Date(map.timestamp * 1e3) : void 0,
+          toMap() {
+            return map;
+          }
+        };
+      case "changes_batch":
+        return {
+          type: "changes_batch",
+          changes: map.changes.map((c) => MessageFactory.fromMap(c)),
+          from_seqnum: map.from_seqnum,
+          to_seqnum: map.to_seqnum,
+          toMap() {
+            return map;
+          }
+        };
+      case "ack":
+        return {
+          type: "ack",
+          seqnum: map.seqnum,
+          success: map.success,
+          error: map.error,
+          server_seqnum: map.server_seqnum,
+          row_hash: map.row_hash,
+          toMap() {
+            return map;
+          }
+        };
+      case "error":
+        return {
+          type: "error",
+          code: map.code,
+          message: map.message,
+          details: map.details,
+          toMap() {
+            return map;
+          }
+        };
+      case "phx_reply":
+        return {
+          type: "phx_reply",
+          status: map.status || "ok",
+          response: map,
+          toMap() {
+            return map;
+          }
+        };
+      case "snapshot_batch":
+        return {
+          type: "snapshot_batch",
+          stream_id: map.stream_id,
+          table: map.table,
+          rows: map.rows || [],
+          toMap() {
+            return map;
+          }
+        };
+      case "snapshot_complete":
+        return {
+          type: "snapshot_complete",
+          stream_id: map.stream_id,
+          channel_id: map.channel_id,
+          toMap() {
+            return map;
+          }
+        };
+      case "job_update":
+        return {
+          type: "job_update",
+          current_step: map.current_step,
+          total_steps: map.total_steps,
+          step_type: map.step_type,
+          job_id: map.job_id,
+          user_id: map.user_id,
+          phoenix_channel_id: map.phoenix_channel_id,
+          filename: map.filename,
+          toMap() {
+            return map;
+          }
+        };
+      case "schema_update":
+        return {
+          type: "schema_update",
+          new_version: map.new_version,
+          migrations: map.migrations,
+          timestamp: map.timestamp,
+          toMap() {
+            return map;
+          }
+        };
+      case "livestream:started":
+      case "livestream:stopped":
+        return {
+          type: map.type || map.event,
+          stream_id: map.stream_id,
+          tribe_id: map.tribe_id,
+          user_id: map.user_id,
+          hls_url: map.hls_url,
+          timestamp: map.timestamp || Math.floor(Date.now() / 1e3),
+          toMap() {
+            return map;
+          }
+        };
+      case "conversation:user_joined":
+      case "conversation:user_left":
+      case "conversation:message_sent":
+      case "conversation:online_count":
+        return {
+          type: map.type || map.event,
+          conversation_id: map.conversation_id,
+          user_id: map.user_id,
+          message_id: map.message_id,
+          online_count: map.online_count,
+          metadata: map.metadata,
+          timestamp: map.timestamp || Math.floor(Date.now() / 1e3),
+          toMap() {
+            return map;
+          }
+        };
+      // Unified sync protocol messages
+      case "change_acks":
+        return {
+          type: "change_acks",
+          stream_id: map.stream_id,
+          acks: map.acks || [],
+          toMap() {
+            return map;
+          }
+        };
+      case "sync_data_batch":
+      case "sync_batch":
+        return {
+          type: map.type,
+          stream_id: map.stream_id,
+          table: map.table,
+          rows: map.rows || [],
+          toMap() {
+            return map;
+          }
+        };
+      case "sync_complete":
+        return {
+          type: "sync_complete",
+          stream_id: map.stream_id,
+          schema_version: map.schema_version,
+          table_seqnums: map.table_seqnums || {},
+          stats: map.stats,
+          toMap() {
+            return map;
+          }
+        };
+      // Merkle tree integrity verification messages
+      case "merkle_verify":
+        return {
+          type: "merkle_verify",
+          table_hashes: map.table_hashes || {},
+          block_size: map.block_size,
+          toMap() {
+            return map;
+          }
+        };
+      case "merkle_verify_response":
+        return {
+          type: "merkle_verify_response",
+          status: map.status,
+          verified_tables: map.verified_tables,
+          mismatches: map.mismatches,
+          toMap() {
+            return map;
+          }
+        };
+      case "merkle_block_hashes":
+        return {
+          type: "merkle_block_hashes",
+          table: map.table,
+          block_hashes: map.block_hashes || [],
+          block_size: map.block_size,
+          toMap() {
+            return map;
+          }
+        };
+      case "merkle_block_hashes_response":
+        return {
+          type: "merkle_block_hashes_response",
+          table: map.table,
+          differing_blocks: map.differing_blocks || [],
+          toMap() {
+            return map;
+          }
+        };
+      case "merkle_fetch_blocks":
+        return {
+          type: "merkle_fetch_blocks",
+          table: map.table,
+          blocks: map.blocks || [],
+          block_size: map.block_size,
+          toMap() {
+            return map;
+          }
+        };
+      case "merkle_fetch_blocks_response":
+        return {
+          type: "merkle_fetch_blocks_response",
+          table: map.table,
+          block: map.block,
+          rows: map.rows || [],
+          toMap() {
+            return map;
+          }
+        };
+      default:
+        throw new Error(`Unknown message type: ${type}`);
+    }
+  }
+};
+
+// src/connection/websocket-manager.ts
+var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
+  ConnectionState2["DISCONNECTED"] = "disconnected";
+  ConnectionState2["CONNECTING"] = "connecting";
+  ConnectionState2["CONNECTED"] = "connected";
+  ConnectionState2["RECONNECTING"] = "reconnecting";
+  ConnectionState2["FAILED"] = "failed";
+  ConnectionState2["AUTH_FAILED"] = "auth_failed";
+  return ConnectionState2;
+})(ConnectionState || {});
+var _WebSocketManager = class _WebSocketManager {
+  constructor(url, reconnectDelay = 2e3, maxReconnectAttempts = 5) {
+    this.url = url;
+    this.reconnectDelay = reconnectDelay;
+    this.maxReconnectAttempts = maxReconnectAttempts;
+    this.socket = null;
+    this.channels = /* @__PURE__ */ new Map();
+    this.state = "disconnected" /* DISCONNECTED */;
+    this.messageListeners = /* @__PURE__ */ new Set();
+    this.stateListeners = /* @__PURE__ */ new Set();
+    this.reconnectAttempts = 0;
+    this.connectStartTime = 0;
+    this.intentionalDisconnect = false;
+    this.quickFailureCount = 0;
+    this.authFailureFired = false;
+  }
+  /**
+   * Register a callback fired when the connection is rejected due to auth
+   * (e.g. expired JWT). The callback can refresh the token via setToken() and
+   * then call connect() again to retry.
+   */
+  setOnAuthFailure(callback) {
+    this.onAuthFailureCallback = callback;
+  }
+  /**
+   * Update the JWT (or other auth param) used for subsequent connect/reconnect
+   * attempts. The Socket reads its `params` via a thunk so the next reconnect
+   * picks up the new value without recreating the socket.
+   *
+   * If the connection is currently in AUTH_FAILED (reconnects were halted), a
+   * fresh token implies the caller wants to retry — we tear down the failed
+   * socket, reset state, and schedule a new connect.
+   */
+  setToken(token) {
+    if (!this.connectionParams) this.connectionParams = {};
+    this.connectionParams.token = token;
+    this.authFailureFired = false;
+    this.quickFailureCount = 0;
+    if (this.state === "auth_failed" /* AUTH_FAILED */) {
+      try {
+        this.socket?.disconnect();
+      } catch (_) {
+      }
+      this.socket = null;
+      this.reconnectAttempts = 0;
+      this.updateState("disconnected" /* DISCONNECTED */);
+      this.connect().catch((e) => {
+        console.warn("Reconnect after setToken failed:", e);
+      });
+    }
+  }
+  /**
+   * Build the string params map from current connectionParams. Called on every
+   * Phoenix reconnect attempt so token refreshes (via setToken) take effect
+   * without tearing down the socket.
+   */
+  buildStringParams() {
+    const out = {};
+    if (this.connectionParams) {
+      for (const [key, value] of Object.entries(this.connectionParams)) {
+        out[key] = String(value);
+      }
+    }
+    return out;
+  }
+  /**
+   * Connect to WebSocket server
+   */
+  async connect(params) {
+    if (this.state === "connected" /* CONNECTED */ || this.state === "connecting" /* CONNECTING */) {
+      console.log("Already connected or connecting");
+      return;
+    }
+    this.intentionalDisconnect = false;
+    if (params) {
+      this.connectionParams = params;
+    }
+    this.updateState("connecting" /* CONNECTING */);
+    this.connectStartTime = Date.now();
+    console.log(`Connecting to ${this.url}`);
+    try {
+      this.socket = new import_phoenix.Socket(this.url, {
+        timeout: 1e4,
+        params: () => this.buildStringParams()
+      });
+      this.socket.onOpen(() => {
+        console.log("Socket opened");
+        this.updateState("connected" /* CONNECTED */);
+        this.reconnectAttempts = 0;
+        this.quickFailureCount = 0;
+      });
+      this.socket.onError((error) => {
+        console.error("Socket error:", error);
+        this.onError(error);
+      });
+      this.socket.onClose(() => {
+        console.warn("Socket closed");
+        this.onClose();
+      });
+      this.socket.connect();
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          reject(new Error("Connection timeout"));
+        }, 1e4);
+        const checkConnection = () => {
+          if (this.state === "connected" /* CONNECTED */) {
+            clearTimeout(timeout);
+            resolve();
+          } else if (this.state === "failed" /* FAILED */) {
+            clearTimeout(timeout);
+            reject(new Error("Connection failed"));
+          } else {
+            setTimeout(checkConnection, 100);
+          }
+        };
+        checkConnection();
+      });
+      console.log("Connect call completed");
+    } catch (e) {
+      console.error("Connection failed:", e);
+      this.updateState("failed" /* FAILED */);
+      this.scheduleReconnect();
+      throw e;
+    }
+  }
+  /**
+   * Join a Phoenix channel
+   */
+  async joinChannel(topic, params = {}) {
+    if (!this.isConnected()) {
+      throw new Error("Not connected to server");
+    }
+    try {
+      if (this.channels.has(topic)) {
+        console.log(`Channel ${topic} already exists, leaving old one`);
+        const oldChannel = this.channels.get(topic);
+        oldChannel?.leave();
+        this.channels.delete(topic);
+      }
+      const channel = this.socket.channel(topic, params);
+      const eventTypes = [
+        "snapshot_batch",
+        "snapshot_complete",
+        "change",
+        "changes_batch",
+        "ack",
+        "error",
+        "schema_update",
+        "job_update",
+        // Unified sync events
+        "sync_complete",
+        "sync_data_batch",
+        "sync_batch",
+        "change_acks",
+        // Livestream events
+        "livestream:started",
+        "livestream:stopped",
+        // Conversation events
+        "conversation:user_joined",
+        "conversation:user_left",
+        "conversation:message_sent",
+        "conversation:online_count"
+      ];
+      for (const eventType of eventTypes) {
+        channel.on(eventType, (payload) => {
+          this.handleIncomingMessage(eventType, payload);
+        });
+      }
+      const joinPush = channel.join();
+      const joinResponse = await new Promise((resolve, reject) => {
+        joinPush.receive("ok", (response) => {
+          this.channels.set(topic, channel);
+          console.log(`Joined channel: ${topic}`, response);
+          resolve(response ?? {});
+        }).receive("error", (error) => {
+          console.error(`Failed to join channel: ${topic}`, error);
+          reject(new Error(`Failed to join channel: ${JSON.stringify(error)}`));
+        }).receive("timeout", () => {
+          console.error(`Timeout joining channel: ${topic}`);
+          reject(new Error("Channel join timeout"));
+        });
+      });
+      return joinResponse;
+    } catch (e) {
+      console.error("Failed to join channel:", e);
+      throw e;
+    }
+  }
+  /**
+   * Check if a channel is currently joined
+   */
+  isChannelJoined(topic) {
+    return this.channels.has(topic);
+  }
+  /**
+   * Get all currently joined channel topics
+   */
+  getJoinedChannels() {
+    return Array.from(this.channels.keys());
+  }
+  /**
+   * Leave a specific channel by topic
+   */
+  async leaveChannel(topic) {
+    const channel = this.channels.get(topic);
+    if (!channel) {
+      console.warn(`Channel ${topic} not found`);
+      return;
+    }
+    console.log(`Leaving channel: ${topic}`);
+    channel.leave();
+    this.channels.delete(topic);
+    console.log(`Left channel: ${topic}`);
+  }
+  /**
+   * Disconnect from WebSocket server
+   */
+  async disconnect() {
+    console.log("Disconnecting");
+    this.intentionalDisconnect = true;
+    for (const channel of this.channels.values()) {
+      channel.leave();
+    }
+    this.channels.clear();
+    this.socket?.disconnect();
+    this.socket = null;
+    this.updateState("disconnected" /* DISCONNECTED */);
+  }
+  /**
+   * Send a message to the server
+   */
+  async send(message, channelTopic) {
+    if (!this.isConnected() || this.channels.size === 0) {
+      throw new Error("Not connected to channel");
+    }
+    try {
+      const map = message.toMap();
+      const event = map.type;
+      delete map.type;
+      console.log(`Sending event: ${event} with payload:`, map);
+      let channel;
+      if (channelTopic) {
+        for (const [topic, ch] of this.channels.entries()) {
+          if (topic === channelTopic) {
+            channel = ch;
+            break;
+          }
+        }
+      }
+      if (!channel) {
+        channel = Array.from(this.channels.values())[0];
+      }
+      if (!channel) {
+        throw new Error("No channel available");
+      }
+      console.log(`[WS DEBUG] Creating push for event: ${event}`);
+      const push = channel.push(event, map);
+      console.log(`[WS DEBUG] Push created, registering callbacks for: ${event}`);
+      await new Promise((resolve, reject) => {
+        push.receive("ok", (response) => {
+          console.log(`[WS DEBUG] Received 'ok' for ${event}:`, response);
+          if (response && typeof response === "object") {
+            this.handleChannelReply({ response });
+          }
+          resolve();
+        }).receive("error", (error) => {
+          console.error(`[WS DEBUG] Received 'error' for ${event}:`, error);
+          reject(new Error(`Failed to send: ${JSON.stringify(error)}`));
+        }).receive("timeout", () => {
+          console.error(`[WS DEBUG] Received 'timeout' for ${event}`);
+          reject(new Error("Send timeout"));
+        });
+        console.log(`[WS DEBUG] Callbacks registered for: ${event}`);
+      });
+    } catch (e) {
+      console.error("Failed to send message:", e);
+      throw e;
+    }
+  }
+  /**
+   * Send a raw message with custom event and payload, returns server response
+   */
+  async sendRaw(event, payload, channelTopic) {
+    if (!this.isConnected() || this.channels.size === 0) {
+      throw new Error("Not connected to channel");
+    }
+    try {
+      console.log(`Sending raw event: ${event} with payload:`, payload);
+      let channel;
+      if (channelTopic) {
+        for (const [topic, ch] of this.channels.entries()) {
+          if (topic === channelTopic) {
+            channel = ch;
+            break;
+          }
+        }
+      }
+      if (!channel) {
+        channel = Array.from(this.channels.values())[0];
+      }
+      if (!channel) {
+        throw new Error("No channel available");
+      }
+      const response = await new Promise((resolve, reject) => {
+        channel.push(event, payload).receive("ok", (resp) => {
+          console.log(
+            `Sent on channel ${channelTopic || "default"} raw message: ${event}, received response`
+          );
+          resolve(resp);
+        }).receive("error", (error) => {
+          console.error(`Failed to send raw message: ${event}`, error);
+          reject(new Error(`Server error: ${JSON.stringify(error)}`));
+        }).receive("timeout", () => {
+          console.error(`Timeout sending raw message: ${event}`);
+          reject(new Error("Request timeout"));
+        });
+      });
+      return response;
+    } catch (e) {
+      console.error("Failed to send raw message:", e);
+      throw e;
+    }
+  }
+  /**
+   * Handle incoming message
+   */
+  handleIncomingMessage(event, payload) {
+    try {
+      console.log(`Received Phoenix message: event=${event}, payload:`, payload);
+      if (event.startsWith("phx_") && event !== "phx_reply") {
+        console.log(`Skipping Phoenix system event: ${event}`);
+        return;
+      }
+      if (event.startsWith("chan_reply_")) {
+        this.handleChannelReply(payload);
+        return;
+      }
+      const messagePayload = { ...payload, type: event };
+      const syncMessage = MessageFactory.fromMap(messagePayload);
+      for (const listener of this.messageListeners) {
+        listener(syncMessage);
+      }
+      console.log(`Successfully decoded ${event} message and notified listeners`);
+    } catch (e) {
+      console.error("Failed to process message:", e);
+    }
+  }
+  /**
+   * Handle channel reply messages
+   */
+  handleChannelReply(payload) {
+    try {
+      const response = payload.response || {};
+      console.log("[WS DEBUG] handleChannelReply called with response:", response);
+      const replyPayload = { ...response, type: "phx_reply" };
+      console.log("[WS DEBUG] Creating phx_reply message from:", replyPayload);
+      const syncMessage = MessageFactory.fromMap(replyPayload);
+      console.log("[WS DEBUG] Created syncMessage:", syncMessage);
+      console.log(`[WS DEBUG] Notifying ${this.messageListeners.size} listeners`);
+      for (const listener of this.messageListeners) {
+        console.log("[WS DEBUG] Calling listener with syncMessage");
+        listener(syncMessage);
+      }
+      console.log("[WS DEBUG] Successfully processed channel reply");
+    } catch (e) {
+      console.error("[WS DEBUG] Failed to process channel reply:", e);
+    }
+  }
+  /**
+   * Handle WebSocket error
+   */
+  onError(error) {
+    console.error("WebSocket error:", error);
+    const timeSinceConnect = Date.now() - this.connectStartTime;
+    if (timeSinceConnect < 2e3 && this.state === "connecting" /* CONNECTING */) {
+      console.warn("Connection rejected quickly - likely auth failure (token expired?)");
+      this.updateState("auth_failed" /* AUTH_FAILED */);
+    } else {
+      this.updateState("failed" /* FAILED */);
+    }
+  }
+  /**
+   * Handle WebSocket close
+   */
+  onClose() {
+    console.warn("WebSocket connection closed");
+    if (this.state === "auth_failed" /* AUTH_FAILED */) {
+      console.warn("Not reconnecting due to auth failure - token refresh required");
+      return;
+    }
+    const timeSinceConnect = Date.now() - this.connectStartTime;
+    if (timeSinceConnect < 2e3) {
+      this.quickFailureCount++;
+      console.warn(`Quick connection failure detected (${this.quickFailureCount}/${_WebSocketManager.QUICK_FAILURE_THRESHOLD})`);
+      if (this.quickFailureCount >= _WebSocketManager.QUICK_FAILURE_THRESHOLD) {
+        console.warn("Multiple quick failures - likely auth failure (token expired?)");
+        this.updateState("auth_failed" /* AUTH_FAILED */);
+        return;
+      }
+    } else {
+      this.quickFailureCount = 0;
+    }
+    this.updateState("disconnected" /* DISCONNECTED */);
+    this.scheduleReconnect();
+  }
+  /**
+   * Schedule automatic reconnection
+   */
+  scheduleReconnect() {
+    if (this.intentionalDisconnect) {
+      console.log("Skipping reconnect - disconnect was intentional");
+      return;
+    }
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error("Max reconnect attempts reached");
+      this.updateState("failed" /* FAILED */);
+      return;
+    }
+    this.reconnectAttempts++;
+    this.updateState("reconnecting" /* RECONNECTING */);
+    const delay = this.reconnectDelay * this.reconnectAttempts;
+    console.log(
+      `Reconnecting in ${delay / 1e3}s (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    setTimeout(() => {
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Update connection state and notify listeners
+   */
+  updateState(newState) {
+    if (this.state === newState) return;
+    this.state = newState;
+    for (const listener of this.stateListeners) {
+      listener(newState);
+    }
+    if (newState === "auth_failed" /* AUTH_FAILED */ && !this.authFailureFired) {
+      this.authFailureFired = true;
+      try {
+        this.onAuthFailureCallback?.();
+      } catch (e) {
+        console.error("onAuthFailure callback threw:", e);
+      }
+    }
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected" /* CONNECTED */;
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Subscribe to messages
+   */
+  onMessage(listener) {
+    this.messageListeners.add(listener);
+    return () => {
+      this.messageListeners.delete(listener);
+    };
+  }
+  /**
+   * Subscribe to state changes
+   */
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => {
+      this.stateListeners.delete(listener);
+    };
+  }
+  /**
+   * Dispose resources
+   */
+  async dispose() {
+    await this.disconnect();
+    this.messageListeners.clear();
+    this.stateListeners.clear();
+  }
+};
+// Track consecutive quick failures for auth detection
+_WebSocketManager.QUICK_FAILURE_THRESHOLD = 1;
+var WebSocketManager = _WebSocketManager;
+
+// src/sync-client.ts
+var import_core2 = require("@synclib-io/core");
+var SyncReadyState = /* @__PURE__ */ ((SyncReadyState2) => {
+  SyncReadyState2["WAITING_FOR_HELLO"] = "waiting_for_hello";
+  SyncReadyState2["APPLYING_MIGRATIONS"] = "applying_migrations";
+  SyncReadyState2["READY"] = "ready";
+  return SyncReadyState2;
+})(SyncReadyState || {});
+var DEFAULT_MERKLE_BLOCK_SIZE = 100;
+var SyncState = /* @__PURE__ */ ((SyncState2) => {
+  SyncState2["DISCONNECTED"] = "disconnected";
+  SyncState2["CONNECTING"] = "connecting";
+  SyncState2["SYNCING"] = "syncing";
+  SyncState2["READY"] = "ready";
+  SyncState2["ERROR"] = "error";
+  return SyncState2;
+})(SyncState || {});
+var RepairDirection = /* @__PURE__ */ ((RepairDirection2) => {
+  RepairDirection2["PULL"] = "pull";
+  RepairDirection2["PUSH"] = "push";
+  RepairDirection2["LWW"] = "lww";
+  return RepairDirection2;
+})(RepairDirection || {});
+var ChannelRole = /* @__PURE__ */ ((ChannelRole2) => {
+  ChannelRole2["PUSH"] = "push";
+  ChannelRole2["PULL"] = "pull";
+  ChannelRole2["BIDIRECTIONAL"] = "bidirectional";
+  return ChannelRole2;
+})(ChannelRole || {});
+function defaultDirectionForRole(role) {
+  switch (role) {
+    case "push" /* PUSH */:
+      return "push" /* PUSH */;
+    case "pull" /* PULL */:
+      return "pull" /* PULL */;
+    case "bidirectional" /* BIDIRECTIONAL */:
+      return "lww" /* LWW */;
+  }
+}
+function getErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function isBenignMigrationError(err) {
+  const msg = getErrorMessage(err).toLowerCase();
+  return msg.includes("duplicate column") || msg.includes("already exists") || msg.includes("no such table");
+}
+var SyncClient = class {
+  constructor(config) {
+    this.isInitialized = false;
+    this.hasConnectedOnce = false;
+    this.pendingAcks = /* @__PURE__ */ new Set();
+    // Track which table/rowId corresponds to each pending change seqnum
+    this.pendingChangeInfo = /* @__PURE__ */ new Map();
+    // Event listeners
+    this.remoteChangeListeners = /* @__PURE__ */ new Set();
+    this.snapshotCompleteListeners = /* @__PURE__ */ new Set();
+    this.jobUpdateListeners = /* @__PURE__ */ new Set();
+    this.livestreamListeners = /* @__PURE__ */ new Set();
+    this.conversationListeners = /* @__PURE__ */ new Set();
+    this.syncReadyStateListeners = /* @__PURE__ */ new Set();
+    // State
+    this.readyState = "waiting_for_hello" /* WAITING_FOR_HELLO */;
+    this.batchQueue = [];
+    this.batchLock = Promise.resolve();
+    // Message queue for serialized processing
+    this.messageQueue = [];
+    this.processingMessages = false;
+    // Unified sync state
+    this.syncState = "disconnected" /* DISCONNECTED */;
+    this.isSyncing = false;
+    this.tableSeqnums = /* @__PURE__ */ new Map();
+    this.activeSyncCompleters = /* @__PURE__ */ new Map();
+    // Unified sync event listeners
+    this.syncStateListeners = /* @__PURE__ */ new Set();
+    this.syncProgressListeners = /* @__PURE__ */ new Set();
+    this.syncCompleteListeners = /* @__PURE__ */ new Set();
+    this.merkleVerificationListeners = /* @__PURE__ */ new Set();
+    this.config = {
+      pushBatchSize: 100,
+      syncOnWriteDebounce: 100,
+      connectionTimeout: 3e4,
+      syncTimeout: 3e5,
+      ...config
+    };
+    this.db = config.db;
+    this.ws = new WebSocketManager(config.serverUrl);
+    this.ws.onMessage(this.enqueueMessage.bind(this));
+    this.ws.onStateChange(this.handleStateChange.bind(this));
+  }
+  /** Get channels that push (push or bidirectional role). */
+  get pushChannels() {
+    return this.config.channels.filter(
+      (c) => c.role === "push" /* PUSH */ || c.role === "bidirectional" /* BIDIRECTIONAL */
+    );
+  }
+  /** Get channels that pull (pull or bidirectional role). */
+  get pullChannels() {
+    return this.config.channels.filter(
+      (c) => c.role === "pull" /* PULL */ || c.role === "bidirectional" /* BIDIRECTIONAL */
+    );
+  }
+  /** Get all sync table names from channels config. */
+  get allSyncTables() {
+    const tables = /* @__PURE__ */ new Set();
+    for (const ch of this.config.channels) {
+      for (const t of ch.tables ?? []) {
+        tables.add(t.name);
+      }
+    }
+    return Array.from(tables);
+  }
+  /**
+   * One-time migration: switch to server-authoritative row_hash.
+   * Sets all local row_hash values to '' (sentinel) so merkle comparison
+   * detects mismatch and triggers repair from server.
+   */
+  migrateToServerAuthoritativeRowHash() {
+    try {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS _synclib_metadata (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+      const results = this.db.read(
+        `SELECT value FROM _synclib_metadata WHERE key = 'server_authoritative_row_hash'`
+      );
+      if (results.length > 0) return;
+      console.log("[SyncClient] Migrating to server-authoritative row_hash");
+      for (const tableName of this.allSyncTables) {
+        try {
+          this.db.exec(`UPDATE "${tableName}" SET row_hash = ''`);
+          console.log(`[SyncClient] Reset row_hash to sentinel for ${tableName}`);
+        } catch (e) {
+          console.log(`[SyncClient] Could not reset row_hash for ${tableName}:`, e);
+        }
+      }
+      this.db.exec(
+        `INSERT OR REPLACE INTO _synclib_metadata (key, value) VALUES ('server_authoritative_row_hash', '1')`
+      );
+      console.log("[SyncClient] Server-authoritative row_hash migration complete");
+    } catch (e) {
+      console.warn("[SyncClient] Failed to migrate row_hash:", e);
+    }
+  }
+  /**
+   * Initialize the sync client
+   */
+  async initialize() {
+    if (this.isInitialized) {
+      console.warn("Already initialized");
+      return;
+    }
+    console.log("Initializing sync client");
+    this.migrateToServerAuthoritativeRowHash();
+    this.isInitialized = true;
+  }
+  /**
+   * Connect to sync server.
+   * `extra` is forwarded as additional Phoenix socket connect params —
+   * used for `slug` and `env` so the server can route the per-app
+   * Postgres schema ({slug}_dev vs {slug}_prod).
+   */
+  async connect(token, extra) {
+    if (!this.isInitialized) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    await this.ws.connect({
+      token,
+      client_id: this.config.clientId,
+      ...extra || {}
+    });
+    await this.joinChannels();
+  }
+  /**
+   * Update the auth token used on subsequent (re)connects without tearing
+   * down the socket. Use this when the host app refreshes a JWT — typically
+   * either proactively (on a timer) or reactively (in response to
+   * setOnAuthFailure).
+   */
+  setToken(token) {
+    this.ws.setToken(token);
+  }
+  /**
+   * Register a callback fired when the WebSocket is rejected due to bad/expired
+   * auth. The host app should refresh the token, call setToken(newToken), then
+   * call connect() again (or rely on the next scheduled reconnect, after we
+   * clear AUTH_FAILED state).
+   */
+  setOnAuthFailure(callback) {
+    this.ws.setOnAuthFailure(callback);
+  }
+  /**
+   * Join all configured channels
+   */
+  async joinChannels() {
+    for (const channel of this.config.channels) {
+      const topic = channel.topic;
+      console.log(`Joining channel: ${topic}`);
+      const response = await this.ws.joinChannel(topic, {
+        client_id: this.config.clientId,
+        ...channel.params
+      });
+      this.extractServerHashColumns(response);
+    }
+    console.log("All channels joined successfully");
+    this.hasConnectedOnce = true;
+    await this.sendHello();
+    this.startPeriodicSync();
+  }
+  /**
+   * Join an additional channel after initial connection
+   */
+  async joinChannel(channel) {
+    if (!this.ws.isConnected()) {
+      throw new Error("Not connected. Call connect() first.");
+    }
+    const topic = channel.topic;
+    console.log(`Joining additional channel: ${topic}`);
+    const response = await this.ws.joinChannel(topic, {
+      client_id: this.config.clientId,
+      ...channel.params
+    });
+    this.extractServerHashColumns(response);
+    console.log(`Successfully joined channel: ${topic}`);
+  }
+  /**
+   * Check if a channel is currently joined
+   */
+  isChannelJoined(channel) {
+    return this.ws.isChannelJoined(channel.topic);
+  }
+  /**
+   * Get all currently joined channel topics
+   */
+  getJoinedChannels() {
+    return this.ws.getJoinedChannels();
+  }
+  /**
+   * Update the channel configuration dynamically.
+   * Useful when new tables are discovered (e.g. after schema_update migration).
+   * The allSyncTables getter automatically uses config.channels.
+   */
+  updateChannels(channels) {
+    this.config = { ...this.config, channels };
+  }
+  /**
+   * Leave a channel
+   */
+  async leaveChannel(channel) {
+    console.log(`Leaving channel: ${channel.topic}`);
+    await this.ws.leaveChannel(channel.topic);
+    console.log(`Left channel: ${channel.topic}`);
+  }
+  /**
+   * Leave a channel by its topic ID (e.g., "sync:user:123")
+   */
+  async leaveChannelById(channelId) {
+    console.log(`Leaving channel: ${channelId}`);
+    await this.ws.leaveChannel(channelId);
+    console.log(`Left channel: ${channelId}`);
+  }
+  /**
+   * Disconnect from sync server
+   */
+  async disconnect() {
+    this.stopPeriodicSync();
+    await this.ws.disconnect();
+  }
+  /**
+   * Manually trigger a sync cycle.
+   * Calls syncUnified() which handles push, pull, schema, and stripped content.
+   */
+  async sync() {
+    await this.syncUnified();
+  }
+  /**
+   * Unified sync - single operation that handles push, pull, and schema in one request.
+   *
+   * This is the recommended sync method that matches the Flutter implementation.
+   * It prevents concurrent syncs and waits for connection if disconnected.
+   */
+  async syncUnified(options) {
+    await this.waitForConnection();
+    if (this.isSyncing) {
+      console.log("[SyncClient] Already syncing, skipping");
+      return;
+    }
+    try {
+      this.isSyncing = true;
+      this.updateSyncState("syncing" /* SYNCING */);
+      const schemaVersion = this.db.getSchemaVersion();
+      const pendingChanges = this.db.getPendingChanges(this.config.pushBatchSize);
+      console.log(`[SyncClient] syncUnified: ${pendingChanges.length} pending changes`);
+      if (pendingChanges.length > 0) {
+        this.emitSyncProgress({
+          phase: "pushing",
+          changesPushed: pendingChanges.length
+        });
+      }
+      const tablesToSync = this.allSyncTables;
+      const tableSeqnums = await this.getPerTableSeqnums(tablesToSync);
+      const payload = {
+        client_id: this.config.clientId,
+        schema_version: schemaVersion,
+        table_seqnums: tableSeqnums,
+        tables: tablesToSync
+      };
+      if (options?.forceRefresh) {
+        payload.force_refresh_tables = options.forceRefresh;
+      }
+      if (pendingChanges.length > 0) {
+        payload.pending_changes = pendingChanges.map((c) => ({
+          local_seqnum: c.seqnum,
+          table: c.tableName,
+          row_id: c.rowId,
+          operation: c.operation,
+          data: c.data ? JSON.parse(c.data) : void 0
+        }));
+        for (const change of pendingChanges) {
+          this.pendingAcks.add(change.seqnum);
+          this.pendingChangeInfo.set(change.seqnum, {
+            table: change.tableName,
+            rowId: change.rowId
+          });
+        }
+      }
+      const channelTopic = this.config.channels[0]?.topic;
+      const response = await this.ws.sendRaw("sync", payload, channelTopic);
+      const streamId = response.stream_id;
+      console.log(`[SyncClient] Sent sync request, server stream_id: ${streamId}`);
+      const completePromise = this.waitForSyncComplete(
+        streamId,
+        this.config.syncTimeout
+      );
+      this.emitSyncProgress({ phase: "pulling" });
+      await completePromise;
+      await this.checkMerkleVerification();
+      if (this.syncOnWriteDebounceTimer) {
+        clearTimeout(this.syncOnWriteDebounceTimer);
+        this.syncOnWriteDebounceTimer = void 0;
+      }
+      this.updateSyncState("ready" /* READY */);
+      console.log("[SyncClient] syncUnified complete");
+    } catch (error) {
+      console.error("[SyncClient] syncUnified error:", error);
+      this.updateSyncState("error" /* ERROR */);
+      throw error;
+    } finally {
+      this.isSyncing = false;
+    }
+  }
+  /**
+   * Wait for WebSocket connection with timeout
+   */
+  async waitForConnection(timeout) {
+    const timeoutMs = timeout ?? this.config.connectionTimeout ?? 3e4;
+    if (this.ws.isConnected()) {
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        unsubscribe();
+        reject(new Error("Connection timeout"));
+      }, timeoutMs);
+      const unsubscribe = this.ws.onStateChange((state) => {
+        if (state === "connected" /* CONNECTED */) {
+          clearTimeout(timeoutId);
+          unsubscribe();
+          resolve();
+        } else if (state === "failed" /* FAILED */ || state === "auth_failed" /* AUTH_FAILED */) {
+          clearTimeout(timeoutId);
+          unsubscribe();
+          reject(new Error(`Connection failed: ${state}`));
+        }
+      });
+    });
+  }
+  /**
+   * Get per-table seqnums for incremental sync
+   */
+  async getPerTableSeqnums(tables) {
+    const seqnums = {};
+    for (const [table, seqnum] of this.tableSeqnums) {
+      if (!tables || tables.includes(table)) {
+        seqnums[table] = seqnum;
+      }
+    }
+    if (tables) {
+      for (const table of tables) {
+        if (seqnums[table] === void 0) {
+          try {
+            const result = this.db.read(`SELECT MAX("seqnum") as max_seqnum FROM ${this.quoteId(table)}`);
+            if (result.length > 0 && result[0].max_seqnum != null) {
+              seqnums[table] = typeof result[0].max_seqnum === "number" ? result[0].max_seqnum : parseInt(String(result[0].max_seqnum), 10);
+            }
+          } catch {
+          }
+        }
+      }
+    }
+    return seqnums;
+  }
+  /**
+   * Wait for sync complete message
+   */
+  waitForSyncComplete(streamId, timeout) {
+    const timeoutMs = timeout ?? this.config.syncTimeout ?? 3e5;
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        this.activeSyncCompleters.delete(streamId);
+        reject(new Error("Sync timeout"));
+      }, timeoutMs);
+      this.activeSyncCompleters.set(streamId, {
+        resolve: () => {
+          clearTimeout(timeoutId);
+          resolve();
+        },
+        reject: (e) => {
+          clearTimeout(timeoutId);
+          reject(e);
+        }
+      });
+    });
+  }
+  /**
+   * Update sync state and notify listeners
+   */
+  updateSyncState(newState) {
+    if (this.syncState !== newState) {
+      this.syncState = newState;
+      for (const listener of this.syncStateListeners) {
+        listener(newState);
+      }
+      console.log(`[SyncClient] Sync state changed to: ${newState}`);
+    }
+  }
+  /**
+   * Emit sync progress event
+   */
+  emitSyncProgress(progress) {
+    for (const listener of this.syncProgressListeners) {
+      listener(progress);
+    }
+  }
+  /**
+   * Extract server-driven hash_columns from a channel join response.
+   */
+  extractServerHashColumns(response) {
+    const hashCols = response?.hash_columns;
+    if (Array.isArray(hashCols) && hashCols.length > 0) {
+      this.serverHashColumns = hashCols;
+      console.log(`Server hash_columns: ${this.serverHashColumns.join(", ")}`);
+    }
+  }
+  /**
+   * Send hello message to server
+   */
+  async sendHello() {
+    const schemaVersion = this.db.getSchemaVersion();
+    const hello = MessageFactory.hello(
+      this.config.clientId,
+      schemaVersion,
+      0,
+      this.config.metadata
+    );
+    const handshakeComplete = new Promise((resolve) => {
+      this.helloHandshakeResolve = resolve;
+    });
+    await this.ws.send(hello, this.config.channels[0]?.topic);
+    console.log(`Sent hello message with schema version ${schemaVersion}`);
+    await handshakeComplete;
+  }
+  /**
+   * Enqueue a message for serialized processing.
+   * Prevents interleaving when multiple async messages arrive rapidly.
+   */
+  enqueueMessage(message) {
+    this.messageQueue.push(message);
+    if (!this.processingMessages) {
+      this.processMessageQueue();
+    }
+  }
+  /**
+   * Process queued messages one at a time.
+   */
+  async processMessageQueue() {
+    this.processingMessages = true;
+    while (this.messageQueue.length > 0) {
+      const msg = this.messageQueue.shift();
+      await this.handleMessage(msg);
+    }
+    this.processingMessages = false;
+  }
+  /**
+   * Handle incoming message from server
+   */
+  async handleMessage(message) {
+    try {
+      if (message.type === "change") {
+        await this.applyRemoteChange(message);
+      } else if (message.type === "changes_batch") {
+        await this.applyRemoteChanges(message.changes);
+      } else if (message.type === "ack") {
+        await this.handleAck(message);
+      } else if (message.type === "phx_reply") {
+        await this.handlePhoenixReply(message);
+      } else if (message.type === "error") {
+        this.handleError(message);
+      } else if (message.type === "snapshot_batch") {
+        await this.queueSnapshotBatch(message);
+      } else if (message.type === "snapshot_complete") {
+        this.handleSnapshotComplete(message);
+      } else if (message.type === "job_update") {
+        this.handleJobUpdate(message);
+      } else if (message.type === "livestream:started" || message.type === "livestream:stopped") {
+        this.handleLivestream(message);
+      } else if (message.type.startsWith("conversation:")) {
+        this.handleConversation(message);
+      } else if (message.type === "schema_update") {
+        await this.handleSchemaUpdate(message);
+      } else if (message.type === "change_acks") {
+        await this.handleChangeAcks(message);
+      } else if (message.type === "sync_data_batch" || message.type === "sync_batch") {
+        await this.handleSyncDataBatch(message);
+      } else if (message.type === "sync_complete") {
+        this.handleSyncComplete(message);
+      } else {
+        console.warn("Unhandled message type:", message.type);
+      }
+    } catch (e) {
+      console.error("Error handling message:", e);
+    }
+  }
+  /**
+   * Apply a single remote change to local database
+   */
+  async applyRemoteChange(change) {
+    try {
+      if (change.data && change.data["deleted_at"] != null) {
+        const deleteSql = `DELETE FROM ${this.quoteId(change.table)} WHERE "id" = '${this.escapeSql(change.row_id)}'`;
+        await this.db.applyRemote({
+          tableName: change.table,
+          rowId: change.row_id,
+          operation: import_core.SynclibOperation.DELETE,
+          sql: deleteSql,
+          data: void 0
+        });
+        console.log(`Soft-deleted row locally: ${change.table}:${change.row_id}`);
+        for (const listener of this.remoteChangeListeners) {
+          listener(change);
+        }
+        return;
+      }
+      if (this.conflictResolver) {
+        const localChanges = this.db.getPendingChanges();
+        const conflict = localChanges.find(
+          (c) => c.tableName === change.table && c.rowId === change.row_id
+        );
+        if (conflict) {
+          console.log(`Conflict detected for ${change.table}:${change.row_id}`);
+          const localChange = MessageFactory.fromChange(conflict);
+          const resolved = await this.conflictResolver(localChange, change);
+          if (!resolved) {
+            console.log(`Conflict skipped for ${change.table}:${change.row_id}`);
+            return;
+          }
+          change = resolved;
+        }
+      }
+      const sql = this.generateSql(change);
+      await this.db.applyRemote({
+        tableName: change.table,
+        rowId: change.row_id,
+        operation: this.toSynclibOperation(change.operation),
+        sql,
+        data: change.data ? JSON.stringify(change.data) : void 0
+      });
+      console.log(`Applied remote change: ${change.operation} on ${change.table}`);
+      for (const listener of this.remoteChangeListeners) {
+        listener(change);
+      }
+    } catch (e) {
+      console.error("Failed to apply remote change:", e);
+    }
+  }
+  /**
+   * Apply multiple remote changes
+   */
+  async applyRemoteChanges(changes) {
+    console.log(`Applying ${changes.length} remote changes`);
+    await this.withBatchLock(async () => {
+      this.db.beginBulkRemote();
+      let deletedCount = 0;
+      let skippedCount = 0;
+      try {
+        for (const change of changes) {
+          try {
+            if (change.data && change.data["deleted_at"] != null) {
+              const deleteSql = `DELETE FROM ${this.quoteId(change.table)} WHERE "id" = '${this.escapeSql(change.row_id)}'`;
+              this.db.execBulkRemote(deleteSql);
+              deletedCount++;
+            } else {
+              const sql = this.generateSql(change);
+              this.db.execBulkRemote(sql);
+            }
+          } catch (rowErr) {
+            skippedCount++;
+            console.error(`Skipping bad row in ${change.table} (id=${change.row_id}):`, rowErr);
+          }
+        }
+        await this.db.endBulkRemote();
+        if (deletedCount > 0) {
+          console.log(`Soft-deleted ${deletedCount} rows locally`);
+        }
+        if (skippedCount > 0) {
+          console.warn(`Skipped ${skippedCount} bad rows in changes batch`);
+        }
+        console.log(`Successfully applied ${changes.length} changes`);
+      } catch (e) {
+        console.error("Failed to apply changes batch:", e);
+        await this.db.endBulkRemote(true);
+      }
+    });
+  }
+  /**
+   * Handle acknowledgment from server
+   */
+  async handleAck(ack) {
+    console.log(`Received ack for seqnum ${ack.seqnum}: ${ack.success}, server_seqnum: ${ack.server_seqnum}`);
+    if (ack.success) {
+      this.pendingAcks.delete(ack.seqnum);
+      const changeInfo = this.pendingChangeInfo.get(ack.seqnum);
+      this.pendingChangeInfo.delete(ack.seqnum);
+      await this.db.deleteChange(ack.seqnum);
+      if (ack.server_seqnum !== void 0 && changeInfo) {
+        await this.updateLocalSeqnum(changeInfo.table, changeInfo.rowId, ack.server_seqnum);
+      }
+      if (ack.row_hash !== void 0 && changeInfo) {
+        this.updateLocalRowHash(changeInfo.table, changeInfo.rowId, ack.row_hash);
+      }
+    } else {
+      console.warn(`Change ${ack.seqnum} failed: ${ack.error}`);
+      this.pendingChangeInfo.delete(ack.seqnum);
+      await this.db.deleteChange(ack.seqnum);
+    }
+  }
+  /**
+   * Update the seqnum column on a local row after server assigns it
+   */
+  async updateLocalSeqnum(table, rowId, serverSeqnum) {
+    try {
+      const escapedRowId = rowId.replace(/'/g, "''");
+      const sql = `UPDATE ${this.quoteId(table)} SET "seqnum" = ${serverSeqnum} WHERE "id" = '${escapedRowId}'`;
+      this.db.exec(sql);
+      console.log(`Updated local seqnum for ${table}:${rowId} to ${serverSeqnum}`);
+    } catch (e) {
+      console.log(`Could not update seqnum for ${table}:${rowId} (table may not have seqnum column):`, e);
+    }
+  }
+  /**
+   * Update the row_hash column on a local row with the server-computed value
+   */
+  updateLocalRowHash(table, rowId, rowHash) {
+    try {
+      const escapedRowId = rowId.replace(/'/g, "''");
+      const escapedHash = rowHash.replace(/'/g, "''");
+      const sql = `UPDATE ${this.quoteId(table)} SET "row_hash" = '${escapedHash}' WHERE "id" = '${escapedRowId}'`;
+      this.db.exec(sql);
+    } catch (e) {
+      console.log(`Could not update row_hash for ${table}:${rowId}:`, e);
+    }
+  }
+  /**
+   * Handle error message from server
+   */
+  handleError(error) {
+    console.error(`Server error: ${error.code} - ${error.message}`);
+  }
+  /**
+   * Queue snapshot batch for processing
+   */
+  async queueSnapshotBatch(batch) {
+    this.batchQueue.push(batch);
+    console.log(
+      `Queued snapshot batch for ${batch.table}: ${batch.rows.length} rows (queue size: ${this.batchQueue.length})`
+    );
+    await this.processBatchQueue();
+  }
+  /**
+   * Process all batches in the queue serially
+   */
+  async processBatchQueue() {
+    await this.withBatchLock(async () => {
+      while (this.batchQueue.length > 0) {
+        const batch = this.batchQueue.shift();
+        console.log(
+          `Processing batch for ${batch.table} (${this.batchQueue.length} remaining in queue)`
+        );
+        await this.handleSnapshotBatch(batch);
+      }
+    });
+  }
+  /**
+   * Handle snapshot batch message
+   */
+  async handleSnapshotBatch(batch) {
+    const startTime = Date.now();
+    console.log(`Received snapshot batch for ${batch.table}: ${batch.rows.length} rows`);
+    try {
+      const tableCheck = this.db.read(
+        `SELECT name FROM sqlite_master WHERE type='table' AND name='${batch.table}'`
+      );
+      if (tableCheck.length === 0) {
+        console.warn(`Table ${batch.table} does not exist, skipping batch`);
+        return;
+      }
+    } catch (e) {
+      console.error(`Error checking if table ${batch.table} exists:`, e);
+      return;
+    }
+    this.db.beginBulkRemote();
+    let processedCount = 0;
+    let deletedCount = 0;
+    try {
+      for (const row of batch.rows) {
+        const deletedAt = row["deleted_at"];
+        if (deletedAt != null) {
+          const rowId = row.id;
+          const deleteSql = `DELETE FROM ${this.quoteId(batch.table)} WHERE "id" = '${this.escapeSql(rowId)}'`;
+          this.db.execBulkRemote(deleteSql);
+          deletedCount++;
+        } else {
+          const change = {
+            type: "change",
+            table: batch.table,
+            operation: "insert",
+            row_id: row.id,
+            data: row,
+            toMap() {
+              const { toMap, ...rest } = this;
+              return rest;
+            }
+          };
+          const sql = this.generateSql(change);
+          this.db.execBulkRemote(sql);
+        }
+        processedCount++;
+      }
+      await this.db.endBulkRemote();
+      if (deletedCount > 0) {
+        console.log(`Soft-deleted ${deletedCount} rows from ${batch.table}`);
+      }
+      const elapsed = Date.now() - startTime;
+      console.log(
+        `Successfully applied snapshot batch for ${batch.table}: processed ${processedCount}/${batch.rows.length} rows in ${elapsed}ms`
+      );
+    } catch (e) {
+      const elapsed = Date.now() - startTime;
+      console.error(
+        `Failed to apply snapshot batch for ${batch.table} after processing ${processedCount}/${batch.rows.length} rows (${elapsed}ms):`,
+        e
+      );
+      await this.db.endBulkRemote(true);
+      throw e;
+    }
+  }
+  /**
+   * Handle snapshot complete message
+   */
+  handleSnapshotComplete(message) {
+    console.log(`Snapshot complete for stream ${message.stream_id} on channel ${message.channel_id}`);
+    for (const listener of this.snapshotCompleteListeners) {
+      listener(message.stream_id, message.channel_id);
+    }
+  }
+  /**
+   * Handle job update message
+   */
+  handleJobUpdate(message) {
+    console.log(
+      `Job update: ${message.step_type} - step ${message.current_step}/${message.total_steps} for job ${message.job_id}`
+    );
+    for (const listener of this.jobUpdateListeners) {
+      listener(message);
+    }
+  }
+  /**
+   * Handle livestream message
+   */
+  handleLivestream(message) {
+    console.log(
+      `Livestream event: ${message.type} - stream ${message.stream_id} by user ${message.user_id}`
+    );
+    for (const listener of this.livestreamListeners) {
+      listener(message);
+    }
+  }
+  /**
+   * Handle conversation message
+   */
+  handleConversation(message) {
+    console.log(
+      `Conversation event: ${message.type} - conversation ${message.conversation_id} by user ${message.user_id}`
+    );
+    for (const listener of this.conversationListeners) {
+      listener(message);
+    }
+  }
+  /**
+   * Handle schema update notification
+   */
+  async handleSchemaUpdate(message) {
+    console.warn(`Schema update notification: server has new version ${message.new_version}`);
+    const currentVersion = this.db.getSchemaVersion();
+    if (message.new_version > currentVersion) {
+      console.log(`Client schema v${currentVersion} is behind server v${message.new_version}`);
+      if (message.migrations && message.migrations.length > 0) {
+        console.log(
+          `Applying ${message.migrations.length} migrations from schema_update notification`
+        );
+        this.updateReadyState("applying_migrations" /* APPLYING_MIGRATIONS */);
+        await this.applyMigrations({
+          migrations: message.migrations,
+          current_version: message.new_version
+        });
+        this.updateReadyState("ready" /* READY */);
+      } else {
+        console.warn(
+          "Schema update detected but no migrations provided - may need to reconnect"
+        );
+      }
+    } else {
+      console.log(`Client schema is already up to date (v${currentVersion})`);
+    }
+  }
+  /**
+   * Handle batch of change acknowledgments (unified sync protocol)
+   */
+  async handleChangeAcks(message) {
+    console.log(`[SyncClient] Received ${message.acks.length} change acks`);
+    for (const ack of message.acks) {
+      if (ack.success) {
+        this.pendingAcks.delete(ack.local_seqnum);
+        const changeInfo = this.pendingChangeInfo.get(ack.local_seqnum);
+        this.pendingChangeInfo.delete(ack.local_seqnum);
+        await this.db.deleteChange(ack.local_seqnum);
+        if (ack.server_seqnum !== void 0 && changeInfo) {
+          await this.updateLocalSeqnum(changeInfo.table, changeInfo.rowId, ack.server_seqnum);
+        }
+        if (ack.row_hash !== void 0 && changeInfo) {
+          this.updateLocalRowHash(changeInfo.table, changeInfo.rowId, ack.row_hash);
+        }
+      } else {
+        console.warn(`Change ${ack.local_seqnum} failed: ${ack.error}`);
+        this.pendingAcks.delete(ack.local_seqnum);
+        this.pendingChangeInfo.delete(ack.local_seqnum);
+        await this.db.deleteChange(ack.local_seqnum);
+      }
+    }
+  }
+  /**
+   * Handle sync data batch (unified sync protocol)
+   */
+  async handleSyncDataBatch(message) {
+    console.log(
+      `[SyncClient] Received sync data batch for ${message.table}: ${message.rows.length} rows`
+    );
+    this.emitSyncProgress({
+      phase: "pulling",
+      table: message.table,
+      rowCount: message.rows.length
+    });
+    await this.withBatchLock(async () => {
+      try {
+        const tableCheck = this.db.read(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='${message.table}'`
+        );
+        if (tableCheck.length === 0) {
+          console.warn(`Table ${message.table} does not exist, skipping batch`);
+          return;
+        }
+      } catch (e) {
+        console.error(`Error checking if table ${message.table} exists:`, e);
+        return;
+      }
+      this.db.beginBulkRemote();
+      let deletedCount = 0;
+      let maxSeqnum = 0;
+      let skippedCount = 0;
+      try {
+        for (const row of message.rows) {
+          try {
+            const rowSeqnum = row.seqnum;
+            if (rowSeqnum && rowSeqnum > maxSeqnum) {
+              maxSeqnum = rowSeqnum;
+            }
+            if (row["deleted_at"] != null) {
+              const rowId = row.id;
+              const deleteSql = `DELETE FROM ${this.quoteId(message.table)} WHERE "id" = '${this.escapeSql(rowId)}'`;
+              this.db.execBulkRemote(deleteSql);
+              deletedCount++;
+            } else {
+              const change = {
+                type: "change",
+                table: message.table,
+                operation: "insert",
+                row_id: row.id,
+                data: row,
+                toMap() {
+                  const { toMap, ...rest } = this;
+                  return rest;
+                }
+              };
+              const sql = this.generateSql(change);
+              this.db.execBulkRemote(sql);
+            }
+          } catch (rowErr) {
+            skippedCount++;
+            console.error(`[SyncClient] Skipping bad row in ${message.table} (id=${row.id}):`, rowErr);
+          }
+        }
+        await this.db.endBulkRemote();
+        if (maxSeqnum > 0) {
+          const currentSeqnum = this.tableSeqnums.get(message.table) ?? 0;
+          if (maxSeqnum > currentSeqnum) {
+            this.tableSeqnums.set(message.table, maxSeqnum);
+          }
+        }
+        if (deletedCount > 0) {
+          console.log(`[SyncClient] Soft-deleted ${deletedCount} rows from ${message.table}`);
+        }
+        if (skippedCount > 0) {
+          console.warn(`[SyncClient] Skipped ${skippedCount} bad rows in ${message.table}`);
+        }
+        console.log(
+          `[SyncClient] Applied sync batch for ${message.table}: ${message.rows.length} rows`
+        );
+      } catch (e) {
+        console.error(`Failed to apply sync data batch for ${message.table}:`, e);
+        await this.db.endBulkRemote(true);
+        throw e;
+      }
+    });
+  }
+  /**
+   * Handle sync complete message (unified sync protocol)
+   */
+  handleSyncComplete(message) {
+    console.log(`[SyncClient] Sync complete, stream_id: ${message.stream_id}`);
+    if (message.table_seqnums) {
+      for (const [table, seqnum] of Object.entries(message.table_seqnums)) {
+        this.tableSeqnums.set(table, seqnum);
+      }
+    }
+    const event = {
+      streamId: message.stream_id,
+      schemaVersion: message.schema_version,
+      tableSeqnums: message.table_seqnums ?? {},
+      schemaUpgraded: message.stats?.schema_upgraded ?? false,
+      migrationsApplied: message.stats?.migrations_applied ?? 0,
+      totalRowsPulled: message.stats?.pull_total ?? 0,
+      totalChangesPushed: message.stats?.push_total ?? 0,
+      totalChangesSucceeded: message.stats?.push_success ?? 0,
+      totalChangesFailed: message.stats?.push_failed ?? 0,
+      pullStats: {},
+      pushStats: {}
+    };
+    this.emitSyncProgress({ phase: "complete" });
+    for (const listener of this.syncCompleteListeners) {
+      listener(event);
+    }
+    const streamId = message.stream_id ?? "";
+    const completer = this.activeSyncCompleters.get(streamId);
+    if (completer) {
+      completer.resolve();
+      this.activeSyncCompleters.delete(streamId);
+    }
+  }
+  /**
+   * Handle Phoenix reply messages
+   */
+  async handlePhoenixReply(reply) {
+    console.log("[SYNC DEBUG] handlePhoenixReply called with:", reply);
+    const response = reply.response;
+    console.log("[SYNC DEBUG] Response object:", response);
+    console.log("[SYNC DEBUG] Response status:", response?.status);
+    if (response.merkle_block_size != null) {
+      this.serverMerkleBlockSize = response.merkle_block_size;
+      console.log(`[SyncClient] Server merkle_block_size: ${this.serverMerkleBlockSize}`);
+    }
+    if (response.status === "upgrade_needed") {
+      console.log("[SYNC DEBUG] Schema upgrade needed - applying migrations");
+      this.updateReadyState("applying_migrations" /* APPLYING_MIGRATIONS */);
+      await this.applyMigrations(response);
+      this.updateReadyState("ready" /* READY */);
+    } else if (response.status === "up_to_date") {
+      console.log("[SYNC DEBUG] Schema is up to date");
+      this.updateReadyState("ready" /* READY */);
+    } else if (response.status === "ok") {
+      console.log("[SYNC DEBUG] Received OK response, current readyState:", this.readyState);
+      if (this.readyState === "waiting_for_hello" /* WAITING_FOR_HELLO */) {
+        console.log("[SYNC DEBUG] Transitioning from WAITING_FOR_HELLO to READY");
+        this.updateReadyState("ready" /* READY */);
+      }
+    } else {
+      console.log("[SYNC DEBUG] Unknown status:", response.status);
+    }
+    if (this.helloHandshakeResolve) {
+      this.helloHandshakeResolve();
+      this.helloHandshakeResolve = void 0;
+    }
+  }
+  /**
+   * Apply schema migrations from server
+   */
+  async applyMigrations(response) {
+    const currentVersion = response.current_version;
+    const migrations = response.migrations;
+    if (!migrations || migrations.length === 0) {
+      console.warn("No migrations provided");
+      return;
+    }
+    console.log(`Applying ${migrations.length} migration(s) to reach version ${currentVersion}`);
+    for (const migration of migrations) {
+      console.log(`Applying migration v${migration.version}: ${migration.description}`);
+      try {
+        for (const sql of migration.sql) {
+          console.log(`Executing: ${sql}`);
+          try {
+            this.db.exec(sql);
+          } catch (stmtErr) {
+            if (isBenignMigrationError(stmtErr)) {
+              console.warn(
+                `Skipping idempotent migration statement (already applied): ${sql} \u2014 ${getErrorMessage(stmtErr)}`
+              );
+              continue;
+            }
+            throw stmtErr;
+          }
+        }
+        await this.db.setSchemaVersion(migration.version);
+        console.log(`Successfully applied migration v${migration.version}`);
+      } catch (e) {
+        console.error(`Failed to apply migration v${migration.version}:`, e);
+        throw e;
+      }
+    }
+    const confirm = MessageFactory.schemaConfirm(currentVersion);
+    await this.ws.send(confirm, this.config.channels[0]?.topic);
+    console.log("Confirmed schema migration to server");
+  }
+  /**
+   * Update sync ready state
+   */
+  updateReadyState(newState) {
+    if (this.readyState !== newState) {
+      this.readyState = newState;
+      for (const listener of this.syncReadyStateListeners) {
+        listener(newState);
+      }
+      console.log(`Sync ready state changed to: ${newState}`);
+    }
+  }
+  /**
+   * Handle connection state changes
+   */
+  handleStateChange(state) {
+    console.log(`Connection state: ${state}`);
+    switch (state) {
+      case "connected" /* CONNECTED */:
+        if (!this.isSyncing) {
+          this.updateSyncState("ready" /* READY */);
+        }
+        break;
+      case "connecting" /* CONNECTING */:
+      case "reconnecting" /* RECONNECTING */:
+        this.updateSyncState("connecting" /* CONNECTING */);
+        break;
+      case "disconnected" /* DISCONNECTED */:
+      case "failed" /* FAILED */:
+        this.stopPeriodicSync();
+        this.updateSyncState("disconnected" /* DISCONNECTED */);
+        break;
+      case "auth_failed" /* AUTH_FAILED */:
+        this.updateSyncState("error" /* ERROR */);
+        break;
+    }
+    if (state === "connected" /* CONNECTED */ && this.hasConnectedOnce) {
+      console.log("Reconnected - rejoining channels");
+      this.joinChannels().catch((e) => {
+        console.error("Failed to rejoin channels after reconnect:", e);
+      });
+    } else if (state === "disconnected" /* DISCONNECTED */ || state === "failed" /* FAILED */) {
+    }
+  }
+  /**
+   * Generate SQL statement from change message
+   */
+  generateSql(change) {
+    const filteredData = {};
+    if (change.data) {
+      for (const [key, value] of Object.entries(change.data)) {
+        if (key === "inserted_at" || key === "id") continue;
+        const normalizedKey = key.toLowerCase();
+        filteredData[normalizedKey] = value;
+      }
+    }
+    const qt = this.quoteId(change.table);
+    switch (change.operation) {
+      case "insert": {
+        const columns = ["id", ...Object.keys(filteredData)].map((c) => this.quoteId(c)).join(", ");
+        const values = [
+          `'${this.escapeSql(change.row_id)}'`,
+          ...Object.values(filteredData).map((v) => this.formatSqlValue(v))
+        ].join(", ");
+        return `INSERT OR REPLACE INTO ${qt} (${columns}) VALUES (${values})`;
+      }
+      case "update": {
+        const sets = Object.entries(filteredData).map(([k, v]) => `${this.quoteId(k)} = ${this.formatSqlValue(v)}`).join(", ");
+        return `UPDATE ${qt} SET ${sets} WHERE "id" = '${this.escapeSql(change.row_id)}'`;
+      }
+      case "delete":
+        return `DELETE FROM ${qt} WHERE "id" = '${this.escapeSql(change.row_id)}'`;
+      default:
+        throw new Error(`Unknown operation: ${change.operation}`);
+    }
+  }
+  /**
+   * Format a value for SQL
+   */
+  formatSqlValue(value) {
+    if (value === null || value === void 0) {
+      return "null";
+    } else if (typeof value === "string") {
+      return `'${this.escapeSql(value)}'`;
+    } else if (typeof value === "boolean") {
+      return value ? "1" : "0";
+    } else if (typeof value === "number") {
+      return value.toString();
+    } else if (typeof value === "object") {
+      const jsonString = JSON.stringify(value);
+      return `'${this.escapeSql(jsonString)}'`;
+    } else {
+      return String(value);
+    }
+  }
+  /**
+   * Escape single quotes in SQL strings
+   */
+  escapeSql(value) {
+    return value.replace(/'/g, "''");
+  }
+  /**
+   * Quote a SQL identifier (table or column name) to prevent SQL injection.
+   */
+  quoteId(name) {
+    return '"' + name.replace(/"/g, '""') + '"';
+  }
+  /**
+   * Convert operation string to SynclibOperation
+   */
+  toSynclibOperation(operation) {
+    switch (operation) {
+      case "insert":
+        return import_core.SynclibOperation.INSERT;
+      case "update":
+        return import_core.SynclibOperation.UPDATE;
+      case "delete":
+        return import_core.SynclibOperation.DELETE;
+      default:
+        throw new Error(`Unknown operation: ${operation}`);
+    }
+  }
+  /**
+   * Execute function with batch lock (serial processing)
+   */
+  async withBatchLock(fn) {
+    const previous = this.batchLock;
+    let resolve;
+    this.batchLock = new Promise((r) => resolve = r);
+    try {
+      await previous;
+      return await fn();
+    } finally {
+      resolve();
+    }
+  }
+  /**
+   * Stream snapshot of tables from server
+   */
+  async streamSnapshot(tables, options = {}) {
+    if (!this.ws.isConnected()) {
+      throw new Error("Not connected to server");
+    }
+    let sinceSeqnum;
+    if (options.incremental) {
+      let maxSeqnum = 0;
+      for (const table of tables) {
+        try {
+          const result = this.db.read(`SELECT MAX("seqnum") as max_seqnum FROM ${this.quoteId(table)}`);
+          if (result.length > 0 && result[0].max_seqnum) {
+            const seqnum = typeof result[0].max_seqnum === "number" ? result[0].max_seqnum : parseInt(String(result[0].max_seqnum), 10);
+            if (seqnum > maxSeqnum) {
+              maxSeqnum = seqnum;
+            }
+          }
+        } catch (e) {
+          console.warn(`Failed to get max seqnum for table ${table}:`, e);
+        }
+      }
+      sinceSeqnum = maxSeqnum;
+      console.log(`Requesting incremental snapshot since seqnum: ${sinceSeqnum}`);
+    } else {
+      console.log("Requesting full snapshot");
+    }
+    const payload = { tables };
+    if (sinceSeqnum !== void 0) {
+      payload.since_seqnum = sinceSeqnum;
+    }
+    await this.ws.sendRaw("stream_snapshot", payload, options.channelTopic);
+  }
+  /**
+   * Fetch a full row from the server
+   */
+  async fetchRow(table, rowId) {
+    const response = await this.sendMessage("fetch_row", {
+      table,
+      row_id: rowId
+    });
+    return response.row;
+  }
+  /**
+   * Send a custom message to the server and wait for reply
+   */
+  async sendMessage(event, payload, channelTopic) {
+    if (!this.ws.isConnected()) {
+      throw new Error("Not connected to server");
+    }
+    try {
+      const response = await this.ws.sendRaw(event, payload, channelTopic);
+      return response;
+    } catch (e) {
+      console.error("Failed to send message:", e);
+      throw e;
+    }
+  }
+  /**
+   * Send a conversation presence event
+   */
+  async sendConversationPresence(options) {
+    if (!this.ws.isConnected()) {
+      throw new Error("Not connected to server");
+    }
+    try {
+      const payload = {
+        conversation_id: options.conversationId,
+        user_id: options.userId,
+        timestamp: Math.floor(Date.now() / 1e3)
+      };
+      await this.ws.sendRaw(options.event, payload, options.channelTopic);
+      console.log(
+        `Sent conversation presence event: ${options.event} for conversation ${options.conversationId}`
+      );
+    } catch (e) {
+      console.error("Failed to send conversation presence:", e);
+      throw e;
+    }
+  }
+  /**
+   * Set conflict resolver
+   */
+  setConflictResolver(resolver) {
+    this.conflictResolver = resolver;
+  }
+  /**
+   * Notify the sync client that a local change occurred.
+   *
+   * Call this after writing to the database to trigger an immediate push.
+   * Uses debouncing to batch rapid writes together (configurable via syncOnWriteDebounce).
+   *
+   * Example:
+   * ```typescript
+   * // After writing to the database
+   * await db.write({ tableName: 'users', rowId: '123', ... });
+   * syncClient.notifyLocalChange();
+   * ```
+   */
+  notifyLocalChange() {
+    if (!this.ws.isConnected()) return;
+    if (this.syncOnWriteDebounceTimer) {
+      clearTimeout(this.syncOnWriteDebounceTimer);
+    }
+    this.syncOnWriteDebounceTimer = setTimeout(() => {
+      console.log("syncOnWrite: syncing after debounce");
+      this.syncUnified();
+    }, this.config.syncOnWriteDebounce);
+  }
+  /** Start periodic background sync timer if configured. */
+  startPeriodicSync() {
+    this.stopPeriodicSync();
+    const interval = this.config.periodicSyncInterval;
+    if (interval == null) return;
+    console.log(`Starting periodic sync every ${interval}ms`);
+    this.periodicSyncTimer = setInterval(() => {
+      this.syncUnified().catch((e) => {
+        console.warn("Periodic sync failed:", e);
+      });
+    }, interval);
+  }
+  /** Stop periodic background sync timer. */
+  stopPeriodicSync() {
+    if (this.periodicSyncTimer) {
+      clearInterval(this.periodicSyncTimer);
+      this.periodicSyncTimer = void 0;
+    }
+  }
+  /**
+   * Event listeners
+   */
+  onRemoteChange(listener) {
+    this.remoteChangeListeners.add(listener);
+    return () => this.remoteChangeListeners.delete(listener);
+  }
+  onSnapshotComplete(listener) {
+    this.snapshotCompleteListeners.add(listener);
+    return () => this.snapshotCompleteListeners.delete(listener);
+  }
+  onJobUpdate(listener) {
+    this.jobUpdateListeners.add(listener);
+    return () => this.jobUpdateListeners.delete(listener);
+  }
+  onLivestream(listener) {
+    this.livestreamListeners.add(listener);
+    return () => this.livestreamListeners.delete(listener);
+  }
+  onConversation(listener) {
+    this.conversationListeners.add(listener);
+    return () => this.conversationListeners.delete(listener);
+  }
+  onSyncReadyStateChange(listener) {
+    this.syncReadyStateListeners.add(listener);
+    return () => this.syncReadyStateListeners.delete(listener);
+  }
+  onStateChange(listener) {
+    return this.ws.onStateChange(listener);
+  }
+  /**
+   * Listen to unified sync state changes
+   */
+  onSyncStateChange(listener) {
+    this.syncStateListeners.add(listener);
+    return () => this.syncStateListeners.delete(listener);
+  }
+  /**
+   * Listen to sync progress events
+   */
+  onSyncProgress(listener) {
+    this.syncProgressListeners.add(listener);
+    return () => this.syncProgressListeners.delete(listener);
+  }
+  /**
+   * Listen to sync complete events
+   */
+  onSyncComplete(listener) {
+    this.syncCompleteListeners.add(listener);
+    return () => this.syncCompleteListeners.delete(listener);
+  }
+  /**
+   * Listen to Merkle verification events
+   * Fires after background verification completes, especially useful when repairs occurred.
+   * Subscribe to invalidate caches/refs when data was repaired.
+   */
+  onMerkleVerification(listener) {
+    this.merkleVerificationListeners.add(listener);
+    return () => this.merkleVerificationListeners.delete(listener);
+  }
+  /**
+   * Getters
+   */
+  get connectionState() {
+    return this.ws.getState();
+  }
+  get isReady() {
+    return this.readyState === "ready" /* READY */;
+  }
+  get currentReadyState() {
+    return this.readyState;
+  }
+  /**
+   * Get current unified sync state
+   */
+  get currentSyncState() {
+    return this.syncState;
+  }
+  // ==========================================================================
+  // MERKLE TREE INTEGRITY VERIFICATION
+  // ==========================================================================
+  /**
+   * Check if Merkle verification is needed based on staleness.
+   * Called at the end of syncUnified to run verification if interval has elapsed.
+   */
+  async checkMerkleVerification() {
+    const hasChannels = this.config.channels.some((c) => (c.tables?.length ?? 0) > 0);
+    if (!this.config.merkleVerifyInterval || !hasChannels) {
+      return;
+    }
+    try {
+      const now = Date.now();
+      const results = this.db.read(
+        `SELECT value FROM _synclib_metadata WHERE key = 'merkle_last_verified'`
+      );
+      const lastVerified = results.length > 0 ? parseInt(results[0].value, 10) : 0;
+      if (lastVerified === 0) {
+        console.log("[SyncClient] Merkle verification: first run - skipping, setting initial timestamp");
+        this.db.exec(
+          `INSERT OR REPLACE INTO _synclib_metadata (key, value) VALUES ('merkle_last_verified', '${now}')`
+        );
+        return;
+      }
+      if (now - lastVerified < this.config.merkleVerifyInterval) {
+        console.log(
+          `[SyncClient] Merkle verification not needed (last: ${new Date(lastVerified).toISOString()})`
+        );
+        return;
+      }
+      console.log(
+        `[SyncClient] Running Merkle verification (last: ${new Date(lastVerified).toISOString()})`
+      );
+      const blockSize = this.serverMerkleBlockSize ?? DEFAULT_MERKLE_BLOCK_SIZE;
+      const allRepairedTables = [];
+      await this.merkleVerifyFromChannels(this.config.channels, blockSize, allRepairedTables);
+      this.db.exec(
+        `INSERT OR REPLACE INTO _synclib_metadata (key, value) VALUES ('merkle_last_verified', '${now}')`
+      );
+      if (allRepairedTables.length > 0) {
+        console.log(`[SyncClient] Merkle verification repaired tables: ${allRepairedTables.join(", ")}`);
+      } else {
+        console.log("[SyncClient] Merkle verification: all tables match");
+      }
+      const event = {
+        repairedTables: allRepairedTables,
+        hadMismatches: allRepairedTables.length > 0
+      };
+      for (const listener of this.merkleVerificationListeners) {
+        listener(event);
+      }
+    } catch (e) {
+      console.warn("[SyncClient] Merkle verification failed:", e);
+    }
+  }
+  /**
+   * Merkle verification using the new channels config.
+   * Verifies all tables per channel, then dispatches repair by direction.
+   */
+  async merkleVerifyFromChannels(channels, blockSize, allRepairedTables) {
+    for (const channel of channels) {
+      if (!channel.tables?.length) continue;
+      const allTables = channel.tables.map((t) => t.name);
+      console.log(`[SyncClient] Merkle verification on ${channel.topic}: ${allTables.join(", ")}`);
+      try {
+        const mismatches = await this.verifyRoots(allTables, blockSize, channel.topic, this.serverHashColumns);
+        for (const mismatch of mismatches) {
+          const syncTable = channel.tables.find((t) => t.name === mismatch.table);
+          const direction = syncTable?.direction ?? defaultDirectionForRole(channel.role);
+          console.log(
+            `[SyncClient] Merkle repair: ${mismatch.table} on ${channel.topic} direction=${direction}`
+          );
+          switch (direction) {
+            case "pull" /* PULL */:
+              await this.repairTablePull(mismatch.table, blockSize, channel.topic, this.serverHashColumns, mismatch.row_ids);
+              break;
+            case "push" /* PUSH */:
+              await this.repairTablePush(mismatch.table, blockSize, channel.topic, this.serverHashColumns, mismatch.row_ids);
+              break;
+            case "lww" /* LWW */:
+              await this.repairTableLww(mismatch.table, blockSize, channel.topic, this.serverHashColumns, mismatch.row_ids);
+              break;
+          }
+          allRepairedTables.push(mismatch.table);
+        }
+      } catch (e) {
+        console.warn(`[SyncClient] Merkle verification failed on ${channel.topic}:`, e);
+      }
+    }
+  }
+  /**
+   * Legacy merkle verification using old config fields (backward compat).
+   */
+  /**
+   * Compare local Merkle roots against server and return mismatches.
+   * Shared root-verification step used by the channels config path.
+   */
+  async verifyRoots(tables, blockSize, channelTopic, hashColumns) {
+    if (!this.ws.isConnected()) {
+      throw new Error("Not connected to server");
+    }
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const tableHashes = {};
+    for (const table of tables) {
+      try {
+        const merkleInfo = await merkleComputer.merkleRoot(table, blockSize, "id", hashColumns);
+        tableHashes[table] = {
+          root_hash: merkleInfo.rootHash,
+          block_count: merkleInfo.blockCount,
+          row_count: merkleInfo.rowCount
+        };
+      } catch (e) {
+        console.warn(`[SyncClient] verifyRoots: Failed to compute Merkle root for ${table}:`, e);
+      }
+    }
+    if (Object.keys(tableHashes).length === 0) return [];
+    const payload = {
+      table_hashes: tableHashes,
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_verify", payload, channelTopic);
+    if (responseMap.status === "ok") return [];
+    const mismatches = (responseMap.mismatches ?? []).map((m) => ({
+      table: m.table,
+      server_root_hash: m.server_root_hash,
+      server_block_count: m.server_block_count,
+      server_row_count: m.server_row_count,
+      row_ids: m.row_ids ?? void 0
+    }));
+    const realMismatches = [];
+    const merkle = new import_core2.MerkleComputer(this.db);
+    for (const mismatch of mismatches) {
+      if (mismatch.row_ids && mismatch.row_ids.length > 0) {
+        try {
+          const scopedInfo = await merkle.merkleRoot(mismatch.table, blockSize, "id", hashColumns, mismatch.row_ids);
+          if (scopedInfo.rootHash === mismatch.server_root_hash) {
+            console.log(
+              `[SyncClient] verifyRoots: ${mismatch.table} matches after scoping (${scopedInfo.rowCount} scoped rows vs ${tableHashes[mismatch.table]?.row_count} total)`
+            );
+            continue;
+          }
+        } catch (e) {
+          console.warn(`[SyncClient] verifyRoots: scoped recheck failed for ${mismatch.table}:`, e);
+        }
+      }
+      realMismatches.push(mismatch);
+    }
+    return realMismatches;
+  }
+  /**
+   * Verify data integrity using Merkle trees.
+   *
+   * Compares local Merkle roots against server and repairs any mismatched blocks.
+   * This is a consistency audit that catches:
+   * - Data corruption during development
+   * - Seqnum drift from manual database edits
+   * - Missed changes from network issues
+   * - Any state where seqnums match but data differs
+   *
+   * @param options - Verification options
+   * @returns List of tables that were repaired. Empty array means all matched.
+   *
+   * @example
+   * ```typescript
+   * const repairedTables = await syncClient.verifyIntegrity({
+   *   tables: ['users', 'workouts'],
+   *   blockSize: 100,
+   * });
+   * if (repairedTables.length > 0) {
+   *   console.log('Repaired tables:', repairedTables);
+   * }
+   * ```
+   */
+  async verifyIntegrity(options) {
+    if (!this.ws.isConnected()) {
+      console.warn("[SyncClient] verifyIntegrity: Not connected");
+      throw new Error("Not connected to server");
+    }
+    const blockSize = options?.blockSize ?? import_core2.DEFAULT_BLOCK_SIZE;
+    const tablesToVerify = options?.tables ?? [];
+    if (tablesToVerify.length === 0) {
+      console.warn("[SyncClient] verifyIntegrity: No tables specified");
+      return [];
+    }
+    console.log(
+      `[SyncClient] verifyIntegrity: Starting integrity check for ${tablesToVerify.length} tables`
+    );
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const tableHashes = {};
+    for (const table of tablesToVerify) {
+      try {
+        const merkleInfo = await merkleComputer.merkleRoot(table, blockSize);
+        tableHashes[table] = {
+          root_hash: merkleInfo.rootHash,
+          block_count: merkleInfo.blockCount,
+          row_count: merkleInfo.rowCount
+        };
+        console.log(
+          `[SyncClient] verifyIntegrity: ${table} - root=${merkleInfo.rootHash.substring(0, 16)}..., blocks=${merkleInfo.blockCount}, rows=${merkleInfo.rowCount}`
+        );
+      } catch (e) {
+        console.warn(
+          `[SyncClient] verifyIntegrity: Failed to compute Merkle root for ${table}:`,
+          e
+        );
+      }
+    }
+    if (Object.keys(tableHashes).length === 0) {
+      console.warn("[SyncClient] verifyIntegrity: No valid tables to verify");
+      return [];
+    }
+    const channel = options?.channelTopic;
+    const payload = {
+      table_hashes: tableHashes,
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_verify", payload, channel);
+    const response = {
+      type: "merkle_verify_response",
+      status: responseMap.status,
+      mismatches: responseMap.mismatches?.map((m) => ({
+        table: m.table,
+        server_root_hash: m.server_root_hash,
+        server_block_count: m.server_block_count,
+        server_row_count: m.server_row_count
+      })),
+      toMap() {
+        return this;
+      }
+    };
+    if (response.status === "ok") {
+      console.log("[SyncClient] verifyIntegrity: All tables verified OK");
+      return [];
+    }
+    const repairedTables = [];
+    for (const mismatch of response.mismatches ?? []) {
+      console.log(
+        `[SyncClient] verifyIntegrity: Mismatch detected for ${mismatch.table} - local: ${tableHashes[mismatch.table]?.root_hash.substring(0, 16)}..., server: ${mismatch.server_root_hash.substring(0, 16)}...`
+      );
+      await this.repairTablePull(mismatch.table, blockSize, channel);
+      repairedTables.push(mismatch.table);
+    }
+    console.log(
+      `[SyncClient] verifyIntegrity: Repaired ${repairedTables.length} tables`
+    );
+    return repairedTables;
+  }
+  /**
+   * Repair a table by fetching differing blocks from server (pull: server → client)
+   */
+  async repairTablePull(table, blockSize, channelTopic, hashColumns, scopedRowIds) {
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const blockHashes = await merkleComputer.merkleBlockHashes(table, blockSize, "id", hashColumns, scopedRowIds);
+    console.log(
+      `[SyncClient] verifyIntegrity: ${table} has ${blockHashes.length} blocks`
+    );
+    const payload = {
+      table,
+      block_hashes: blockHashes,
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_block_hashes", payload, channelTopic);
+    const response = {
+      type: "merkle_block_hashes_response",
+      table: responseMap.table,
+      differing_blocks: responseMap.differing_blocks,
+      toMap() {
+        return this;
+      }
+    };
+    if (response.differing_blocks.length === 0 && scopedRowIds == null) {
+      console.log(
+        `[SyncClient] verifyIntegrity: ${table} - no differing blocks (hash collision resolved)`
+      );
+      return;
+    }
+    console.log(
+      `[SyncClient] verifyIntegrity: ${table} - ${response.differing_blocks.length} differing blocks: ${response.differing_blocks}`
+    );
+    for (const blockIndex of response.differing_blocks) {
+      await this.fetchAndApplyBlock(table, blockIndex, blockSize, channelTopic);
+    }
+    if (scopedRowIds != null) {
+      const allLocalIds = merkleComputer.getAllRowIds(table);
+      const scopedSet = new Set(scopedRowIds);
+      const outOfScope = allLocalIds.filter((id) => !scopedSet.has(id));
+      if (outOfScope.length > 0) {
+        console.log(
+          `[SyncClient] verifyIntegrity: ${table} - deleting ${outOfScope.length} out-of-scope rows`
+        );
+        this.db.beginBulkRemote();
+        try {
+          for (const rowId of outOfScope) {
+            const change = {
+              type: "change",
+              table,
+              operation: "delete",
+              row_id: rowId,
+              toMap() {
+                return this;
+              }
+            };
+            const sql = this.generateSql(change);
+            this.db.execBulkRemote(sql);
+          }
+          await this.db.endBulkRemote();
+        } catch (e) {
+          await this.db.endBulkRemote(true);
+          throw e;
+        }
+      }
+    }
+    console.log(`[SyncClient] verifyIntegrity: ${table} - repair complete`);
+  }
+  /**
+   * Fetch a block from server and apply to local database
+   */
+  async fetchAndApplyBlock(table, blockIndex, blockSize, channelTopic) {
+    const payload = {
+      table,
+      blocks: [blockIndex],
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_fetch_blocks", payload, channelTopic);
+    const response = {
+      type: "merkle_fetch_blocks_response",
+      table: responseMap.table,
+      block: responseMap.block,
+      rows: responseMap.rows,
+      toMap() {
+        return this;
+      }
+    };
+    console.log(
+      `[SyncClient] verifyIntegrity: ${table} block ${blockIndex} - received ${response.rows.length} rows`
+    );
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const existingRowIds = merkleComputer.getBlockRowIds(table, blockIndex, blockSize);
+    const serverRowIds = new Set(response.rows.map((r) => String(r.id ?? "")));
+    for (const row of response.rows) {
+      const rowId = String(row.id ?? "");
+      if (!rowId) continue;
+      const isUpdate = existingRowIds.includes(rowId);
+      await this.applyRemoteChange({
+        type: "change",
+        table,
+        operation: isUpdate ? "update" : "insert",
+        row_id: rowId,
+        data: row,
+        toMap() {
+          return this;
+        }
+      });
+    }
+    for (const localRowId of existingRowIds) {
+      if (!serverRowIds.has(localRowId)) {
+        await this.applyRemoteChange({
+          type: "change",
+          table,
+          operation: "delete",
+          row_id: localRowId,
+          toMap() {
+            return this;
+          }
+        });
+        console.log(
+          `[SyncClient] verifyIntegrity: ${table} - deleted orphan row ${localRowId}`
+        );
+      }
+    }
+  }
+  /**
+   * Repair a table by pushing local rows to server (push: client → server)
+   */
+  async repairTablePush(table, blockSize, channelTopic, hashColumns, scopedRowIds) {
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const effectiveScope = scopedRowIds != null && scopedRowIds.length === 0 ? void 0 : scopedRowIds;
+    const blockHashes = await merkleComputer.merkleBlockHashes(table, blockSize, "id", hashColumns, effectiveScope);
+    console.log(`[SyncClient] repairPush: ${table} has ${blockHashes.length} blocks`);
+    const payload = {
+      table,
+      block_hashes: blockHashes,
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_block_hashes", payload, channelTopic);
+    const differingBlocks = responseMap.differing_blocks;
+    if (differingBlocks.length === 0) {
+      console.log(`[SyncClient] repairPush: ${table} - no differing blocks`);
+      return;
+    }
+    console.log(
+      `[SyncClient] repairPush: ${table} - ${differingBlocks.length} differing blocks: ${differingBlocks}`
+    );
+    for (const blockIndex of differingBlocks) {
+      await this.pushBlockToServer(table, blockIndex, blockSize, channelTopic);
+    }
+    console.log(`[SyncClient] repairPush: ${table} - push repair complete`);
+  }
+  /**
+   * Read local rows for a block and push them to the server.
+   */
+  async pushBlockToServer(table, blockIndex, blockSize, channelTopic) {
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const rowIds = merkleComputer.getBlockRowIds(table, blockIndex, blockSize);
+    const rows = [];
+    for (const rowId of rowIds) {
+      const rowData = this.db.read(
+        `SELECT * FROM ${this.quoteId(table)} WHERE "id" = '${this.escapeSql(rowId)}'`
+      );
+      if (rowData.length > 0) {
+        const { row_hash, ...row } = rowData[0];
+        rows.push(row);
+      }
+    }
+    const payload = {
+      table,
+      block_index: blockIndex,
+      block_size: blockSize,
+      rows,
+      client_row_ids: rowIds
+    };
+    const responseMap = await this.ws.sendRaw("merkle_push_blocks", payload, channelTopic);
+    const response = {
+      type: "merkle_push_blocks_response",
+      table: responseMap.table,
+      block_index: responseMap.block_index,
+      applied: responseMap.applied ?? 0,
+      rejected: responseMap.rejected ?? 0,
+      deleted: responseMap.deleted ?? 0,
+      errors: responseMap.errors ?? [],
+      toMap() {
+        return this;
+      }
+    };
+    console.log(
+      `[SyncClient] repairPush: ${table} block ${blockIndex} - applied: ${response.applied}, rejected: ${response.rejected}, deleted: ${response.deleted}`
+    );
+    if (response.errors.length > 0) {
+      for (const error of response.errors) {
+        console.warn(`[SyncClient] repairPush: ${table} block ${blockIndex} - error:`, error);
+      }
+    }
+  }
+  /**
+   * Repair a table using last-write-wins (LWW) resolution.
+   * Sends local rows to server which compares last_modified_ms timestamps.
+   */
+  async repairTableLww(table, blockSize, channelTopic, hashColumns, scopedRowIds) {
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const effectiveScope = scopedRowIds != null && scopedRowIds.length === 0 ? void 0 : scopedRowIds;
+    const blockHashes = await merkleComputer.merkleBlockHashes(table, blockSize, "id", hashColumns, effectiveScope);
+    console.log(`[SyncClient] repairLww: ${table} has ${blockHashes.length} blocks`);
+    const payload = {
+      table,
+      block_hashes: blockHashes,
+      block_size: blockSize
+    };
+    const responseMap = await this.ws.sendRaw("merkle_block_hashes", payload, channelTopic);
+    const differingBlocks = responseMap.differing_blocks;
+    if (differingBlocks.length === 0) {
+      console.log(`[SyncClient] repairLww: ${table} - no differing blocks`);
+      return;
+    }
+    console.log(
+      `[SyncClient] repairLww: ${table} - ${differingBlocks.length} differing blocks: ${differingBlocks}`
+    );
+    for (const blockIndex of differingBlocks) {
+      await this.lwwResolveBlock(table, blockIndex, blockSize, channelTopic);
+    }
+    console.log(`[SyncClient] repairLww: ${table} - lww repair complete`);
+  }
+  /**
+   * Resolve a single block using last-write-wins.
+   */
+  async lwwResolveBlock(table, blockIndex, blockSize, channelTopic) {
+    const merkleComputer = new import_core2.MerkleComputer(this.db);
+    const rowIds = merkleComputer.getBlockRowIds(table, blockIndex, blockSize);
+    const localRows = [];
+    for (const rowId of rowIds) {
+      const rowData = this.db.read(
+        `SELECT * FROM ${this.quoteId(table)} WHERE "id" = '${this.escapeSql(rowId)}'`
+      );
+      if (rowData.length > 0) {
+        const { row_hash, ...row } = rowData[0];
+        localRows.push(row);
+      }
+    }
+    const payload = {
+      table,
+      block_index: blockIndex,
+      block_size: blockSize,
+      rows: localRows,
+      client_row_ids: rowIds
+    };
+    const responseMap = await this.ws.sendRaw("merkle_lww_blocks", payload, channelTopic);
+    const response = {
+      type: "merkle_lww_blocks_response",
+      table: responseMap.table,
+      block_index: responseMap.block_index,
+      client_wins: responseMap.client_wins ?? [],
+      server_wins: responseMap.server_wins ?? [],
+      applied_from_client: responseMap.applied_from_client ?? 0,
+      sent_to_client: responseMap.sent_to_client ?? 0,
+      toMap() {
+        return this;
+      }
+    };
+    if (response.server_wins.length > 0) {
+      this.db.beginBulkRemote();
+      try {
+        for (const row of response.server_wins) {
+          const rowId = String(row.id ?? "");
+          if (!rowId) continue;
+          const isUpdate = rowIds.includes(rowId);
+          const change = {
+            type: "change",
+            table,
+            operation: isUpdate ? "update" : "insert",
+            row_id: rowId,
+            data: row,
+            toMap() {
+              return this;
+            }
+          };
+          const sql = this.generateSql(change);
+          this.db.execBulkRemote(sql);
+        }
+        await this.db.endBulkRemote();
+      } catch (e) {
+        await this.db.endBulkRemote(true);
+        throw e;
+      }
+    }
+    console.log(
+      `[SyncClient] repairLww: ${table} block ${blockIndex} - client_wins: ${response.applied_from_client}, server_wins: ${response.server_wins.length}`
+    );
+  }
+  // ==========================================================================
+  // END MERKLE TREE INTEGRITY VERIFICATION
+  // ==========================================================================
+  /**
+   * Dispose resources
+   */
+  async dispose() {
+    this.stopPeriodicSync();
+    if (this.syncOnWriteDebounceTimer) {
+      clearTimeout(this.syncOnWriteDebounceTimer);
+    }
+    this.remoteChangeListeners.clear();
+    this.snapshotCompleteListeners.clear();
+    this.jobUpdateListeners.clear();
+    this.livestreamListeners.clear();
+    this.conversationListeners.clear();
+    this.syncReadyStateListeners.clear();
+    this.syncStateListeners.clear();
+    this.syncProgressListeners.clear();
+    this.syncCompleteListeners.clear();
+    this.activeSyncCompleters.clear();
+    this.merkleVerificationListeners.clear();
+    await this.ws.dispose();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChannelRole,
+  ConnectionState,
+  MessageFactory,
+  RepairDirection,
+  SyncClient,
+  SyncReadyState,
+  SyncState,
+  WebSocketManager
+});