@structbuild/sdk 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -36,6 +36,7 @@ __export(exports_src, {
   StructWebSocket: () => StructWebSocket,
   StructError: () => StructError,
   StructClient: () => StructClient,
+  StructAlertsWebSocket: () => StructAlertsWebSocket,
   NetworkError: () => NetworkError,
   HttpError: () => HttpError,
   HttpClient: () => HttpClient
@@ -389,11 +390,13 @@ class MarketsNamespace extends Namespace {
   }
   async getMarket(params, venue) {
     const { conditionId, ...query } = params;
-    return this.get(venue, `/market/${encodeURIComponent(conditionId)}`, { params: { ...query } });
+    const res = await this.get(venue, `/market/${encodeURIComponent(conditionId)}`, { params: { ...query } });
+    return { ...res, data: res.data[0] };
   }
   async getMarketBySlug(params, venue) {
     const { marketSlug, ...query } = params;
-    return this.get(venue, `/market/slug/${encodeURIComponent(marketSlug)}`, { params: { ...query } });
+    const res = await this.get(venue, `/market/slug/${encodeURIComponent(marketSlug)}`, { params: { ...query } });
+    return { ...res, data: res.data[0] };
   }
   async getMarketChart(params, venue) {
     return this.get(venue, "/market/chart", { params: { ...params } });
@@ -431,6 +434,10 @@ class SeriesNamespace extends Namespace {
   async getSeriesOutcomes(params, venue) {
     return this.get(venue, "/series/outcomes", { params: { ...params } });
   }
+  async getSeriesEvents(params, venue) {
+    const { identifier, ...query } = params;
+    return this.get(venue, `/series/${encodeURIComponent(identifier)}/events`, { params: { ...query } });
+  }
 }
 // src/namespaces/trader.ts
 class TraderNamespace extends Namespace {
@@ -581,6 +588,32 @@ class StructClient {
 // src/ws-transport.ts
 var DEFAULT_INITIAL_DELAY_MS2 = 1000;
 var DEFAULT_MAX_DELAY_MS2 = 30000;
+var DEFAULT_MAX_PENDING_MESSAGES = 256;
+var AUTH_FAILURE_CLOSE_CODES = new Set([1008, 4401]);
+function buildWebSocketUrl(path, config, defaultBaseUrl) {
+  const base = trimTrailingSlashes(config.baseUrl ?? defaultBaseUrl);
+  const wsBase = toWebSocketBaseUrl(base);
+  const params = new URLSearchParams({ "api-key": config.apiKey });
+  if (config.jwt)
+    params.set("token", config.jwt);
+  return `${wsBase}${path}?${params.toString()}`;
+}
+function trimTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function toWebSocketBaseUrl(baseUrl) {
+  if (baseUrl.startsWith("https://")) {
+    return `wss://${baseUrl.slice("https://".length)}`;
+  }
+  if (baseUrl.startsWith("http://")) {
+    return `ws://${baseUrl.slice("http://".length)}`;
+  }
+  return baseUrl;
+}
 
 class WebSocketTransport {
   ws = null;
@@ -588,13 +621,14 @@ class WebSocketTransport {
   reconnectTimer = null;
   reconnectAttempt = 0;
   intentionalClose = false;
+  connectWaiters = new Set;
   pendingMessages = [];
   replayMessages = [];
-  url;
+  getUrl;
   retry;
   callbacks;
   constructor(url, retry, callbacks) {
-    this.url = url;
+    this.getUrl = typeof url === "function" ? url : () => url;
     this.retry = retry;
     this.callbacks = callbacks;
   }
@@ -602,22 +636,24 @@ class WebSocketTransport {
     return this._state;
   }
   connect() {
-    if (this._state === "connected" || this._state === "connecting" || this._state === "reconnecting") {
-      return;
-    }
-    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
-      return;
+    if (this._state === "connected")
+      return Promise.resolve();
+    const promise = this.createConnectPromise();
+    if (this._state === "connecting" || this._state === "reconnecting") {
+      return promise;
     }
     this.intentionalClose = false;
     this.clearReconnectTimer();
     this.setState("connecting");
     this.createSocket();
+    return promise;
   }
   disconnect() {
     this.intentionalClose = true;
     this.clearReconnectTimer();
     this.pendingMessages.length = 0;
     this.replayMessages.length = 0;
+    this.rejectConnect(new WebSocketClosedError(1000, "client disconnect"));
     if (this.ws) {
       this.ws.close(1000, "client disconnect");
       this.ws = null;
@@ -625,30 +661,50 @@ class WebSocketTransport {
     this.setState("disconnected");
   }
   send(message) {
-    if (this._state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(message));
-    } else {
-      this.pendingMessages.push(message);
-    }
+    const queuedMessage = { message };
+    if (this.sendMessage(queuedMessage))
+      return true;
+    this.enqueueMessage(this.pendingMessages, queuedMessage, "pending");
+    return false;
+  }
+  sendNow(message) {
+    return this.sendMessage({ message });
   }
   addReplayMessage(message) {
-    this.replayMessages.push(message);
+    this.addReplayMessages([message]);
   }
-  removeReplayMessages(predicate) {
-    for (let i = this.replayMessages.length - 1;i >= 0; i--) {
-      if (predicate(this.replayMessages[i])) {
-        this.replayMessages.splice(i, 1);
-      }
-    }
+  addReplayMessages(messages) {
+    this.enqueueReplayMessages(messages.map((message) => ({ message })));
   }
   clearReplayMessages() {
     this.replayMessages.length = 0;
   }
+  close(code, reason) {
+    this.ws?.close(code, reason);
+  }
+  createConnectPromise() {
+    return new Promise((resolve, reject) => {
+      this.connectWaiters.add({ resolve, reject });
+    });
+  }
+  resolveConnect() {
+    for (const waiter of this.connectWaiters) {
+      waiter.resolve();
+    }
+    this.connectWaiters.clear();
+  }
+  rejectConnect(error) {
+    for (const waiter of this.connectWaiters) {
+      waiter.reject(error);
+    }
+    this.connectWaiters.clear();
+  }
   createSocket() {
     try {
-      this.ws = new WebSocket(this.url);
+      this.ws = new WebSocket(this.getUrl());
     } catch (err) {
-      this.callbacks.onError(new WebSocketError("Failed to create WebSocket", { cause: err }));
+      const error = new WebSocketError("Failed to create WebSocket", { cause: err });
+      this.callbacks.onError(error);
       this.scheduleReconnect();
       return;
     }
@@ -657,6 +713,7 @@ class WebSocketTransport {
       this.reconnectAttempt = 0;
       this.replaySubscriptions();
       this.flushPendingMessages();
+      this.resolveConnect();
       this.callbacks.onOpen();
     };
     this.ws.onclose = (event) => {
@@ -666,7 +723,14 @@ class WebSocketTransport {
         this.callbacks.onClose(event.code, event.reason);
         return;
       }
+      const error = new WebSocketClosedError(event.code, event.reason);
       this.callbacks.onClose(event.code, event.reason);
+      if (this.isAuthFailure(event.code)) {
+        this.setState("disconnected");
+        this.rejectConnect(error);
+        this.callbacks.onAuthFailed(error);
+        return;
+      }
       this.scheduleReconnect();
     };
     this.ws.onerror = () => {
@@ -682,25 +746,24 @@ class WebSocketTransport {
     };
   }
   replaySubscriptions() {
-    for (const msg of this.replayMessages) {
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(JSON.stringify(msg));
+    for (const replayGroup of this.replayMessages) {
+      for (const queuedMessage of replayGroup.messages) {
+        this.sendMessage(queuedMessage);
       }
     }
   }
   flushPendingMessages() {
     while (this.pendingMessages.length > 0) {
-      const msg = this.pendingMessages.shift();
-      if (this.ws?.readyState === WebSocket.OPEN) {
-        this.ws.send(JSON.stringify(msg));
-      }
+      this.sendMessage(this.pendingMessages.shift());
     }
   }
   scheduleReconnect() {
     const maxRetries = this.retry.maxRetries ?? Infinity;
     if (this.reconnectAttempt >= maxRetries) {
+      const error = new WebSocketClosedError(1006, "Max reconnection attempts reached");
       this.setState("disconnected");
-      this.callbacks.onError(new WebSocketClosedError(1006, "Max reconnection attempts reached"));
+      this.rejectConnect(error);
+      this.callbacks.onReconnectFailed(error);
       return;
     }
     this.setState("reconnecting");
@@ -722,46 +785,82 @@ class WebSocketTransport {
       this.reconnectTimer = null;
     }
   }
+  sendMessage(queuedMessage) {
+    if (this.ws?.readyState !== WebSocket.OPEN)
+      return false;
+    this.ws.send(JSON.stringify(queuedMessage.message));
+    return true;
+  }
+  enqueueMessage(queue, queuedMessage, queueName) {
+    queue.push(queuedMessage);
+    const maxPendingMessages = this.retry.maxPendingMessages ?? DEFAULT_MAX_PENDING_MESSAGES;
+    if (queue.length > maxPendingMessages) {
+      queue.shift();
+      this.callbacks.onWarning(new WebSocketError(`WebSocket ${queueName} queue exceeded ${maxPendingMessages} messages; dropped oldest message`));
+    }
+  }
+  enqueueReplayMessages(messages) {
+    this.replayMessages.push({ messages });
+    const maxPendingMessages = this.retry.maxPendingMessages ?? DEFAULT_MAX_PENDING_MESSAGES;
+    if (this.replayMessages.length > maxPendingMessages) {
+      this.replayMessages.shift();
+      this.callbacks.onWarning(new WebSocketError(`WebSocket replay queue exceeded ${maxPendingMessages} entries; dropped oldest replay entry`));
+    }
+  }
+  isAuthFailure(code) {
+    return AUTH_FAILURE_CLOSE_CODES.has(code);
+  }
   setState(state) {
     this._state = state;
   }
 }
 
 // src/ws.ts
-var DEFAULT_BASE_URL2 = "https://api.struct.to/v1";
+var DEFAULT_BASE_URL2 = "wss://api.struct.to";
+var PING_INTERVAL_MS = 30000;
+var DEFAULT_SUBSCRIBE_TIMEOUT_MS = 1e4;
 
 class StructWebSocket {
   transport;
   listeners = new Map;
-  activeMarkets = new Set;
-  activeMarketPositions = new Set;
-  activeWallets = new Set;
-  activeConditions = new Set;
-  activeSpecialRooms = new Set;
+  subscriptions = new Map;
+  pendingSubscribes = new Map;
+  subscribeTimeout;
+  pingTimer = null;
+  pongTimer = null;
+  isEmittingListenerError = false;
   constructor(config) {
-    const httpBase = (config.baseUrl ?? DEFAULT_BASE_URL2).replace(/\/+$/, "");
-    const wsBase = httpBase.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
-    const url = config.jwt ? `${wsBase}?api-key=${encodeURIComponent(config.apiKey)}&token=${encodeURIComponent(config.jwt)}` : `${wsBase}?token=${encodeURIComponent(config.apiKey)}`;
-    this.transport = new WebSocketTransport(url, config.reconnect ?? {}, {
+    this.subscribeTimeout = config.subscribeTimeout ?? DEFAULT_SUBSCRIBE_TIMEOUT_MS;
+    const getUrl = () => buildWebSocketUrl("/ws", {
+      apiKey: config.apiKey,
+      jwt: config.getJwt?.() ?? config.jwt,
+      baseUrl: config.baseUrl
+    }, DEFAULT_BASE_URL2);
+    this.transport = new WebSocketTransport(getUrl, config.reconnect ?? {}, {
       onOpen: () => this.handleOpen(),
       onClose: (code, reason) => this.handleClose(code, reason),
       onError: (error) => this.emit("error", error),
       onMessage: (data) => this.handleMessage(data),
-      onReconnecting: (attempt) => this.emit("reconnecting", { attempt })
+      onReconnecting: (attempt) => this.emit("reconnecting", { attempt }),
+      onReconnectFailed: (error) => this.emit("reconnect_failed", error),
+      onAuthFailed: (error) => this.emit("auth_failed", error),
+      onWarning: (warning) => this.emit("warning", warning)
     });
   }
   get state() {
     return this.transport.state;
   }
   connect() {
-    this.transport.connect();
+    return this.transport.connect();
   }
   disconnect() {
-    this.activeMarkets.clear();
-    this.activeMarketPositions.clear();
-    this.activeWallets.clear();
-    this.activeConditions.clear();
-    this.activeSpecialRooms.clear();
+    this.stopPing();
+    for (const [, pending] of this.pendingSubscribes) {
+      this.clearSubscribeTimer(pending);
+      pending.reject(new WebSocketError("Disconnected"));
+    }
+    this.pendingSubscribes.clear();
+    this.subscriptions.clear();
     this.transport.disconnect();
   }
   on(event, listener) {
@@ -771,11 +870,12 @@ class StructWebSocket {
       this.listeners.set(event, set);
     }
     set.add(listener);
-    return this;
+    return () => {
+      set.delete(listener);
+    };
   }
   off(event, listener) {
     this.listeners.get(event)?.delete(listener);
-    return this;
   }
   once(event, listener) {
     const wrapper = (payload) => {
@@ -784,132 +884,374 @@ class StructWebSocket {
     };
     return this.on(event, wrapper);
   }
-  subscribeMarket(conditionId) {
-    if (this.activeMarkets.has(conditionId))
-      return;
-    this.activeMarkets.add(conditionId);
-    const msg = this.marketSubscribeMessage(conditionId);
-    this.transport.addReplayMessage(msg);
-    this.transport.send(msg);
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
   }
-  unsubscribeMarket(conditionId) {
-    if (!this.activeMarkets.has(conditionId))
-      return;
-    this.activeMarkets.delete(conditionId);
-    const msg = {
-      type: "unsubscribe_market",
-      room_id: `market_${conditionId}`,
-      message: {}
-    };
-    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === `market_${conditionId}`);
-    this.transport.send(msg);
+  subscribe(room, filters) {
+    const resolvedFilters = filters ?? {};
+    const isNewRoom = !this.subscriptions.has(room);
+    const existing = this.pendingSubscribes.get(room);
+    if (existing) {
+      this.clearSubscribeTimer(existing);
+      existing.reject(new WebSocketError("Superseded by new subscription"));
+    }
+    this.subscriptions.set(room, resolvedFilters);
+    this.rebuildReplay();
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        timer: null
+      };
+      this.pendingSubscribes.set(room, pending);
+      if (this.sendSubscription(room, resolvedFilters, isNewRoom)) {
+        this.armSubscribeTimer(room, pending);
+      }
+    });
   }
-  subscribeMarketByPosition(positionId) {
-    if (this.activeMarketPositions.has(positionId))
+  unsubscribe(room) {
+    if (!this.subscriptions.has(room))
       return;
-    this.activeMarketPositions.add(positionId);
-    const msg = this.marketPositionSubscribeMessage(positionId);
-    this.transport.addReplayMessage(msg);
-    this.transport.send(msg);
+    const pending = this.pendingSubscribes.get(room);
+    if (pending) {
+      this.clearSubscribeTimer(pending);
+      pending.reject(new WebSocketError("Unsubscribed"));
+      this.pendingSubscribes.delete(room);
+    }
+    this.subscriptions.delete(room);
+    this.rebuildReplay();
+    if (this.state === "connected") {
+      this.transport.sendNow({
+        type: "room_message",
+        payload: { room_id: room, message: { action: "unsubscribe_all" } }
+      });
+      this.transport.sendNow({ type: "leave_room", payload: { room_id: room } });
+    }
   }
-  unsubscribeMarketByPosition(positionId) {
-    if (!this.activeMarketPositions.has(positionId))
-      return;
-    this.activeMarketPositions.delete(positionId);
-    const msg = {
-      type: "unsubscribe_market",
-      room_id: `market_position_${positionId}`,
-      message: {}
-    };
-    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === `market_position_${positionId}`);
-    this.transport.send(msg);
+  rebuildReplay() {
+    this.transport.clearReplayMessages();
+    for (const [roomId, filters] of this.subscriptions) {
+      this.transport.addReplayMessages([
+        { type: "join_room", payload: { room_id: roomId } },
+        {
+          type: "room_message",
+          payload: { room_id: roomId, message: { action: "subscribe", ...filters } }
+        }
+      ]);
+    }
   }
-  trackWallets(addresses) {
-    const uniqueAddresses = [...new Set(addresses)];
-    const added = uniqueAddresses.filter((addr) => !this.activeWallets.has(addr));
-    if (added.length === 0)
+  handleOpen() {
+    this.startPing();
+    this.restartPendingSubscribes();
+    this.emit("connected", undefined);
+  }
+  handleClose(code, reason) {
+    this.stopPing();
+    this.pausePendingSubscribes();
+    this.emit("disconnected", { code, reason });
+  }
+  handleMessage(raw) {
+    const msg = raw;
+    if (!msg || typeof msg !== "object" || !msg.type)
+      return;
+    if (msg.type === "pong") {
+      this.clearPongTimer();
       return;
-    for (const addr of added)
-      this.activeWallets.add(addr);
-    const msg = this.walletTrackMessage("subscribe", added);
-    this.rebuildWalletReplay();
-    this.transport.send(msg);
-  }
-  untrackWallets(addresses) {
-    const uniqueAddresses = [...new Set(addresses)];
-    const removed = uniqueAddresses.filter((addr) => this.activeWallets.has(addr));
-    if (removed.length === 0)
+    }
+    if (this.isSubscribeResponseMessage(msg)) {
+      const pending = this.pendingSubscribes.get(msg.room_id);
+      if (pending) {
+        this.clearSubscribeTimer(pending);
+        this.pendingSubscribes.delete(msg.room_id);
+        const subscribeError = this.getSubscribeError(msg.data);
+        if (subscribeError) {
+          const error = new WebSocketError(subscribeError);
+          pending.reject(error);
+          this.emit("error", error);
+        } else {
+          pending.resolve(msg.data);
+        }
+      }
       return;
-    for (const addr of removed)
-      this.activeWallets.delete(addr);
-    const msg = this.walletTrackMessage("unsubscribe", removed);
-    this.rebuildWalletReplay();
-    this.transport.send(msg);
+    }
+    this.emit(msg.type, msg.data);
   }
-  subscribeWhaleTrades() {
-    this.subscribeSpecialRoom("whale_trades");
+  isSubscribeResponseMessage(msg) {
+    if (!msg.type || !msg.room_id)
+      return false;
+    return msg.type === "subscribed" || msg.type.endsWith("_subscribe_response");
   }
-  unsubscribeWhaleTrades() {
-    this.unsubscribeSpecialRoom("whale_trades");
+  emit(event, payload) {
+    const set = this.listeners.get(event);
+    if (!set)
+      return;
+    for (const fn of set) {
+      try {
+        fn(payload);
+      } catch (error) {
+        this.handleListenerError(error);
+      }
+    }
   }
-  subscribeSmartMoneyTrades() {
-    this.subscribeSpecialRoom("smart_money_trades");
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      if (this.transport.sendNow({ type: "ping" })) {
+        this.armPongTimer();
+      }
+    }, PING_INTERVAL_MS);
   }
-  unsubscribeSmartMoneyTrades() {
-    this.unsubscribeSpecialRoom("smart_money_trades");
+  stopPing() {
+    if (this.pingTimer !== null) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.clearPongTimer();
+  }
+  sendSubscription(room, filters, joinRoom) {
+    if (this.state !== "connected")
+      return false;
+    let sent = true;
+    if (joinRoom) {
+      sent = this.transport.sendNow({ type: "join_room", payload: { room_id: room } }) && sent;
+    }
+    sent = this.transport.sendNow({
+      type: "room_message",
+      payload: { room_id: room, message: { action: "subscribe", ...filters } }
+    }) && sent;
+    return sent;
+  }
+  restartPendingSubscribes() {
+    for (const [room, pending] of this.pendingSubscribes) {
+      if (pending.timer === null) {
+        this.armSubscribeTimer(room, pending);
+      }
+    }
   }
-  subscribeInsiderTrades() {
-    this.subscribeSpecialRoom("insider_trades");
+  pausePendingSubscribes() {
+    for (const [, pending] of this.pendingSubscribes) {
+      this.clearSubscribeTimer(pending);
+    }
   }
-  unsubscribeInsiderTrades() {
-    this.unsubscribeSpecialRoom("insider_trades");
+  armSubscribeTimer(room, pending) {
+    this.clearSubscribeTimer(pending);
+    pending.timer = setTimeout(() => {
+      pending.timer = null;
+      this.pendingSubscribes.delete(room);
+      pending.reject(new WebSocketError(`Subscribe to ${room} timed out`));
+    }, this.subscribeTimeout);
+  }
+  clearSubscribeTimer(pending) {
+    if (pending.timer !== null) {
+      clearTimeout(pending.timer);
+      pending.timer = null;
+    }
   }
-  trackConditions(conditionIds) {
-    const uniqueConditionIds = [...new Set(conditionIds)];
-    const added = uniqueConditionIds.filter((id) => !this.activeConditions.has(id));
-    if (added.length === 0)
+  armPongTimer() {
+    if (this.pongTimer !== null)
       return;
-    for (const id of added)
-      this.activeConditions.add(id);
-    const msg = this.conditionsTrackMessage("subscribe", added);
-    this.rebuildConditionsReplay();
-    this.transport.send(msg);
-  }
-  untrackConditions(conditionIds) {
-    const uniqueConditionIds = [...new Set(conditionIds)];
-    const removed = uniqueConditionIds.filter((id) => this.activeConditions.has(id));
-    if (removed.length === 0)
+    this.pongTimer = setTimeout(() => {
+      this.pongTimer = null;
+      this.transport.close(4000, "pong timeout");
+    }, PING_INTERVAL_MS * 2);
+  }
+  clearPongTimer() {
+    if (this.pongTimer !== null) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
+    }
+  }
+  getSubscribeError(data) {
+    if (!data || typeof data !== "object")
+      return null;
+    const error = data.error;
+    return typeof error === "string" && error.length > 0 ? error : null;
+  }
+  handleListenerError(error) {
+    const normalizedError = error instanceof Error ? error : new WebSocketError("WebSocket listener threw", { cause: error });
+    if (!this.isEmittingListenerError && (this.listeners.get("error")?.size ?? 0) > 0) {
+      this.isEmittingListenerError = true;
+      try {
+        this.emit("error", normalizedError);
+        return;
+      } finally {
+        this.isEmittingListenerError = false;
+      }
+    }
+    console.error(normalizedError);
+  }
+}
+// src/ws-alerts.ts
+var DEFAULT_BASE_URL3 = "wss://api.struct.to";
+var PING_INTERVAL_MS2 = 30000;
+var DEFAULT_SUBSCRIBE_TIMEOUT_MS2 = 1e4;
+
+class StructAlertsWebSocket {
+  transport;
+  listeners = new Map;
+  subscriptions = new Map;
+  pendingSubscribes = new Map;
+  subscribeTimeout;
+  pingTimer = null;
+  pongTimer = null;
+  isEmittingListenerError = false;
+  constructor(config) {
+    this.subscribeTimeout = config.subscribeTimeout ?? DEFAULT_SUBSCRIBE_TIMEOUT_MS2;
+    const getUrl = () => buildWebSocketUrl("/ws/alerts", {
+      apiKey: config.apiKey,
+      jwt: config.getJwt?.() ?? config.jwt,
+      baseUrl: config.baseUrl
+    }, DEFAULT_BASE_URL3);
+    this.transport = new WebSocketTransport(getUrl, config.reconnect ?? {}, {
+      onOpen: () => this.handleOpen(),
+      onClose: (code, reason) => this.handleClose(code, reason),
+      onError: (error) => this.emit("error", error),
+      onMessage: (data) => this.handleMessage(data),
+      onReconnecting: (attempt) => this.emit("reconnecting", { attempt }),
+      onReconnectFailed: (error) => this.emit("reconnect_failed", error),
+      onAuthFailed: (error) => this.emit("auth_failed", error),
+      onWarning: (warning) => this.emit("warning", warning)
+    });
+  }
+  get state() {
+    return this.transport.state;
+  }
+  connect() {
+    return this.transport.connect();
+  }
+  disconnect() {
+    this.stopPing();
+    for (const [, pending] of this.pendingSubscribes) {
+      this.clearSubscribeTimer(pending);
+      pending.reject(new WebSocketError("Disconnected"));
+    }
+    this.pendingSubscribes.clear();
+    this.subscriptions.clear();
+    this.transport.disconnect();
+  }
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+  }
+  once(event, listener) {
+    const wrapper = (payload) => {
+      this.off(event, wrapper);
+      listener(payload);
+    };
+    return this.on(event, wrapper);
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  subscribe(event, filters) {
+    const message = { op: "subscribe", event, ...filters };
+    const existing = this.pendingSubscribes.get(event);
+    if (existing) {
+      this.clearSubscribeTimer(existing);
+      existing.reject(new WebSocketError("Superseded by new subscription"));
+    }
+    this.subscriptions.set(event, message);
+    this.rebuildReplay();
+    return new Promise((resolve, reject) => {
+      const pending = {
+        resolve,
+        reject,
+        timer: null
+      };
+      this.pendingSubscribes.set(event, pending);
+      if (this.sendSubscription(message)) {
+        this.armSubscribeTimer(event, pending);
+      }
+    });
+  }
+  unsubscribe(event) {
+    const sub = this.subscriptions.get(event);
+    if (!sub)
       return;
-    for (const id of removed)
-      this.activeConditions.delete(id);
-    const msg = this.conditionsTrackMessage("unsubscribe", removed);
-    this.rebuildConditionsReplay();
-    this.transport.send(msg);
+    const pending = this.pendingSubscribes.get(event);
+    if (pending) {
+      this.clearSubscribeTimer(pending);
+      pending.reject(new WebSocketError("Unsubscribed"));
+      this.pendingSubscribes.delete(event);
+    }
+    this.subscriptions.delete(event);
+    this.rebuildReplay();
+    if (this.state === "connected") {
+      this.transport.sendNow({ ...sub, op: "unsubscribe" });
+    }
+  }
+  rebuildReplay() {
+    this.transport.clearReplayMessages();
+    for (const [, message] of this.subscriptions) {
+      this.transport.addReplayMessage(message);
+    }
   }
   handleOpen() {
+    this.startPing();
+    this.restartPendingSubscribes();
     this.emit("connected", undefined);
   }
   handleClose(code, reason) {
+    this.stopPing();
+    this.pausePendingSubscribes();
     this.emit("disconnected", { code, reason });
   }
   handleMessage(raw) {
     const msg = raw;
     if (!msg || typeof msg !== "object")
       return;
-    const roomId = msg.room_id ?? "";
-    const type = msg.type;
-    if (type === "market_trade" || roomId.startsWith("market_")) {
-      this.emit("market_trade", msg.data);
-    } else if (type === "whale_trade" || roomId === "whale_trades") {
-      this.emit("whale_trade", msg.data);
-    } else if (type === "smart_money_trade" || roomId === "smart_money_trades") {
-      this.emit("smart_money_trade", msg.data);
-    } else if (type === "insider_trade" || roomId === "insider_trades") {
-      this.emit("insider_trade", msg.data);
-    } else if (type === "wallet_tracking_alert") {
-      this.emit("wallet_tracking_alert", msg.data);
-    } else if (type === "conditions_tracking_alert") {
-      this.emit("conditions_tracking_alert", msg.data);
+    if (msg.op === "pong" || msg.type === "pong") {
+      this.clearPongTimer();
+      return;
+    }
+    if (msg.error) {
+      const error = new WebSocketError(msg.error);
+      if (msg.event) {
+        const pending = this.pendingSubscribes.get(msg.event);
+        if (pending) {
+          this.clearSubscribeTimer(pending);
+          this.pendingSubscribes.delete(msg.event);
+          pending.reject(error);
+        }
+      }
+      this.emit("error", error);
+      return;
+    }
+    if (msg.op === "subscribed" && msg.event) {
+      const pending = this.pendingSubscribes.get(msg.event);
+      if (pending) {
+        this.clearSubscribeTimer(pending);
+        this.pendingSubscribes.delete(msg.event);
+        pending.resolve({ op: "subscribed", event: msg.event, subscription_id: msg.subscription_id });
+      }
+      return;
+    }
+    if (msg.op === "unsubscribed")
+      return;
+    if (msg.event && msg.data !== undefined) {
+      this.emit(msg.event, {
+        event: msg.event,
+        timestamp: msg.timestamp,
+        data: msg.data
+      });
     }
   }
   emit(event, payload) {
@@ -919,48 +1261,83 @@ class StructWebSocket {
     for (const fn of set) {
       try {
         fn(payload);
-      } catch {}
+      } catch (error) {
+        this.handleListenerError(error);
+      }
     }
   }
-  marketSubscribeMessage(conditionId) {
-    return { type: "subscribe_market", room_id: `market_${conditionId}`, message: {} };
+  startPing() {
+    this.stopPing();
+    this.pingTimer = setInterval(() => {
+      if (this.transport.sendNow({ type: "ping" })) {
+        this.armPongTimer();
+      }
+    }, PING_INTERVAL_MS2);
+  }
+  stopPing() {
+    if (this.pingTimer !== null) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+    this.clearPongTimer();
   }
-  marketPositionSubscribeMessage(positionId) {
-    return { type: "subscribe_market", room_id: `market_position_${positionId}`, message: {} };
+  sendSubscription(message) {
+    if (this.state !== "connected")
+      return false;
+    return this.transport.sendNow(message);
   }
-  walletTrackMessage(action, addresses) {
-    return { type: "wallet_tracking", action, wallet_addresses: addresses };
+  restartPendingSubscribes() {
+    for (const [event, pending] of this.pendingSubscribes) {
+      if (pending.timer === null) {
+        this.armSubscribeTimer(event, pending);
+      }
+    }
   }
-  conditionsTrackMessage(action, conditionIds) {
-    return { type: "conditions_tracking", action, condition_ids: conditionIds };
+  pausePendingSubscribes() {
+    for (const [, pending] of this.pendingSubscribes) {
+      this.clearSubscribeTimer(pending);
+    }
   }
-  subscribeSpecialRoom(roomId) {
-    if (this.activeSpecialRooms.has(roomId))
-      return;
-    this.activeSpecialRooms.add(roomId);
-    const msg = { type: "subscribe_market", room_id: roomId, message: {} };
-    this.transport.addReplayMessage(msg);
-    this.transport.send(msg);
+  armSubscribeTimer(event, pending) {
+    this.clearSubscribeTimer(pending);
+    pending.timer = setTimeout(() => {
+      pending.timer = null;
+      this.pendingSubscribes.delete(event);
+      pending.reject(new WebSocketError(`Subscribe to alert ${event} timed out`));
+    }, this.subscribeTimeout);
+  }
+  clearSubscribeTimer(pending) {
+    if (pending.timer !== null) {
+      clearTimeout(pending.timer);
+      pending.timer = null;
+    }
   }
-  unsubscribeSpecialRoom(roomId) {
-    if (!this.activeSpecialRooms.has(roomId))
+  armPongTimer() {
+    if (this.pongTimer !== null)
       return;
-    this.activeSpecialRooms.delete(roomId);
-    const msg = { type: "unsubscribe_market", room_id: roomId, message: {} };
-    this.transport.removeReplayMessages((m) => m.type === "subscribe_market" && m.room_id === roomId);
-    this.transport.send(msg);
-  }
-  rebuildWalletReplay() {
-    this.transport.removeReplayMessages((m) => m.type === "wallet_tracking");
-    if (this.activeWallets.size > 0) {
-      this.transport.addReplayMessage(this.walletTrackMessage("subscribe", [...this.activeWallets]));
+    this.pongTimer = setTimeout(() => {
+      this.pongTimer = null;
+      this.transport.close(4000, "pong timeout");
+    }, PING_INTERVAL_MS2 * 2);
+  }
+  clearPongTimer() {
+    if (this.pongTimer !== null) {
+      clearTimeout(this.pongTimer);
+      this.pongTimer = null;
     }
   }
-  rebuildConditionsReplay() {
-    this.transport.removeReplayMessages((m) => m.type === "conditions_tracking");
-    if (this.activeConditions.size > 0) {
-      this.transport.addReplayMessage(this.conditionsTrackMessage("subscribe", [...this.activeConditions]));
+  handleListenerError(error) {
+    const normalizedError = error instanceof Error ? error : new WebSocketError("WebSocket listener threw", { cause: error });
+    if (!this.isEmittingListenerError && (this.listeners.get("error")?.size ?? 0) > 0) {
+      this.isEmittingListenerError = true;
+      try {
+        this.emit("error", normalizedError);
+        return;
+      } finally {
+        this.isEmittingListenerError = false;
+      }
     }
+    console.error(normalizedError);
   }
 }
 // src/paginate.ts
@@ -979,5 +1356,5 @@ async function* paginate(fetcher, params, pageSize = DEFAULT_PAGE_SIZE) {
   }
 }
 
-//# debugId=BC93A176E3C2ACA564756E2164756E21
+//# debugId=C22008EEB4E58D0B64756E2164756E21
 //# sourceMappingURL=index.js.map