@kadoa/node-sdk 0.23.0 → 0.24.2

package/dist/index.d.mts

@@ -385,13 +385,9 @@ type MonitoredFieldOperatorEnum = typeof MonitoredFieldOperatorEnum[keyof typeof
  */
 interface MonitoringConfig {
     /**
-     * Whether monitoring is enabled
+     * Fields to monitor (at least one required)
      */
-    'enabled': boolean;
-    /**
-     * Fields to monitor
-     */
-    'fields'?: Array<MonitoredField>;
+    'fields': Array<MonitoredField>;
     /**
      * Notification channels
      */
@@ -1182,10 +1178,38 @@ interface CreateCrawlerConfigRequestBlueprintInner {
 interface CreateCrawlerConfigRequestCrawlMethod {
     [key: string]: any;
     /**
-     * Crawler execution type (e.g. puppeteer, impit)
+     * Worker selection mode. \'auto\' (default) picks cheapest compatible worker, \'browser\' forces browser.
      */
-    'type': string;
+    'mode'?: CreateCrawlerConfigRequestCrawlMethodModeEnum;
+    /**
+     * Explicit Scrape V2 worker override. BrightData is blocked in crawler runtime.
+     */
+    'worker'?: CreateCrawlerConfigRequestCrawlMethodWorkerEnum;
+    /**
+     * Explicit proxy routing override for Scrape V2
+     */
+    'proxy'?: CreateCrawlerConfigRequestCrawlMethodProxyEnum;
 }
+declare const CreateCrawlerConfigRequestCrawlMethodModeEnum: {
+    readonly Auto: "auto";
+    readonly Browser: "browser";
+};
+type CreateCrawlerConfigRequestCrawlMethodModeEnum = typeof CreateCrawlerConfigRequestCrawlMethodModeEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodModeEnum];
+declare const CreateCrawlerConfigRequestCrawlMethodWorkerEnum: {
+    readonly Auto: "auto";
+    readonly CurlCffi: "curl-cffi";
+    readonly Patchright: "patchright";
+    readonly Camoufox: "camoufox";
+    readonly Brightdata: "brightdata";
+};
+type CreateCrawlerConfigRequestCrawlMethodWorkerEnum = typeof CreateCrawlerConfigRequestCrawlMethodWorkerEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodWorkerEnum];
+declare const CreateCrawlerConfigRequestCrawlMethodProxyEnum: {
+    readonly Auto: "auto";
+    readonly Dc: "dc";
+    readonly Resi: "resi";
+    readonly Isp: "isp";
+};
+type CreateCrawlerConfigRequestCrawlMethodProxyEnum = typeof CreateCrawlerConfigRequestCrawlMethodProxyEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodProxyEnum];
 
 /**
  * Kadoa API
@@ -4137,6 +4161,10 @@ interface V4ChangesGet200ResponseChangesInner {
      * URL where the change was detected
      */
     'url'?: string;
+    /**
+     * AI-generated one-sentence summary of the data change. Null if generation failed, feature is disabled, or change predates the feature.
+     */
+    'summary'?: string | null;
     /**
      * URL of the screenshot taken when the change was detected
      */
@@ -5742,13 +5770,9 @@ type V4WorkflowsWorkflowIdMetadataPutRequestMonitoringFieldsInnerOperatorEnum =
  */
 
 /**
- * The new monitoring config for the workflow
+ * The monitoring config for the workflow
  */
 interface V4WorkflowsWorkflowIdMetadataPutRequestMonitoring {
-    /**
-     * Whether monitoring is enabled for the workflow
-     */
-    'enabled'?: boolean;
     'fields'?: Array<V4WorkflowsWorkflowIdMetadataPutRequestMonitoringFieldsInner>;
     'conditions'?: V4WorkflowsWorkflowIdMetadataPutRequestMonitoringConditions;
 }
