@stryke-xyz/premarket-sdk 1.2.1 → 1.2.2

package/dist/esm/sync/clients/order-client.js

@@ -124,6 +124,10 @@ function _sliced_to_array(arr, i) {
 function _to_consumable_array(arr) {
     return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
 }
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 function _unsupported_iterable_to_array(o, minLen) {
     if (!o) return;
     if (typeof o === "string") return _array_like_to_array(o, minLen);
@@ -238,21 +242,40 @@ function scheduleDeferred(callback) {
     }
     setTimeout(callback, 0);
 }
-/**
- * Normalize a price string to a canonical form for consistent map key lookups.
- * Converts "1.000000" and "1" both to "1" (removes trailing zeros after decimal).
- */ function normalizePrice(price) {
+function normalizePrice(price) {
     var num = parseFloat(price);
     if (isNaN(num)) return price;
     return num.toString();
 }
-/** Current depth state for a token within a market subscription. */ /** One bid or ask level change in the normalized SDK format. */ /** Raw level shape inside the wire `depth_update.levels[]` array. */ /** Raw `depth_update` frame as published by the depth projector. */ /** Consolidated depth update emitted to SDK listeners after normalization. */ /** Last applied executor sequenceId for this token (== endSeq of the frame). */ /** Range covered by this frame; clients can detect gaps via startSeq != prevSeq + 1. */ /** Configuration for the market depth websocket client. */ /** Heartbeat interval in ms (default: 30000) */ /** Heartbeat timeout - if no pong received within this time, reconnect (default: 10000) */ /** Max reconnection attempts before giving up (default: Infinity) */ /** Initial reconnect delay in ms (default: 1000) */ /** Max reconnect delay in ms (default: 30000) */ // Internal state per token
-// price -> depth
-// price -> depth
-// Current sequence ID for this token
+/** A market + its token IDs to subscribe to. */ /** Current depth state for a token within a market subscription. */ /** One bid or ask level change in the normalized SDK format. */ /** Raw level shape inside the wire `depth_update.levels[]` array. */ /** Raw `depth_update` frame as published by the depth projector. */ /** Consolidated depth update emitted to SDK listeners after normalization. */ /** Last applied executor sequenceId for this token (== endSeq of the frame). */ /** Range covered by this frame; clients can detect gaps via startSeq != prevSeq + 1. */ /**
+ * Configuration for the market depth websocket client.
+ *
+ * Supports multiple markets over a single WebSocket connection.
+ * Markets can be added/removed dynamically via subscribeMarket / unsubscribeMarket
+ * without closing the connection.
+ */ /** Initial market subscriptions. More can be added later via subscribeMarket(). */ /** Heartbeat interval in ms (default: 30000) */ /** Heartbeat timeout - if no pong received within this time, reconnect (default: 10000) */ /** Max reconnection attempts before giving up (default: Infinity) */ /** Initial reconnect delay in ms (default: 1000) */ /** Max reconnect delay in ms (default: 30000) */ /** @deprecated Use MarketDepthClientConfig with markets[] instead of marketId+tokenIds. */ // Internal state per token
+// price → depth
+// price → depth
 /**
- * Client for syncing orderbook depth data for multiple tokens in a market.
- * Seq is per market+token (gapless, monotonic). Each token tracks its own seq for dedup and gap detection.
+ * Client for syncing orderbook depth data for one or more markets over a
+ * single persistent WebSocket connection.
+ *
+ * Usage:
+ *   const client = new MarketDepthSyncClient({ wsUrl: "wss://..." });
+ *   await client.connect();
+ *
+ *   // Subscribe to markets dynamically (e.g. when they scroll into view)
+ *   client.subscribeMarket("5", ["0xabc..."]);
+ *
+ *   // Unsubscribe without closing the connection (e.g. scrolled out of view)
+ *   client.unsubscribeMarket("5");
+ *
+ *   // Listen for updates
+ *   const offDelta = client.onDelta((marketId, update) => { ... });
+ *   const offSnap  = client.onSnapshot((marketId, snapshots) => { ... });
+ *
+ *   // Full disconnect (app teardown)
+ *   await client.disconnect();
  */ export var MarketDepthSyncClient = /*#__PURE__*/ function() {
     "use strict";
     function MarketDepthSyncClient(config) {
@@ -260,11 +283,18 @@ function scheduleDeferred(callback) {
         _define_property(this, "ws", null);
         _define_property(this, "config", void 0);
         _define_property(this, "status", "disconnected");
-        // Per-token depth state (each token has its own gapless executor-seq counter)
+        // Per-token depth state (tokenIds are globally unique across all subscribed markets)
         _define_property(this, "tokenStates", new Map());
-        // Frame queue for ordering — frames received before initial snapshot are buffered.
-        _define_property(this, "frameQueue", []);
-        _define_property(this, "isProcessing", false);
+        // Active subscriptions: marketId → tokenIds[]
+        _define_property(this, "activeSubscriptions", new Map());
+        // Reverse map: tokenId → marketId (for gap resync targeting)
+        _define_property(this, "tokenToMarket", new Map());
+        // Markets that have received their initial snapshot on this connection
+        _define_property(this, "syncedMarkets", new Set());
+        // Per-market frame queues: buffer depth_updates received before snapshot
+        _define_property(this, "frameQueues", new Map());
+        // Per-market processing mutex
+        _define_property(this, "processingMarkets", new Set());
         // Listeners
         _define_property(this, "statusListeners", new Set());
         _define_property(this, "snapshotListeners", new Set());
@@ -273,121 +303,186 @@ function scheduleDeferred(callback) {
         _define_property(this, "shouldBeConnected", false);
         _define_property(this, "reconnectAttempts", 0);
         _define_property(this, "reconnectTimeoutId", null);
-        // Heartbeat state
+        // Heartbeat
         _define_property(this, "heartbeatIntervalId", null);
         _define_property(this, "heartbeatTimeoutId", null);
         _define_property(this, "lastPongTime", 0);
-        // Visibility change handler reference (for cleanup)
+        // Visibility handler
         _define_property(this, "visibilityChangeHandler", null);
+        // Support legacy single-market config (marketId + tokenIds)
+        var normalizedConfig = _object_spread({}, config);
+        if (config.marketId && config.tokenIds) {
+            var _config_markets;
+            normalizedConfig.markets = [
+                {
+                    marketId: config.marketId,
+                    tokenIds: config.tokenIds
+                }
+            ].concat(_to_consumable_array((_config_markets = config.markets) !== null && _config_markets !== void 0 ? _config_markets : []));
+        }
         this.config = _object_spread({
+            markets: [],
             heartbeatIntervalMs: 30000,
             heartbeatTimeoutMs: 10000,
             maxReconnectAttempts: Infinity,
             initialReconnectDelayMs: 1000,
             maxReconnectDelayMs: 30000
-        }, config);
+        }, normalizedConfig);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // Seed initial subscriptions from config
+            for(var _iterator = this.config.markets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var spec = _step.value;
+                this.activeSubscriptions.set(spec.marketId, _to_consumable_array(spec.tokenIds));
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = spec.tokenIds[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var tokenId = _step1.value;
+                        this.tokenToMarket.set(tokenId, spec.marketId);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
     }
     _create_class(MarketDepthSyncClient, [
         {
             key: "connect",
-            value: /** Connects to the market depth websocket and hydrates token snapshots. */ function connect() {
+            value: // ---------------------------------------------------------------------------
+            // Public API
+            // ---------------------------------------------------------------------------
+            /** Open the WebSocket connection and subscribe to all configured markets. */ function connect() {
                 return _async_to_generator(function() {
                     var _this, wsUrl;
                     return _ts_generator(this, function(_state) {
                         _this = this;
-                        // Clean up any existing connection first
                         this.stopHeartbeat();
                         this.clearReconnectTimeout();
                         if (this.ws) {
                             this.ws.onclose = null;
-                            // Prevent triggering reconnect
                             this.ws.close();
                             this.ws = null;
                         }
                         this.shouldBeConnected = true;
+                        this.syncedMarkets.clear();
+                        this.frameQueues.clear();
+                        this.processingMarkets.clear();
                         this.setStatus("connecting");
                         wsUrl = this.config.wsUrl;
                         if (!wsUrl.startsWith("ws://") && !wsUrl.startsWith("wss://")) {
                             throw new Error("Invalid WebSocket URL: ".concat(wsUrl));
                         }
-                        // Prevent queue processing until snapshots are received
-                        this.isProcessing = true;
-                        // Set up visibility change handler
                         this.setupVisibilityChangeHandler();
                         return [
                             2,
                             new Promise(function(resolve, reject) {
                                 var settled = false;
                                 var resolveOnce = function() {
-                                    if (settled) return;
-                                    settled = true;
-                                    resolve();
+                                    if (!settled) {
+                                        settled = true;
+                                        resolve();
+                                    }
                                 };
-                                var rejectOnce = function(error) {
-                                    if (settled) return;
-                                    settled = true;
-                                    reject(error);
+                                var rejectOnce = function(e) {
+                                    if (!settled) {
+                                        settled = true;
+                                        reject(e);
+                                    }
                                 };
                                 _this.ws = new WebSocket(wsUrl);
                                 _this.ws.onopen = function() {
-                                    // Reset reconnect attempts on successful connection
                                     _this.reconnectAttempts = 0;
                                     _this.lastPongTime = Date.now();
-                                    // Send subscribe_market message
-                                    _this.ws.send(JSON.stringify({
-                                        type: "subscribe_market",
-                                        marketId: _this.config.marketId,
-                                        tokenIds: _this.config.tokenIds
-                                    }));
-                                    // Start heartbeat
                                     _this.startHeartbeat();
+                                    if (_this.activeSubscriptions.size === 0) {
+                                        _this.setStatus("synced");
+                                        resolveOnce();
+                                    } else {
+                                        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                        try {
+                                            for(var _iterator = _this.activeSubscriptions[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                                var _step_value = _sliced_to_array(_step.value, 2), marketId = _step_value[0], tokenIds = _step_value[1];
+                                                _this._sendSubscribeMarket(marketId, tokenIds);
+                                            }
+                                        } catch (err) {
+                                            _didIteratorError = true;
+                                            _iteratorError = err;
+                                        } finally{
+                                            try {
+                                                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                                    _iterator.return();
+                                                }
+                                            } finally{
+                                                if (_didIteratorError) {
+                                                    throw _iteratorError;
+                                                }
+                                            }
+                                        }
+                                        // Resolve immediately once WS is open — snapshots arrive async
+                                        resolveOnce();
+                                    }
                                 };
                                 _this.ws.onmessage = function(event) {
                                     try {
                                         var msg = JSON.parse(event.data);
-                                        // Handle pong response
                                         if (msg.type === "pong") {
                                             _this.lastPongTime = Date.now();
                                             _this.clearHeartbeatTimeout();
                                             return;
                                         }
                                         if (msg.type === "subscribed_market") {
-                                            // Received initial snapshots
                                             _this.handleSubscribedMarket(msg);
-                                            _this.isProcessing = false;
-                                            _this.setStatus("synced");
-                                            void _this.processFrameQueue();
-                                            resolveOnce();
                                         } else if (msg.type === "depth_update") {
                                             _this.handleDepthUpdate(msg);
                                         } else if (msg.type === "market_state") {
-                                            // Received market state (bestBid, bestAsk, lastPrice) - preferred over last_price
                                             _this.handleMarketStateUpdate(msg);
                                         } else if (msg.type === "last_price") {
-                                            // Legacy: last price only (still supported)
                                             _this.handleLastPriceUpdate(msg);
                                         } else if (msg.type === "error") {
-                                            console.error("WebSocket error:", msg.message);
+                                            console.error("[MarketDepthSyncClient] server error:", msg.message);
                                             rejectOnce(new Error(msg.message));
                                         }
                                     } catch (error) {
-                                        console.error("Error parsing message:", error);
+                                        console.error("[MarketDepthSyncClient] parse error:", error);
                                     }
                                 };
                                 _this.ws.onerror = function(error) {
-                                    console.error("WebSocket error:", error);
-                                    // Only reject if this is the initial connection
                                     if (_this.status === "connecting") {
                                         rejectOnce(error);
                                     }
                                 };
                                 _this.ws.onclose = function() {
                                     _this.stopHeartbeat();
+                                    _this.syncedMarkets.clear();
                                     _this.setStatus("disconnected");
                                     if (!settled) {
-                                        rejectOnce(new Error("WebSocket closed before initial depth snapshot"));
+                                        rejectOnce(new Error("[MarketDepthSyncClient] WebSocket closed before connecting"));
                                     }
-                                    // Attempt to reconnect if we should still be connected
                                     if (_this.shouldBeConnected) {
                                         _this.scheduleReconnect();
                                     }
@@ -399,210 +494,257 @@ function scheduleDeferred(callback) {
             }
         },
         {
-            key: "setupVisibilityChangeHandler",
-            value: function setupVisibilityChangeHandler() {
-                var _this = this;
-                // Only set up in browser environment
-                if (typeof document === "undefined") return;
-                // Remove existing handler if any
-                this.removeVisibilityChangeHandler();
-                this.visibilityChangeHandler = function() {
-                    if (document.visibilityState === "visible" && _this.shouldBeConnected) {
-                        // Tab became visible - check if connection is still healthy
-                        _this.checkConnectionHealth();
+            /**
+   * Subscribe to a market's depth. If the WebSocket is already open, sends the
+   * `subscribe_market` message immediately. Otherwise, the subscription is queued
+   * and sent when the connection opens. Calling this for an already-subscribed
+   * market re-requests a fresh snapshot.
+   */ key: "subscribeMarket",
+            value: function subscribeMarket(marketId, tokenIds) {
+                this.activeSubscriptions.set(marketId, _to_consumable_array(tokenIds));
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = tokenIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var tokenId = _step.value;
+                        this.tokenToMarket.set(tokenId, marketId);
                     }
-                };
-                document.addEventListener("visibilitychange", this.visibilityChangeHandler);
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    this._sendSubscribeMarket(marketId, tokenIds);
+                }
             }
         },
         {
-            key: "removeVisibilityChangeHandler",
-            value: function removeVisibilityChangeHandler() {
-                if (typeof document === "undefined") return;
-                if (this.visibilityChangeHandler) {
-                    document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
-                    this.visibilityChangeHandler = null;
+            /**
+   * Unsubscribe from a market. Sends `unsubscribe_market` to the server and
+   * clears local state for that market's tokens. The WebSocket connection is
+   * kept open for other subscriptions.
+   */ key: "unsubscribeMarket",
+            value: function unsubscribeMarket(marketId) {
+                var _this_activeSubscriptions_get;
+                var tokenIds = (_this_activeSubscriptions_get = this.activeSubscriptions.get(marketId)) !== null && _this_activeSubscriptions_get !== void 0 ? _this_activeSubscriptions_get : [];
+                this.activeSubscriptions.delete(marketId);
+                this.syncedMarkets.delete(marketId);
+                this.frameQueues.delete(marketId);
+                this.processingMarkets.delete(marketId);
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = tokenIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var tokenId = _step.value;
+                        this.tokenStates.delete(tokenId);
+                        this.tokenToMarket.delete(tokenId);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                    try {
+                        this.ws.send(JSON.stringify({
+                            type: "unsubscribe_market",
+                            marketId: marketId
+                        }));
+                    } catch (unused) {}
                 }
             }
         },
         {
-            key: "checkConnectionHealth",
-            value: function checkConnectionHealth() {
-                var _this = this;
-                if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-                    // Connection is dead, trigger reconnect
-                    console.log("Connection unhealthy on visibility change, reconnecting...");
-                    this.handleConnectionLost();
-                    return;
-                }
-                // Send a ping to verify the connection is actually working
-                try {
-                    this.ws.send(JSON.stringify({
-                        type: "ping"
-                    }));
-                    // Set a timeout for the pong response
-                    this.clearHeartbeatTimeout();
-                    this.heartbeatTimeoutId = setTimeout(function() {
-                        console.log("Ping timeout on visibility change, reconnecting...");
-                        _this.handleConnectionLost();
-                    }, this.config.heartbeatTimeoutMs);
-                } catch (unused) {
-                    // Send failed, connection is dead
-                    this.handleConnectionLost();
-                }
+            key: "disconnect",
+            value: // Ignore — connection closing
+            /** Fully disconnect and stop reconnecting. */ function disconnect() {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        this.shouldBeConnected = false;
+                        this.stopHeartbeat();
+                        this.clearReconnectTimeout();
+                        this.removeVisibilityChangeHandler();
+                        if (this.ws) {
+                            this.ws.onclose = null;
+                            this.ws.close();
+                            this.ws = null;
+                        }
+                        this.syncedMarkets.clear();
+                        this.setStatus("disconnected");
+                        return [
+                            2
+                        ];
+                    });
+                }).call(this);
             }
         },
         {
-            key: "handleConnectionLost",
-            value: function handleConnectionLost() {
-                this.stopHeartbeat();
-                if (this.ws) {
-                    this.ws.onclose = null;
-                    // Prevent double-triggering
-                    this.ws.close();
-                    this.ws = null;
-                }
-                this.setStatus("disconnected");
-                if (this.shouldBeConnected) {
-                    this.scheduleReconnect();
-                }
+            key: "getStatus",
+            value: function getStatus() {
+                return this.status;
             }
         },
         {
-            key: "startHeartbeat",
-            value: function startHeartbeat() {
-                var _this = this;
-                this.stopHeartbeat();
-                this.heartbeatIntervalId = setInterval(function() {
-                    if (!_this.ws || _this.ws.readyState !== WebSocket.OPEN) {
-                        return;
-                    }
-                    try {
-                        _this.ws.send(JSON.stringify({
-                            type: "ping"
-                        }));
-                        // Set timeout for pong response
-                        _this.clearHeartbeatTimeout();
-                        _this.heartbeatTimeoutId = setTimeout(function() {
-                            console.log("Heartbeat timeout, reconnecting...");
-                            _this.handleConnectionLost();
-                        }, _this.config.heartbeatTimeoutMs);
-                    } catch (unused) {
-                        // Send failed, connection is dead
-                        _this.handleConnectionLost();
-                    }
-                }, this.config.heartbeatIntervalMs);
+            key: "isSynced",
+            value: function isSynced() {
+                if (this.activeSubscriptions.size === 0) return this.status === "synced";
+                return this.activeSubscriptions.size === this.syncedMarkets.size;
             }
         },
         {
-            key: "stopHeartbeat",
-            value: function stopHeartbeat() {
-                if (this.heartbeatIntervalId) {
-                    clearInterval(this.heartbeatIntervalId);
-                    this.heartbeatIntervalId = null;
-                }
-                this.clearHeartbeatTimeout();
+            key: "isMarketSynced",
+            value: function isMarketSynced(marketId) {
+                return this.syncedMarkets.has(marketId);
             }
         },
         {
-            key: "clearHeartbeatTimeout",
-            value: function clearHeartbeatTimeout() {
-                if (this.heartbeatTimeoutId) {
-                    clearTimeout(this.heartbeatTimeoutId);
-                    this.heartbeatTimeoutId = null;
-                }
+            key: "getBids",
+            value: function getBids(tokenId) {
+                var state = this.tokenStates.get(tokenId);
+                if (!state) return [];
+                return Array.from(state.bids.entries()).map(function(param) {
+                    var _param = _sliced_to_array(param, 2), price = _param[0], depth = _param[1];
+                    return {
+                        price: price,
+                        depth: depth
+                    };
+                });
             }
         },
         {
-            key: "scheduleReconnect",
-            value: function scheduleReconnect() {
-                var _this = this;
-                if (!this.shouldBeConnected) return;
-                var maxAttempts = this.config.maxReconnectAttempts;
-                if (this.reconnectAttempts >= maxAttempts) {
-                    console.error("Max reconnection attempts (".concat(maxAttempts, ") reached, giving up"));
-                    return;
-                }
-                // Exponential backoff with jitter
-                var baseDelay = this.config.initialReconnectDelayMs;
-                var maxDelay = this.config.maxReconnectDelayMs;
-                var delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts) + Math.random() * 1000, maxDelay);
-                this.reconnectAttempts++;
-                this.setStatus("recovering");
-                console.log("Scheduling reconnect attempt ".concat(this.reconnectAttempts, " in ").concat(Math.round(delay), "ms"));
-                this.clearReconnectTimeout();
-                this.reconnectTimeoutId = setTimeout(function() {
-                    _this.performReconnect();
-                }, delay);
+            key: "getAsks",
+            value: function getAsks(tokenId) {
+                var state = this.tokenStates.get(tokenId);
+                if (!state) return [];
+                return Array.from(state.asks.entries()).map(function(param) {
+                    var _param = _sliced_to_array(param, 2), price = _param[0], depth = _param[1];
+                    return {
+                        price: price,
+                        depth: depth
+                    };
+                });
             }
         },
         {
-            key: "clearReconnectTimeout",
-            value: function clearReconnectTimeout() {
-                if (this.reconnectTimeoutId) {
-                    clearTimeout(this.reconnectTimeoutId);
-                    this.reconnectTimeoutId = null;
-                }
+            key: "getBestBid",
+            value: function getBestBid(tokenId) {
+                var _ref;
+                var _this_tokenStates_get;
+                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.bestBid) !== null && _ref !== void 0 ? _ref : null;
             }
         },
         {
-            key: "performReconnect",
-            value: function performReconnect() {
-                return _async_to_generator(function() {
-                    var error;
-                    return _ts_generator(this, function(_state) {
-                        switch(_state.label){
-                            case 0:
-                                if (!this.shouldBeConnected) return [
-                                    2
-                                ];
-                                _state.label = 1;
-                            case 1:
-                                _state.trys.push([
-                                    1,
-                                    3,
-                                    ,
-                                    4
-                                ]);
-                                // Clear state before reconnecting
-                                this.tokenStates.clear();
-                                this.frameQueue = [];
-                                return [
-                                    4,
-                                    this.connect()
-                                ];
-                            case 2:
-                                _state.sent();
-                                console.log("Reconnected successfully");
-                                return [
-                                    3,
-                                    4
-                                ];
-                            case 3:
-                                error = _state.sent();
-                                console.error("Reconnection failed:", error);
-                                return [
-                                    3,
-                                    4
-                                ];
-                            case 4:
-                                return [
-                                    2
-                                ];
-                        }
-                    });
-                }).call(this);
+            key: "getBestAsk",
+            value: function getBestAsk(tokenId) {
+                var _ref;
+                var _this_tokenStates_get;
+                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.bestAsk) !== null && _ref !== void 0 ? _ref : null;
             }
         },
         {
-            key: "handleSubscribedMarket",
-            value: // Will trigger another reconnect via onclose handler
-            function handleSubscribedMarket(msg) {
-                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                try {
-                    // Initialize state for each token from snapshots (seq is the executor
-                    // sequenceId, monotonic per token).
-                    for(var _iterator = msg.snapshots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            key: "getLastPrice",
+            value: function getLastPrice(tokenId) {
+                var _ref;
+                var _this_tokenStates_get;
+                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.lastPrice) !== null && _ref !== void 0 ? _ref : null;
+            }
+        },
+        {
+            key: "onSnapshot",
+            value: function onSnapshot(listener) {
+                var _this = this;
+                this.snapshotListeners.add(listener);
+                return function() {
+                    return _this.snapshotListeners.delete(listener);
+                };
+            }
+        },
+        {
+            key: "onDelta",
+            value: function onDelta(listener) {
+                var _this = this;
+                this.deltaListeners.add(listener);
+                return function() {
+                    return _this.deltaListeners.delete(listener);
+                };
+            }
+        },
+        {
+            key: "onStatus",
+            value: function onStatus(listener) {
+                var _this = this;
+                this.statusListeners.add(listener);
+                return function() {
+                    return _this.statusListeners.delete(listener);
+                };
+            }
+        },
+        {
+            key: "_sendSubscribeMarket",
+            value: // ---------------------------------------------------------------------------
+            // Private — WS message handlers
+            // ---------------------------------------------------------------------------
+            function _sendSubscribeMarket(marketId, tokenIds) {
+                var _this_activeSubscriptions_get;
+                // Clear stale state so we get a clean snapshot
+                var existingTokenIds = (_this_activeSubscriptions_get = this.activeSubscriptions.get(marketId)) !== null && _this_activeSubscriptions_get !== void 0 ? _this_activeSubscriptions_get : tokenIds;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = existingTokenIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var tokenId = _step.value;
+                        this.tokenStates.delete(tokenId);
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                this.syncedMarkets.delete(marketId);
+                this.frameQueues.delete(marketId);
+                try {
+                    this.ws.send(JSON.stringify({
+                        type: "subscribe_market",
+                        marketId: marketId,
+                        tokenIds: tokenIds
+                    }));
+                } catch (e) {
+                    console.warn("[MarketDepthSyncClient] failed to send subscribe_market:", e);
+                }
+            }
+        },
+        {
+            key: "handleSubscribedMarket",
+            value: function handleSubscribedMarket(msg) {
+                var marketId = msg.marketId, snapshots = msg.snapshots;
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    for(var _iterator = snapshots[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                         var snapshot = _step.value;
                         var state = {
                             bids: new Map(),
@@ -668,20 +810,38 @@ function scheduleDeferred(callback) {
                         }
                     }
                 }
+                this.syncedMarkets.add(marketId);
+                if (this.activeSubscriptions.size > 0 && this.syncedMarkets.size >= this.activeSubscriptions.size) {
+                    this.setStatus("synced");
+                }
                 this.snapshotListeners.forEach(function(listener) {
                     try {
-                        listener(msg.snapshots);
-                    } catch (error) {
-                        console.error("Error in snapshot listener:", error);
+                        listener(marketId, snapshots);
+                    } catch (e) {
+                        console.error(e);
                     }
                 });
+                // Process any buffered depth_updates for this market
+                void this.processFrameQueue(marketId);
             }
         },
         {
             key: "handleDepthUpdate",
             value: function handleDepthUpdate(msg) {
-                this.frameQueue.push(msg);
-                void this.processFrameQueue();
+                var marketId = msg.marketId;
+                if (!this.syncedMarkets.has(marketId)) {
+                    // Buffer until snapshot arrives
+                    if (!this.frameQueues.has(marketId)) {
+                        this.frameQueues.set(marketId, []);
+                    }
+                    this.frameQueues.get(marketId).push(msg);
+                    return;
+                }
+                if (!this.frameQueues.has(marketId)) {
+                    this.frameQueues.set(marketId, []);
+                }
+                this.frameQueues.get(marketId).push(msg);
+                void this.processFrameQueue(marketId);
             }
         },
         {
@@ -689,83 +849,88 @@ function scheduleDeferred(callback) {
             value: function handleMarketStateUpdate(msg) {
                 var _msg_bestBid, _msg_bestAsk, _msg_lastPrice;
                 var state = this.tokenStates.get(String(msg.tokenId));
-                if (!state) {
-                    return;
-                }
+                if (!state) return;
                 state.bestBid = (_msg_bestBid = msg.bestBid) !== null && _msg_bestBid !== void 0 ? _msg_bestBid : state.bestBid;
                 state.bestAsk = (_msg_bestAsk = msg.bestAsk) !== null && _msg_bestAsk !== void 0 ? _msg_bestAsk : state.bestAsk;
                 state.lastPrice = (_msg_lastPrice = msg.lastPrice) !== null && _msg_lastPrice !== void 0 ? _msg_lastPrice : state.lastPrice;
-                this.emitOutOfBandUpdate(msg.tokenId, state);
+                this.emitOutOfBandUpdate(msg.marketId, msg.tokenId, state);
             }
         },
         {
             key: "handleLastPriceUpdate",
             value: function handleLastPriceUpdate(msg) {
+                var _ref, _msg_marketId;
                 var state = this.tokenStates.get(String(msg.tokenId));
-                if (!state) {
-                    return;
-                }
+                if (!state) return;
                 state.lastPrice = msg.lastPrice;
-                this.emitOutOfBandUpdate(msg.tokenId, state);
+                var marketId = (_ref = (_msg_marketId = msg.marketId) !== null && _msg_marketId !== void 0 ? _msg_marketId : this.tokenToMarket.get(msg.tokenId)) !== null && _ref !== void 0 ? _ref : "";
+                this.emitOutOfBandUpdate(marketId, msg.tokenId, state);
             }
         },
         {
             key: "emitOutOfBandUpdate",
-            value: /** Emit a delta with empty levels for events that mutate side-state but no levels (market_state, last_price). */ function emitOutOfBandUpdate(tokenId, state) {
-                var _this = this;
+            value: function emitOutOfBandUpdate(marketId, tokenId, state) {
+                var update = {
+                    tokenId: tokenId,
+                    levels: [],
+                    bestBid: state.bestBid,
+                    bestAsk: state.bestAsk,
+                    lastPrice: state.lastPrice,
+                    seq: state.seq,
+                    startSeq: state.seq,
+                    endSeq: state.seq
+                };
                 this.deltaListeners.forEach(function(listener) {
                     try {
-                        var update = {
-                            tokenId: tokenId,
-                            levels: [],
-                            bestBid: state.bestBid,
-                            bestAsk: state.bestAsk,
-                            lastPrice: state.lastPrice,
-                            seq: state.seq,
-                            startSeq: state.seq,
-                            endSeq: state.seq
-                        };
-                        listener(_this.config.marketId, update);
-                    } catch (error) {
-                        console.error("Error in delta listener:", error);
+                        listener(marketId, update);
+                    } catch (e) {
+                        console.error(e);
                     }
                 });
             }
         },
         {
             key: "processFrameQueue",
-            value: function processFrameQueue() {
+            value: function processFrameQueue(marketId) {
                 return _async_to_generator(function() {
-                    var _this, _this1, _loop;
+                    var _this, _this1, _loop, queue, _ret, queue1;
                     return _ts_generator(this, function(_state) {
                         _this = this;
-                        if (this.isProcessing) return [
+                        if (this.processingMarkets.has(marketId)) return [
                             2
                         ];
-                        this.isProcessing = true;
+                        this.processingMarkets.add(marketId);
                         try {
                             _loop = function() {
-                                var frame = _this1.frameQueue.shift();
+                                var frame = queue.shift();
                                 var state = _this1.tokenStates.get(String(frame.tokenId));
                                 if (!state) return "continue";
                                 var startSeq = parseInt(frame.startSeq, 10);
                                 var endSeq = parseInt(frame.endSeq, 10);
-                                // Whole frame already applied (e.g. reconnect after partial JetStream replay)
-                                if (endSeq <= state.seq) return "continue";
-                                // Gap detection: startSeq should be exactly state.seq + 1.
-                                // Depth values are absolute, so a gap is a soft warning, not a hard fail.
-                                if (state.seq > 0 && startSeq > state.seq + 1) {
-                                    console.warn("[MarketDepth] Gap tokenId=".concat(frame.tokenId, " expected=").concat(state.seq + 1, " got=").concat(startSeq, " (frame ").concat(startSeq, "..").concat(endSeq, "). Continuing — depth is absolute."));
+                                // endSeq=0 is a sentinel meaning "no sequence tracking" — always apply.
+                                // Non-zero endSeq <= state.seq means this frame was already applied.
+                                if (endSeq !== 0 && endSeq <= state.seq) return "continue";
+                                // Gap detection: warn and trigger resync for that specific market.
+                                if (state.seq > 0 && startSeq > 0 && startSeq > state.seq + 1) {
+                                    console.warn("[MarketDepthSyncClient] gap detected tokenId=".concat(frame.tokenId, " ") + "expected=".concat(state.seq + 1, " got=").concat(startSeq, " — resyncing market ").concat(marketId));
+                                    // Re-subscribe to get a fresh snapshot (clears state, re-sends subscribe)
+                                    var tokenIds = _this1.activeSubscriptions.get(marketId);
+                                    if (tokenIds && _this1.ws && _this1.ws.readyState === WebSocket.OPEN) {
+                                        _this1._sendSubscribeMarket(marketId, tokenIds);
+                                    }
+                                    return {
+                                        v: void void 0
+                                    };
                                 }
+                                // Stop processing stale queue; new snapshot will restart it
                                 var emittedLevels = [];
                                 var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 try {
                                     for(var _iterator = frame.levels[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                                         var lv = _step.value;
-                                        // Per-level dedup against state.seq guards against re-applying
-                                        // levels from a partially-applied previous frame.
                                         var lvSeq = parseInt(lv.seq, 10);
-                                        if (lvSeq <= state.seq) continue;
+                                        // lvSeq=0 means no sequence → always apply (same sentinel logic as endSeq)
+                                        if (lvSeq !== 0 && lvSeq <= state.seq) continue;
                                         _this1.applyLevel(lv, state);
                                         emittedLevels.push({
                                             side: lv.side,
@@ -787,32 +952,44 @@ function scheduleDeferred(callback) {
                                         }
                                     }
                                 }
-                                state.seq = endSeq;
+                                // Advance seq only when endSeq is meaningful
+                                if (endSeq > state.seq) state.seq = endSeq;
                                 if (emittedLevels.length === 0) return "continue";
+                                var update = {
+                                    tokenId: frame.tokenId,
+                                    levels: emittedLevels,
+                                    bestBid: state.bestBid,
+                                    bestAsk: state.bestAsk,
+                                    lastPrice: state.lastPrice,
+                                    seq: state.seq,
+                                    startSeq: startSeq,
+                                    endSeq: endSeq
+                                };
                                 _this1.deltaListeners.forEach(function(listener) {
                                     try {
-                                        var update = {
-                                            tokenId: frame.tokenId,
-                                            levels: emittedLevels,
-                                            bestBid: state.bestBid,
-                                            bestAsk: state.bestAsk,
-                                            lastPrice: state.lastPrice,
-                                            seq: endSeq,
-                                            startSeq: startSeq,
-                                            endSeq: endSeq
-                                        };
-                                        listener(_this.config.marketId, update);
-                                    } catch (error) {
-                                        console.error("Error in delta listener:", error);
+                                        listener(marketId, update);
+                                    } catch (e) {
+                                        console.error(e);
                                     }
                                 });
                             };
-                            while(this.frameQueue.length > 0)_this1 = this, _loop();
+                            queue = this.frameQueues.get(marketId);
+                            if (!queue) return [
+                                2
+                            ];
+                            while(queue.length > 0){
+                                _ret = (_this1 = this, _loop());
+                                if (_type_of(_ret) === "object") return [
+                                    2,
+                                    _ret.v
+                                ];
+                            }
                         } finally{
-                            this.isProcessing = false;
-                            if (this.frameQueue.length > 0) {
+                            this.processingMarkets.delete(marketId);
+                            queue1 = this.frameQueues.get(marketId);
+                            if (queue1 && queue1.length > 0) {
                                 scheduleDeferred(function() {
-                                    void _this.processFrameQueue();
+                                    void _this.processFrameQueue(marketId);
                                 });
                             }
                         }
@@ -834,7 +1011,6 @@ function scheduleDeferred(callback) {
                 } else {
                     map.set(key, level.depth);
                 }
-                // Recalculate best prices from current state
                 if (level.side === "bid") {
                     var _Math;
                     var bidPrices = Array.from(state.bids.keys()).map(function(p) {
@@ -858,186 +1034,190 @@ function scheduleDeferred(callback) {
                 this.statusListeners.forEach(function(listener) {
                     try {
                         listener(status);
-                    } catch (error) {
-                        console.error("Error in status listener:", error);
+                    } catch (e) {
+                        console.error(e);
                     }
                 });
             }
         },
         {
-            // Public API
-            /** Returns the current connection lifecycle state. */ key: "getStatus",
-            value: function getStatus() {
-                return this.status;
-            }
-        },
-        {
-            /** Returns true once initial depth snapshots have been received. */ key: "isSynced",
-            value: function isSynced() {
-                return this.status === "synced";
-            }
-        },
-        {
-            /** Returns all token ids currently tracked by the client. */ key: "getTokenIds",
-            value: function getTokenIds() {
-                return Array.from(this.tokenStates.keys());
-            }
-        },
-        {
-            /** Returns raw internal token state for advanced integrations. */ key: "getTokenState",
-            value: function getTokenState(tokenId) {
-                return this.tokenStates.get(tokenId);
-            }
-        },
-        {
-            /** Returns the current bid ladder for a token, sorted from highest to lowest price. */ key: "getBids",
-            value: function getBids(tokenId) {
-                var state = this.tokenStates.get(tokenId);
-                if (!state) return [];
-                return Array.from(state.bids.entries()).map(function(param) {
-                    var _param = _sliced_to_array(param, 2), price = _param[0], depth = _param[1];
-                    return {
-                        price: price,
-                        depth: depth
-                    };
-                }).sort(function(a, b) {
-                    return parseFloat(b.price) - parseFloat(a.price);
-                });
-            }
-        },
-        {
-            // Highest first
-            /** Returns the current ask ladder for a token, sorted from lowest to highest price. */ key: "getAsks",
-            value: function getAsks(tokenId) {
-                var state = this.tokenStates.get(tokenId);
-                if (!state) return [];
-                return Array.from(state.asks.entries()).map(function(param) {
-                    var _param = _sliced_to_array(param, 2), price = _param[0], depth = _param[1];
-                    return {
-                        price: price,
-                        depth: depth
-                    };
-                }).sort(function(a, b) {
-                    return parseFloat(a.price) - parseFloat(b.price);
-                });
-            }
-        },
-        {
-            // Lowest first
-            /** Returns the best bid price for a token, if known. */ key: "getBestBid",
-            value: function getBestBid(tokenId) {
-                var _ref;
-                var _this_tokenStates_get;
-                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.bestBid) !== null && _ref !== void 0 ? _ref : null;
+            key: "setupVisibilityChangeHandler",
+            value: // ---------------------------------------------------------------------------
+            // Private — reconnection & heartbeat
+            // ---------------------------------------------------------------------------
+            function setupVisibilityChangeHandler() {
+                var _this = this;
+                if (typeof document === "undefined") return;
+                this.removeVisibilityChangeHandler();
+                this.visibilityChangeHandler = function() {
+                    if (document.visibilityState === "visible" && _this.shouldBeConnected) {
+                        _this.checkConnectionHealth();
+                    }
+                };
+                document.addEventListener("visibilitychange", this.visibilityChangeHandler);
             }
         },
         {
-            /** Returns the best ask price for a token, if known. */ key: "getBestAsk",
-            value: function getBestAsk(tokenId) {
-                var _ref;
-                var _this_tokenStates_get;
-                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.bestAsk) !== null && _ref !== void 0 ? _ref : null;
+            key: "removeVisibilityChangeHandler",
+            value: function removeVisibilityChangeHandler() {
+                if (typeof document === "undefined") return;
+                if (this.visibilityChangeHandler) {
+                    document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
+                    this.visibilityChangeHandler = null;
+                }
             }
         },
         {
-            /** Returns the latest trade price tracked for a token, if any. */ key: "getLastPrice",
-            value: function getLastPrice(tokenId) {
-                var _ref;
-                var _this_tokenStates_get;
-                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.lastPrice) !== null && _ref !== void 0 ? _ref : null;
+            key: "checkConnectionHealth",
+            value: function checkConnectionHealth() {
+                var _this = this;
+                if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+                    this.handleConnectionLost();
+                    return;
+                }
+                try {
+                    this.ws.send(JSON.stringify({
+                        type: "ping"
+                    }));
+                    this.clearHeartbeatTimeout();
+                    this.heartbeatTimeoutId = setTimeout(function() {
+                        _this.handleConnectionLost();
+                    }, this.config.heartbeatTimeoutMs);
+                } catch (unused) {
+                    this.handleConnectionLost();
+                }
             }
         },
         {
-            /** Returns the latest applied sequence id for a token. */ key: "getSeq",
-            value: function getSeq(tokenId) {
-                var _ref;
-                var _this_tokenStates_get;
-                return (_ref = (_this_tokenStates_get = this.tokenStates.get(tokenId)) === null || _this_tokenStates_get === void 0 ? void 0 : _this_tokenStates_get.seq) !== null && _ref !== void 0 ? _ref : 0;
+            key: "handleConnectionLost",
+            value: function handleConnectionLost() {
+                this.stopHeartbeat();
+                if (this.ws) {
+                    this.ws.onclose = null;
+                    this.ws.close();
+                    this.ws = null;
+                }
+                this.setStatus("disconnected");
+                if (this.shouldBeConnected) {
+                    this.scheduleReconnect();
+                }
             }
         },
         {
-            /** Returns the current bid-ask spread for a token when both sides are available. */ key: "getSpread",
-            value: function getSpread(tokenId) {
-                var state = this.tokenStates.get(tokenId);
-                if (!state || !state.bestBid || !state.bestAsk) return null;
-                return parseFloat(state.bestAsk) - parseFloat(state.bestBid);
+            key: "startHeartbeat",
+            value: function startHeartbeat() {
+                var _this = this;
+                this.stopHeartbeat();
+                this.heartbeatIntervalId = setInterval(function() {
+                    if (!_this.ws || _this.ws.readyState !== WebSocket.OPEN) return;
+                    try {
+                        _this.ws.send(JSON.stringify({
+                            type: "ping"
+                        }));
+                        _this.clearHeartbeatTimeout();
+                        _this.heartbeatTimeoutId = setTimeout(function() {
+                            _this.handleConnectionLost();
+                        }, _this.config.heartbeatTimeoutMs);
+                    } catch (unused) {
+                        _this.handleConnectionLost();
+                    }
+                }, this.config.heartbeatIntervalMs);
             }
         },
         {
-            /** Returns the depth resting at one exact price level on a given side. */ key: "getDepthAtPrice",
-            value: function getDepthAtPrice(tokenId, side, price) {
-                var state = this.tokenStates.get(tokenId);
-                if (!state) return null;
-                var map = side === "bid" ? state.bids : state.asks;
-                return map.get(normalizePrice(price)) || null;
+            key: "stopHeartbeat",
+            value: function stopHeartbeat() {
+                if (this.heartbeatIntervalId) {
+                    clearInterval(this.heartbeatIntervalId);
+                    this.heartbeatIntervalId = null;
+                }
+                this.clearHeartbeatTimeout();
             }
         },
         {
-            // Event listeners
-            /** Registers a listener for connection lifecycle updates. */ key: "onStatus",
-            value: function onStatus(callback) {
-                var _this = this;
-                this.statusListeners.add(callback);
-                return function() {
-                    return _this.statusListeners.delete(callback);
-                };
+            key: "clearHeartbeatTimeout",
+            value: function clearHeartbeatTimeout() {
+                if (this.heartbeatTimeoutId) {
+                    clearTimeout(this.heartbeatTimeoutId);
+                    this.heartbeatTimeoutId = null;
+                }
             }
         },
         {
-            /** Registers a listener that receives full snapshots for all subscribed tokens. */ key: "onSnapshot",
-            value: function onSnapshot(callback) {
+            key: "scheduleReconnect",
+            value: function scheduleReconnect() {
                 var _this = this;
-                this.snapshotListeners.add(callback);
-                return function() {
-                    return _this.snapshotListeners.delete(callback);
-                };
+                if (!this.shouldBeConnected) return;
+                var maxAttempts = this.config.maxReconnectAttempts;
+                if (this.reconnectAttempts >= maxAttempts) {
+                    console.error("[MarketDepthSyncClient] max reconnect attempts (".concat(maxAttempts, ") reached"));
+                    return;
+                }
+                var baseDelay = this.config.initialReconnectDelayMs;
+                var maxDelay = this.config.maxReconnectDelayMs;
+                var delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts) + Math.random() * 1000, maxDelay);
+                this.reconnectAttempts++;
+                this.setStatus("recovering");
+                this.clearReconnectTimeout();
+                this.reconnectTimeoutId = setTimeout(function() {
+                    void _this.performReconnect();
+                }, delay);
             }
         },
         {
-            /** Registers a listener for normalized incremental depth updates. */ key: "onDelta",
-            value: function onDelta(callback) {
-                var _this = this;
-                this.deltaListeners.add(callback);
-                return function() {
-                    return _this.deltaListeners.delete(callback);
-                };
+            key: "clearReconnectTimeout",
+            value: function clearReconnectTimeout() {
+                if (this.reconnectTimeoutId) {
+                    clearTimeout(this.reconnectTimeoutId);
+                    this.reconnectTimeoutId = null;
+                }
             }
         },
         {
-            key: "disconnect",
-            value: /** Closes the websocket and stops automatic reconnection attempts. */ function disconnect() {
+            key: "performReconnect",
+            value: function performReconnect() {
                 return _async_to_generator(function() {
+                    var error;
                     return _ts_generator(this, function(_state) {
-                        // Mark that we intentionally want to disconnect
-                        this.shouldBeConnected = false;
-                        this.isProcessing = true;
-                        // Clean up all timers and handlers
-                        this.stopHeartbeat();
-                        this.clearReconnectTimeout();
-                        this.removeVisibilityChangeHandler();
-                        this.reconnectAttempts = 0;
-                        if (this.ws) {
-                            // Prevent onclose from triggering reconnect
-                            this.ws.onclose = null;
-                            // Send unsubscribe before closing
-                            if (this.ws.readyState === WebSocket.OPEN) {
-                                try {
-                                    this.ws.send(JSON.stringify({
-                                        type: "unsubscribe_market",
-                                        marketId: this.config.marketId
-                                    }));
-                                } catch (unused) {}
-                            }
-                            // Ignore send errors during disconnect
-                            this.ws.close();
-                            this.ws = null;
+                        switch(_state.label){
+                            case 0:
+                                if (!this.shouldBeConnected) return [
+                                    2
+                                ];
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    3,
+                                    ,
+                                    4
+                                ]);
+                                // Clear snapshot state — will be re-populated from fresh snapshots
+                                this.tokenStates.clear();
+                                this.frameQueues.clear();
+                                this.processingMarkets.clear();
+                                return [
+                                    4,
+                                    this.connect()
+                                ];
+                            case 2:
+                                _state.sent();
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 3:
+                                error = _state.sent();
+                                console.error("[MarketDepthSyncClient] reconnection failed:", error);
+                                return [
+                                    3,
+                                    4
+                                ];
+                            case 4:
+                                return [
+                                    2
+                                ];
                         }
-                        this.frameQueue = [];
-                        this.tokenStates.clear();
-                        this.setStatus("disconnected");
-                        return [
-                            2
-                        ];
                     });
                 }).call(this);
             }