@@ -10119,6 +10143,7 @@ interface RealtimeEvent {
     message: unknown;
     id?: string;
     timestamp: number;
+    _cursor?: string;
 }
 interface RealtimeConfig {
     apiKey: string;
@@ -10127,7 +10152,10 @@ interface RealtimeConfig {
     missedHeartbeatsLimit?: number;
 }
 declare class Realtime {
-    private socket?;
+    private static readonly DEFAULT_RECONNECT_DELAY_MS;
+    private static readonly MAX_RECONNECT_DELAY_MS;
+    private activeSocket?;
+    private drainingSockets;
     private heartbeatInterval;
     private reconnectDelay;
     private lastHeartbeat;
@@ -10138,8 +10166,26 @@ declare class Realtime {
     private eventListeners;
     private connectionListeners;
     private errorListeners;
+    private isClosed;
+    private lastCursor?;
+    private reconnectTimer?;
+    private hasConnectedOnce;
+    private readonly recentEventIds;
+    private readonly recentEventIdQueue;
+    private readonly maxRecentEventIds;
     constructor(config: RealtimeConfig);
     connect(): Promise<void>;
+    private getOAuthToken;
+    private openSocket;
+    private promoteSocket;
+    private handleSocketMessage;
+    private handleDrainSignal;
+    private handleSocketClose;
+    private handleUnexpectedDisconnect;
+    private scheduleReconnect;
+    private scheduleDrainReconnect;
+    private normalizeReconnectDelay;
+    private isDuplicateEvent;
     private handleHeartbeat;
     private notifyEventListeners;
     private notifyConnectionListeners;
@@ -10370,8 +10416,8 @@ declare class ApiRegistry {
 interface TeamInfo {
     id: string;
     name: string;
-    role: string;
     memberRole: string;
+    adminEmail: string | null;
 }
 interface BearerAuthOptions {
     bearerToken: string;

package/dist/index.d.ts

@@ -385,13 +385,9 @@ type MonitoredFieldOperatorEnum = typeof MonitoredFieldOperatorEnum[keyof typeof
  */
 interface MonitoringConfig {
     /**
-     * Whether monitoring is enabled
+     * Fields to monitor (at least one required)
      */
-    'enabled': boolean;
-    /**
-     * Fields to monitor
-     */
-    'fields'?: Array<MonitoredField>;
+    'fields': Array<MonitoredField>;
     /**
      * Notification channels
      */
@@ -1182,10 +1178,38 @@ interface CreateCrawlerConfigRequestBlueprintInner {
 interface CreateCrawlerConfigRequestCrawlMethod {
     [key: string]: any;
     /**
-     * Crawler execution type (e.g. puppeteer, impit)
+     * Worker selection mode. \'auto\' (default) picks cheapest compatible worker, \'browser\' forces browser.
      */
-    'type': string;
+    'mode'?: CreateCrawlerConfigRequestCrawlMethodModeEnum;
+    /**
+     * Explicit Scrape V2 worker override. BrightData is blocked in crawler runtime.
+     */
+    'worker'?: CreateCrawlerConfigRequestCrawlMethodWorkerEnum;
+    /**
+     * Explicit proxy routing override for Scrape V2
+     */
+    'proxy'?: CreateCrawlerConfigRequestCrawlMethodProxyEnum;
 }
+declare const CreateCrawlerConfigRequestCrawlMethodModeEnum: {
+    readonly Auto: "auto";
+    readonly Browser: "browser";
+};
+type CreateCrawlerConfigRequestCrawlMethodModeEnum = typeof CreateCrawlerConfigRequestCrawlMethodModeEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodModeEnum];
+declare const CreateCrawlerConfigRequestCrawlMethodWorkerEnum: {
+    readonly Auto: "auto";
+    readonly CurlCffi: "curl-cffi";
+    readonly Patchright: "patchright";
+    readonly Camoufox: "camoufox";
+    readonly Brightdata: "brightdata";
+};
+type CreateCrawlerConfigRequestCrawlMethodWorkerEnum = typeof CreateCrawlerConfigRequestCrawlMethodWorkerEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodWorkerEnum];
+declare const CreateCrawlerConfigRequestCrawlMethodProxyEnum: {
+    readonly Auto: "auto";
+    readonly Dc: "dc";
+    readonly Resi: "resi";
+    readonly Isp: "isp";
+};
+type CreateCrawlerConfigRequestCrawlMethodProxyEnum = typeof CreateCrawlerConfigRequestCrawlMethodProxyEnum[keyof typeof CreateCrawlerConfigRequestCrawlMethodProxyEnum];
 
 /**
  * Kadoa API
@@ -4137,6 +4161,10 @@ interface V4ChangesGet200ResponseChangesInner {
      * URL where the change was detected
      */
     'url'?: string;
+    /**
+     * AI-generated one-sentence summary of the data change. Null if generation failed, feature is disabled, or change predates the feature.
+     */
+    'summary'?: string | null;
     /**
      * URL of the screenshot taken when the change was detected
      */
@@ -5742,13 +5770,9 @@ type V4WorkflowsWorkflowIdMetadataPutRequestMonitoringFieldsInnerOperatorEnum =
  */
 
 /**
- * The new monitoring config for the workflow
+ * The monitoring config for the workflow
  */
 interface V4WorkflowsWorkflowIdMetadataPutRequestMonitoring {
-    /**
-     * Whether monitoring is enabled for the workflow
-     */
-    'enabled'?: boolean;
     'fields'?: Array<V4WorkflowsWorkflowIdMetadataPutRequestMonitoringFieldsInner>;
     'conditions'?: V4WorkflowsWorkflowIdMetadataPutRequestMonitoringConditions;
 }
@@ -10119,6 +10143,7 @@ interface RealtimeEvent {
     message: unknown;
     id?: string;
     timestamp: number;
+    _cursor?: string;
 }
 interface RealtimeConfig {
     apiKey: string;
@@ -10127,7 +10152,10 @@ interface RealtimeConfig {
     missedHeartbeatsLimit?: number;
 }
 declare class Realtime {
-    private socket?;
+    private static readonly DEFAULT_RECONNECT_DELAY_MS;
+    private static readonly MAX_RECONNECT_DELAY_MS;
+    private activeSocket?;
+    private drainingSockets;
     private heartbeatInterval;
     private reconnectDelay;
     private lastHeartbeat;
@@ -10138,8 +10166,26 @@ declare class Realtime {
     private eventListeners;
     private connectionListeners;
     private errorListeners;
+    private isClosed;
+    private lastCursor?;
+    private reconnectTimer?;
+    private hasConnectedOnce;
+    private readonly recentEventIds;
+    private readonly recentEventIdQueue;
+    private readonly maxRecentEventIds;
     constructor(config: RealtimeConfig);
     connect(): Promise<void>;
+    private getOAuthToken;
+    private openSocket;
+    private promoteSocket;
+    private handleSocketMessage;
+    private handleDrainSignal;
+    private handleSocketClose;
+    private handleUnexpectedDisconnect;
+    private scheduleReconnect;
+    private scheduleDrainReconnect;
+    private normalizeReconnectDelay;
+    private isDuplicateEvent;
     private handleHeartbeat;
     private notifyEventListeners;
     private notifyConnectionListeners;
@@ -10370,8 +10416,8 @@ declare class ApiRegistry {
 interface TeamInfo {
     id: string;
     name: string;
-    role: string;
     memberRole: string;
+    adminEmail: string | null;
 }
 interface BearerAuthOptions {
     bearerToken: string;

package/dist/index.js

@@ -6043,7 +6043,7 @@ var NotificationSetupService = class {
           (s) => s.eventType === eventType
         );
         if (existing?.id) {
-          const existingChannelIds = (existing.channels || []).map((c) => c.id).filter(Boolean);
+          const existingChannelIds = (existing.channels || []).map((channel) => channel.id).filter(Boolean);
           const mergedChannelIds = [
             .../* @__PURE__ */ new Set([...existingChannelIds, ...channelIds])
           ];
@@ -6209,7 +6209,7 @@ process.env.KADOA_WSS_NEO_API_URI ?? "wss://events.kadoa.com/events/ws";
 var REALTIME_API_URI = process.env.KADOA_REALTIME_API_URI ?? "https://realtime.kadoa.com";
 
 // src/version.ts
-var SDK_VERSION = "0.23.0";
+var SDK_VERSION = "0.24.2";
 var SDK_NAME = "kadoa-node-sdk";
 var SDK_LANGUAGE = "node";
 
@@ -6218,89 +6218,256 @@ var debug5 = logger.wss;
 if (typeof WebSocket === "undefined") {
   global.WebSocket = __require("ws");
 }
-var Realtime = class {
+var isDrainControlMessage = (message) => message.type === "control.draining";
+var isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining";
+var _Realtime = class _Realtime {
   constructor(config) {
+    this.drainingSockets = /* @__PURE__ */ new Set();
     this.lastHeartbeat = Date.now();
     this.isConnecting = false;
     this.eventListeners = /* @__PURE__ */ new Set();
     this.connectionListeners = /* @__PURE__ */ new Set();
     this.errorListeners = /* @__PURE__ */ new Set();
+    this.isClosed = false;
+    this.hasConnectedOnce = false;
+    this.recentEventIds = /* @__PURE__ */ new Set();
+    this.recentEventIdQueue = [];
+    this.maxRecentEventIds = 1e3;
     this.apiKey = config.apiKey;
     this.heartbeatInterval = config.heartbeatInterval || 1e4;
-    this.reconnectDelay = config.reconnectDelay || 5e3;
+    this.reconnectDelay = this.normalizeReconnectDelay(config.reconnectDelay);
     this.missedHeartbeatsLimit = config.missedHeartbeatsLimit || 3e4;
   }
   async connect() {
-    if (this.isConnecting) return;
+    if (this.isClosed || this.isConnecting || this.activeSocket) {
+      return;
+    }
     this.isConnecting = true;
     try {
-      const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": `${this.apiKey}`,
-          "x-sdk-version": SDK_VERSION
+      const { access_token, team_id } = await this.getOAuthToken();
+      await this.openSocket(access_token, team_id, "active");
+      this.hasConnectedOnce = true;
+    } catch (err) {
+      debug5("Failed to connect: %O", err);
+      this.isConnecting = false;
+      this.notifyErrorListeners(err);
+      if (!this.hasConnectedOnce) {
+        throw err;
+      }
+      this.scheduleReconnect();
+    }
+  }
+  async getOAuthToken() {
+    const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": `${this.apiKey}`,
+        "x-sdk-version": SDK_VERSION
+      }
+    });
+    return await response.json();
+  }
+  async openSocket(accessToken, teamId, role) {
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket(
+        `${WSS_API_URI}?access_token=${accessToken}`
+      );
+      let settled = false;
+      socket.onopen = () => {
+        const subscribeMessage = {
+          action: "subscribe",
+          channel: teamId
+        };
+        if (this.lastCursor) {
+          subscribeMessage.lastCursor = this.lastCursor;
         }
-      });
-      const { access_token, team_id } = await response.json();
-      await new Promise((resolve, reject) => {
-        this.socket = new WebSocket(
-          `${WSS_API_URI}?access_token=${access_token}`
-        );
-        this.socket.onopen = () => {
-          this.isConnecting = false;
-          this.lastHeartbeat = Date.now();
-          if (this.socket?.readyState === WebSocket.OPEN) {
-            this.socket.send(
-              JSON.stringify({
-                action: "subscribe",
-                channel: team_id
-              })
-            );
-            debug5("Connected to WebSocket");
-            this.notifyConnectionListeners(true);
-          }
-          this.startHeartbeatCheck();
+        socket.send(JSON.stringify(subscribeMessage));
+        this.promoteSocket(socket, role);
+        this.isConnecting = false;
+        this.lastHeartbeat = Date.now();
+        this.startHeartbeatCheck();
+        debug5("Connected to WebSocket");
+        if (!settled) {
+          settled = true;
           resolve();
-        };
-        this.socket.onmessage = (event) => {
-          try {
-            const data = JSON.parse(event.data);
-            if (data.type === "heartbeat") {
-              this.handleHeartbeat();
-            } else {
-              if (data?.id) {
-                fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({ id: data.id })
-                });
-              }
-              this.notifyEventListeners(data);
-            }
-          } catch (err) {
-            debug5("Failed to parse incoming message: %O", err);
-          }
-        };
-        this.socket.onclose = () => {
-          debug5("WebSocket disconnected. Attempting to reconnect...");
-          this.isConnecting = false;
-          this.stopHeartbeatCheck();
-          this.notifyConnectionListeners(false, "Connection closed");
-          setTimeout(() => this.connect(), this.reconnectDelay);
-        };
-        this.socket.onerror = (error) => {
-          debug5("WebSocket error: %O", error);
-          this.isConnecting = false;
-          this.notifyErrorListeners(error);
+        }
+      };
+      socket.onmessage = (event) => {
+        this.handleSocketMessage(socket, event.data);
+      };
+      socket.onclose = () => {
+        this.handleSocketClose(socket);
+        if (!settled) {
+          settled = true;
+          reject(new Error("WebSocket closed before opening"));
+        }
+      };
+      socket.onerror = (error) => {
+        this.notifyErrorListeners(error);
+        if (!settled) {
+          settled = true;
           reject(error);
-        };
-      });
+          return;
+        }
+        if (socket === this.activeSocket) {
+          this.handleUnexpectedDisconnect("Socket error");
+        }
+      };
+    });
+  }
+  promoteSocket(socket, role) {
+    if (role === "replacement" && this.activeSocket && this.activeSocket !== socket) {
+      this.drainingSockets.add(this.activeSocket);
+    }
+    this.activeSocket = socket;
+    this.drainingSockets.delete(socket);
+    if (role === "active" || !this.hasConnectedOnce) {
+      this.notifyConnectionListeners(true);
+    }
+  }
+  handleSocketMessage(socket, rawData) {
+    try {
+      const payload = typeof rawData === "string" ? rawData : rawData.toString?.() ?? "";
+      const data = JSON.parse(payload);
+      if (data.type === "heartbeat") {
+        if (socket === this.activeSocket) {
+          this.handleHeartbeat();
+        }
+        return;
+      }
+      if (isDrainControlMessage(data)) {
+        this.handleDrainSignal(socket, data);
+        return;
+      }
+      if (!isRealtimeEvent(data)) {
+        return;
+      }
+      if (typeof data._cursor === "string") {
+        this.lastCursor = data._cursor;
+      }
+      if (typeof data.id === "string") {
+        fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id: data.id })
+        }).catch((error) => {
+          debug5("Failed to acknowledge event %s: %O", data.id, error);
+        });
+      }
+      if (this.isDuplicateEvent(data.id)) {
+        return;
+      }
+      this.notifyEventListeners(data);
     } catch (err) {
-      debug5("Failed to connect: %O", err);
-      this.isConnecting = false;
-      setTimeout(() => this.connect(), this.reconnectDelay);
+      debug5("Failed to parse incoming message: %O", err);
+    }
+  }
+  handleDrainSignal(socket, message) {
+    if (socket !== this.activeSocket || this.isClosed) {
+      return;
+    }
+    debug5("Received drain signal, preparing replacement socket");
+    this.drainingSockets.add(socket);
+    this.scheduleDrainReconnect(message.retryAfterMs);
+  }
+  handleSocketClose(socket) {
+    const wasActiveSocket = socket === this.activeSocket;
+    this.drainingSockets.delete(socket);
+    if (!wasActiveSocket) {
+      return;
+    }
+    this.activeSocket = void 0;
+    this.stopHeartbeatCheck();
+    if (this.isClosed) {
+      return;
+    }
+    if (this.drainingSockets.size > 0) {
+      debug5("Draining socket closed after replacement was scheduled");
+      return;
+    }
+    this.handleUnexpectedDisconnect("Connection closed");
+  }
+  handleUnexpectedDisconnect(reason) {
+    this.isConnecting = false;
+    this.notifyConnectionListeners(false, reason);
+    this.scheduleReconnect();
+  }
+  scheduleReconnect(replacement = false) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = void 0;
+      if (this.isClosed || this.isConnecting || !replacement && this.activeSocket) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(
+          access_token,
+          team_id,
+          replacement ? "replacement" : "active"
+        );
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(replacement);
+      }
+    }, this.reconnectDelay);
+  }
+  scheduleDrainReconnect(retryAfterMs) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
     }
+    let safeDelayMs = this.reconnectDelay;
+    if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 && retryAfterMs <= _Realtime.MAX_RECONNECT_DELAY_MS) {
+      safeDelayMs = Math.trunc(retryAfterMs);
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = void 0;
+      if (this.isClosed || this.isConnecting) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(access_token, team_id, "replacement");
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(true);
+      }
+    }, safeDelayMs);
+  }
+  normalizeReconnectDelay(delay) {
+    if (typeof delay !== "number" || !Number.isFinite(delay)) {
+      return _Realtime.DEFAULT_RECONNECT_DELAY_MS;
+    }
+    return Math.min(
+      Math.max(0, Math.trunc(delay)),
+      _Realtime.MAX_RECONNECT_DELAY_MS
+    );
+  }
+  isDuplicateEvent(eventId) {
+    if (!eventId) {
+      return false;
+    }
+    if (this.recentEventIds.has(eventId)) {
+      return true;
+    }
+    this.recentEventIds.add(eventId);
+    this.recentEventIdQueue.push(eventId);
+    if (this.recentEventIdQueue.length > this.maxRecentEventIds) {
+      const expiredId = this.recentEventIdQueue.shift();
+      if (expiredId) {
+        this.recentEventIds.delete(expiredId);
+      }
+    }
+    return false;
   }
   handleHeartbeat() {
     debug5("Heartbeat received");
@@ -6328,22 +6495,24 @@ var Realtime = class {
     this.errorListeners.forEach((listener) => {
       try {
         listener(error);
-      } catch (error2) {
-        debug5("Error in error listener: %O", error2);
+      } catch (listenerError) {
+        debug5("Error in error listener: %O", listenerError);
       }
     });
   }
   startHeartbeatCheck() {
+    this.stopHeartbeatCheck();
     this.missedHeartbeatCheckTimer = setInterval(() => {
-      if (Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
+      if (this.activeSocket && Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
         debug5("No heartbeat received in 30 seconds! Closing connection.");
-        this.socket?.close();
+        this.activeSocket.close();
       }
     }, this.heartbeatInterval);
   }
   stopHeartbeatCheck() {
     if (this.missedHeartbeatCheckTimer) {
       clearInterval(this.missedHeartbeatCheckTimer);
+      this.missedHeartbeatCheckTimer = void 0;
     }
   }
   /**
@@ -6364,6 +6533,9 @@ var Realtime = class {
    */
   onConnection(listener) {
     this.connectionListeners.add(listener);
+    if (this.isConnected()) {
+      listener(true);
+    }
     return () => {
       this.connectionListeners.delete(listener);
     };
@@ -6380,19 +6552,30 @@ var Realtime = class {
     };
   }
   close() {
-    if (this.socket) {
-      this.stopHeartbeatCheck();
-      this.socket.close();
-      this.socket = void 0;
+    this.isClosed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = void 0;
     }
+    this.stopHeartbeatCheck();
+    this.activeSocket?.close();
+    this.activeSocket = void 0;
+    this.drainingSockets.forEach((socket) => {
+      socket.close();
+    });
+    this.drainingSockets.clear();
+    this.isConnecting = false;
     this.eventListeners.clear();
     this.connectionListeners.clear();
     this.errorListeners.clear();
   }
   isConnected() {
-    return this.socket?.readyState === WebSocket.OPEN;
+    return this.activeSocket?.readyState === WebSocket.OPEN;
   }
 };
+_Realtime.DEFAULT_RECONNECT_DELAY_MS = 5e3;
+_Realtime.MAX_RECONNECT_DELAY_MS = 6e4;
+var Realtime = _Realtime;
 
 // src/domains/user/user.service.ts
 var UserService = class {