@rlanz/socket 0.0.1-9 → 0.1.0

package/build/{chunk-QNOOQXYY.js → chunk-DR6GWQUW.js}

@@ -1,6 +1,9 @@
+import {
+  SERVER_DISCONNECT_CODE
+} from "./chunk-YSW4MNFR.js";
 import {
   BindableChannelPattern
-} from "./chunk-6PJ4ALJD.js";
+} from "./chunk-DM3UQMWW.js";
 
 // src/client/callback.ts
 function reportClientError(error) {
@@ -86,7 +89,7 @@ var Channel = class {
    * Whether the channel should stay subscribed.
    */
   #subscribed = false;
-  #active = false;
+  #remoteSynchronization = { status: "idle" };
   /**
    * Event handlers grouped by event type.
    */
@@ -114,11 +117,7 @@ var Channel = class {
   #boundPresenceHandler = null;
   #boundEventHandler = null;
   #boundDisconnectHandler = null;
-  #listenersAttached = false;
-  #pendingSubscribe = null;
-  #subscribeToken = 0;
   #managedSubscriptions = 0;
-  #pendingUnsubscribe = null;
   constructor(name, transport) {
     this.name = name;
     this.#transport = transport;
@@ -137,7 +136,7 @@ var Channel = class {
    * Whether the channel is active on the server.
    */
   get active() {
-    return this.#active;
+    return this.#remoteSynchronization.status === "active";
   }
   /**
    * List of present users.
@@ -237,7 +236,9 @@ var Channel = class {
     return {
       ready,
       release: () => {
-        if (released) return this.#pendingUnsubscribe ?? Promise.resolve();
+        if (released) {
+          return this.#remoteSynchronization.status === "unsubscribing" ? this.#remoteSynchronization.promise : Promise.resolve();
+        }
         released = true;
         this.#managedSubscriptions--;
         return this.#unsubscribeIfUnused();
@@ -249,43 +250,41 @@ var Channel = class {
     return this.#ensureSubscribed(options);
   }
   async #ensureSubscribed(options) {
-    if (this.#pendingUnsubscribe) {
-      await this.#pendingUnsubscribe;
+    if (this.#remoteSynchronization.status === "unsubscribing") {
+      await this.#remoteSynchronization.promise;
     }
     if (!this.subscribed) return this;
-    if (this.#pendingSubscribe) {
-      await this.#pendingSubscribe.promise;
+    if (this.#remoteSynchronization.status === "subscribing") {
+      await this.#remoteSynchronization.pending.promise;
       return this;
     }
-    if (this.#active) {
+    if (this.#remoteSynchronization.status === "active") {
       return this;
     }
     const timeout = options.timeout ?? 5e3;
-    if (!this.#listenersAttached) {
+    if (this.#remoteSynchronization.status === "idle" || this.#remoteSynchronization.status === "remoteSubscriptionUncertain") {
       this.#setupSocketListeners();
     }
-    const token = ++this.#subscribeToken;
     const deferred = Promise.withResolvers();
-    this.#pendingSubscribe = {
-      promise: deferred.promise,
-      resolve: deferred.resolve,
-      reject: deferred.reject,
-      token
+    const synchronization = {
+      status: "subscribing",
+      pending: deferred,
+      connected: true
     };
-    const { resolve, reject } = this.#pendingSubscribe;
+    this.#remoteSynchronization = synchronization;
     const timer = setTimeout(() => {
-      if (token !== this.#subscribeToken) return;
-      this.#subscribeToken++;
-      this.#pendingSubscribe = null;
+      if (this.#remoteSynchronization !== synchronization) return;
+      this.#remoteSynchronization = { status: "waitingForReconnect" };
       this.#resetConnectionState();
-      reject(new Error(`Subscribe timeout for channel: ${this.name}`));
+      synchronization.pending.reject(new Error(`Subscribe timeout for channel: ${this.name}`));
+      void this.#transport.sendRequest({ type: "unsubscribe", channel: this.name }, timeout).catch(() => {
+      });
     }, timeout);
     this.#transport.sendRequest({ type: "subscribe", channel: this.name }, timeout).then((response) => {
-      if (token !== this.#subscribeToken) return;
+      if (this.#remoteSynchronization !== synchronization) return;
       clearTimeout(timer);
-      this.#pendingSubscribe = null;
       if (response.ok) {
-        this.#active = true;
+        this.#remoteSynchronization = { status: "active" };
         const presenceData = ClientPresenceSnapshot.fromTransport(
           response.data?.presenceData,
           this.name
@@ -293,17 +292,20 @@ var Channel = class {
         if (presenceData) {
           this.#handleInitialPresence(presenceData);
         }
-        resolve(this);
+        synchronization.pending.resolve(this);
       } else {
+        this.#remoteSynchronization = { status: "waitingForReconnect" };
         this.#resetConnectionState();
-        reject(new Error(response.error ?? "Subscribe failed"));
+        synchronization.pending.reject(new Error(response.error));
       }
     }).catch((error) => {
-      if (token !== this.#subscribeToken) return;
+      if (this.#remoteSynchronization !== synchronization) return;
       clearTimeout(timer);
-      this.#pendingSubscribe = null;
+      this.#remoteSynchronization = synchronization.connected ? { status: "subscriptionUncertain" } : { status: "waitingForReconnect" };
       this.#resetConnectionState();
-      reject(error instanceof Error ? error : new Error("Subscribe failed"));
+      synchronization.pending.reject(
+        error instanceof Error ? error : new Error("Subscribe failed")
+      );
     });
     await deferred.promise;
     return this;
@@ -318,35 +320,45 @@ var Channel = class {
   }
   #unsubscribeIfUnused(options = {}) {
     if (this.subscribed) return Promise.resolve();
-    if (this.#pendingUnsubscribe) return this.#pendingUnsubscribe;
-    const hadPendingSubscribe = this.#pendingSubscribe !== null;
-    this.#subscribeToken++;
-    if (this.#pendingSubscribe) {
-      this.#pendingSubscribe.reject(new Error(`Unsubscribed from channel: ${this.name}`));
-      this.#pendingSubscribe = null;
-    }
-    if (!hadPendingSubscribe && !this.#active) {
+    if (this.#remoteSynchronization.status === "unsubscribing") {
+      return this.#remoteSynchronization.promise;
+    }
+    const previousSynchronization = this.#remoteSynchronization;
+    const hadPendingSubscribe = previousSynchronization.status === "subscribing";
+    if (previousSynchronization.status === "subscribing") {
+      previousSynchronization.pending.reject(new Error(`Unsubscribed from channel: ${this.name}`));
+    }
+    const remoteSubscriptionPossible = previousSynchronization.status === "active" || previousSynchronization.status === "subscriptionUncertain" || previousSynchronization.status === "remoteSubscriptionUncertain";
+    if (!hadPendingSubscribe && !remoteSubscriptionPossible) {
       this.#cleanupTerminal();
       return Promise.resolve();
     }
-    this.#active = false;
-    const pending = new Promise((resolve) => {
-      const timeout = options.timeout ?? 5e3;
-      const timer = setTimeout(() => {
-        resolve();
-      }, timeout);
-      this.#transport.sendRequest({ type: "unsubscribe", channel: this.name }, timeout).then(() => {
-        clearTimeout(timer);
-        resolve();
-      }).catch(() => {
-        clearTimeout(timer);
-        resolve();
-      });
+    const timeout = options.timeout ?? 5e3;
+    const deferred = Promise.withResolvers();
+    const synchronization = {
+      status: "unsubscribing",
+      promise: deferred.promise
+    };
+    this.#remoteSynchronization = synchronization;
+    let remoteMayRemain = true;
+    let terminalSynchronization = null;
+    const timer = setTimeout(() => deferred.resolve(), timeout);
+    this.#transport.sendRequest({ type: "unsubscribe", channel: this.name }, timeout).then(() => {
+      remoteMayRemain = false;
+      clearTimeout(timer);
+      deferred.resolve();
+      if (this.#remoteSynchronization === terminalSynchronization) {
+        this.#remoteSynchronization = { status: "idle" };
+      }
+    }).catch(() => {
+      clearTimeout(timer);
+      deferred.resolve();
     });
-    this.#pendingUnsubscribe = pending;
+    const pending = deferred.promise;
     void pending.finally(() => {
-      if (this.#pendingUnsubscribe !== pending) return;
-      this.#pendingUnsubscribe = null;
+      if (this.#remoteSynchronization !== synchronization) return;
+      terminalSynchronization = remoteMayRemain ? { status: "remoteSubscriptionUncertain" } : { status: "idle" };
+      this.#remoteSynchronization = terminalSynchronization;
       this.#resetConnectionState();
       this.#detachTransportListeners();
       if (!this.subscribed) this.#clearCallbacks();
@@ -354,7 +366,7 @@ var Channel = class {
     return pending;
   }
   send(event, data) {
-    if (!this.#active) {
+    if (!this.active) {
       console.warn(`Cannot send to channel ${this.name}: not subscribed`);
       return this;
     }
@@ -370,7 +382,7 @@ var Channel = class {
    * Relays a client event to other members of this channel.
    */
   whisper(event, data) {
-    if (!this.#active) {
+    if (!this.active) {
       console.warn(`Cannot whisper to channel ${this.name}: not subscribed`);
       return this;
     }
@@ -383,7 +395,7 @@ var Channel = class {
     return this;
   }
   async sendWithAck(event, data) {
-    if (!this.#active) {
+    if (!this.active) {
       throw new Error(`Cannot send to channel ${this.name}: not subscribed`);
     }
     const payload = {
@@ -421,10 +433,16 @@ var Channel = class {
     };
     this.#transport.on(`channel:${this.name}:event`, this.#boundEventHandler);
     this.#boundDisconnectHandler = () => {
+      if (this.#remoteSynchronization.status === "subscribing") {
+        this.#remoteSynchronization.connected = false;
+      } else if (this.#remoteSynchronization.status === "active" || this.#remoteSynchronization.status === "subscriptionUncertain") {
+        this.#remoteSynchronization = { status: "waitingForReconnect" };
+      } else if (this.#remoteSynchronization.status === "remoteSubscriptionUncertain") {
+        this.#remoteSynchronization = { status: "idle" };
+      }
       this.#resetConnectionState();
     };
     this.#transport.on("disconnect", this.#boundDisconnectHandler);
-    this.#listenersAttached = true;
   }
   /**
    * Handles the initial presence snapshot.
@@ -460,7 +478,6 @@ var Channel = class {
     }
   }
   #resetConnectionState() {
-    this.#active = false;
     this.#presence = null;
   }
   #detachTransportListeners() {
@@ -476,7 +493,6 @@ var Channel = class {
       this.#transport.off("disconnect", this.#boundDisconnectHandler);
       this.#boundDisconnectHandler = null;
     }
-    this.#listenersAttached = false;
   }
   #clearUserCallbacks() {
     this.#eventHandlers.clear();
@@ -492,6 +508,7 @@ var Channel = class {
    * Performs terminal cleanup after the user leaves or the socket is disposed.
    */
   #cleanupTerminal() {
+    this.#remoteSynchronization = { status: "idle" };
     this.#resetConnectionState();
     this.#detachTransportListeners();
     this.#clearCallbacks();
@@ -500,22 +517,17 @@ var Channel = class {
 
 // src/client/socket_session.ts
 var ClientSocketSession = class {
-  #ws = null;
-  #state = "disconnected";
-  #connectPromise = null;
-  #cancelConnect = null;
+  #lifecycle = { kind: "disconnected", reconnectAttempt: 0 };
   #stateHandlers = /* @__PURE__ */ new Set();
   #eventHandlers = /* @__PURE__ */ new Map();
   #pendingRequests = /* @__PURE__ */ new Map();
   #requestId = 0;
-  #reconnectAttempts = 0;
-  #reconnectTimer = null;
-  #manualDisconnect = false;
   #buildUrl;
   #createWebSocket;
   #autoReconnect;
   #reconnectDelay;
   #reconnectMaxDelay;
+  #shouldReconnect;
   #onConnected;
   constructor(options) {
     this.#buildUrl = options.buildUrl;
@@ -523,115 +535,109 @@ var ClientSocketSession = class {
     this.#autoReconnect = options.autoReconnect ?? true;
     this.#reconnectDelay = Math.max(0, options.reconnectDelay ?? 250);
     this.#reconnectMaxDelay = Math.max(this.#reconnectDelay, options.reconnectMaxDelay ?? 5e3);
+    this.#shouldReconnect = options.shouldReconnect ?? ((event) => event.code !== SERVER_DISCONNECT_CODE);
     this.#onConnected = options.onConnected;
   }
   get state() {
-    return this.#state;
+    switch (this.#lifecycle.kind) {
+      case "opening":
+      case "connecting":
+        return "connecting";
+      case "opened":
+      case "connected":
+        return "connected";
+      case "disconnected":
+      case "waiting":
+      case "failed":
+        return "disconnected";
+    }
   }
   get connected() {
-    return this.#state === "connected";
+    return this.state === "connected";
   }
   connect() {
-    if (this.#state === "connected") {
-      return Promise.resolve();
-    }
-    if (this.#connectPromise) {
-      return this.#connectPromise;
-    }
-    this.#manualDisconnect = false;
-    this.#setState("connecting");
-    let setupFailed = false;
-    const connectPromise = new Promise((resolve, reject) => {
-      let ws;
-      try {
-        ws = this.#createWebSocket(this.#buildUrl());
-      } catch (error) {
-        setupFailed = true;
-        reject(error);
-        return;
-      }
-      this.#ws = ws;
-      let settled = false;
-      const cleanup = () => {
-        ws.removeEventListener("open", handleOpen);
-        ws.removeEventListener("error", handleError);
-        if (this.#connectPromise === connectPromise) {
-          this.#connectPromise = null;
-        }
-        if (this.#cancelConnect === cancelConnect) {
-          this.#cancelConnect = null;
-        }
-      };
-      const cancelConnect = (error) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        reject(error);
-      };
-      const handleOpen = () => {
-        if (settled || this.#ws !== ws) {
-          return;
-        }
-        this.#setState("connected");
-        if (settled || this.#ws !== ws || !this.connected) {
-          return;
-        }
-        settled = true;
-        cleanup();
-        this.#reconnectAttempts = 0;
-        this.#emitLocal("connect");
-        if (this.#onConnected) {
-          this.#callHandler(this.#onConnected);
-        }
-        resolve();
-      };
-      const handleError = () => {
-        cancelConnect(new Error("WebSocket connection failed"));
-        if (this.#ws === ws) {
-          this.#setState("disconnected");
-        }
-      };
-      const handleClose = () => {
-        cancelConnect(new Error("WebSocket connection failed"));
-        if (this.#ws === ws) {
-          this.#handleClose();
-        }
+    if (this.#lifecycle.kind === "connected") return Promise.resolve();
+    if (this.#lifecycle.kind === "opening" || this.#lifecycle.kind === "connecting") {
+      return this.#lifecycle.deferred.promise;
+    }
+    if (this.#lifecycle.kind === "opened") return this.#lifecycle.deferred.promise;
+    const reconnectAttempt = this.#reconnectAttempt;
+    const failedSocket = this.#lifecycle.kind === "failed" ? this.#lifecycle.connection.socket : null;
+    if (this.#lifecycle.kind === "waiting") clearTimeout(this.#lifecycle.timer);
+    const connection = this.#startConnection(reconnectAttempt);
+    failedSocket?.close();
+    return connection;
+  }
+  #startConnection(reconnectAttempt) {
+    const deferred = Promise.withResolvers();
+    const opening = { kind: "opening", deferred, reconnectAttempt };
+    this.#setLifecycle(opening);
+    if (this.#lifecycle !== opening) return deferred.promise;
+    let socket;
+    try {
+      socket = this.#createWebSocket(this.#buildUrl());
+    } catch (error) {
+      this.#setLifecycle({ kind: "disconnected", reconnectAttempt });
+      deferred.reject(error);
+      return deferred.promise;
+    }
+    const connection = { socket };
+    const connecting = {
+      kind: "connecting",
+      connection,
+      deferred,
+      reconnectAttempt
+    };
+    this.#lifecycle = connecting;
+    const cleanup = () => {
+      socket.removeEventListener("open", handleOpen);
+      socket.removeEventListener("error", handleError);
+    };
+    const handleOpen = () => {
+      if (this.#lifecycle !== connecting) return;
+      cleanup();
+      const opened = {
+        kind: "opened",
+        connection,
+        deferred,
+        reconnectAttempt
       };
-      this.#cancelConnect = cancelConnect;
-      ws.addEventListener("open", handleOpen);
-      ws.addEventListener("error", handleError);
-      ws.addEventListener("message", (event) => {
-        if (this.#ws === ws) {
-          this.#handleIncoming(event.data);
-        }
-      });
-      ws.addEventListener("close", handleClose);
+      this.#setLifecycle(opened);
+      if (!this.#isCurrent(opened)) return;
+      this.#lifecycle = { kind: "connected", connection };
+      this.#emitLocal("connect");
+      if (this.#onConnected) this.#callHandler(this.#onConnected);
+      deferred.resolve();
+    };
+    const handleError = () => {
+      if (this.#lifecycle !== connecting) return;
+      cleanup();
+      deferred.reject(new Error("WebSocket connection failed"));
+      this.#setLifecycle({ kind: "failed", connection, reconnectAttempt });
+    };
+    socket.addEventListener("open", handleOpen);
+    socket.addEventListener("error", handleError);
+    socket.addEventListener("message", (event) => {
+      if (this.#owns(connection)) this.#handleIncoming(event.data);
     });
-    this.#connectPromise = connectPromise;
-    if (setupFailed) {
-      this.#connectPromise = null;
-      this.#setState("disconnected");
-    }
-    return connectPromise;
+    socket.addEventListener("close", (event) => {
+      cleanup();
+      if (this.#owns(connection)) this.#handleClose(event);
+    });
+    return deferred.promise;
   }
   disconnect() {
-    this.#manualDisconnect = true;
-    if (this.#reconnectTimer) {
-      clearTimeout(this.#reconnectTimer);
-      this.#reconnectTimer = null;
-    }
-    this.#cancelConnect?.(new Error("Socket disconnected"));
-    this.#reconnectAttempts = 0;
-    const ws = this.#ws;
-    const shouldEmitDisconnect = this.#state !== "disconnected";
-    this.#ws = null;
-    this.#setState("disconnected");
+    const lifecycle = this.#lifecycle;
+    const shouldEmitDisconnect = this.state !== "disconnected";
+    if (lifecycle.kind === "waiting") clearTimeout(lifecycle.timer);
+    if (lifecycle.kind === "opening" || lifecycle.kind === "connecting" || lifecycle.kind === "opened") {
+      lifecycle.deferred.reject(new Error("Socket disconnected"));
+    }
+    this.#setLifecycle({ kind: "disconnected", reconnectAttempt: 0 });
     if (shouldEmitDisconnect) {
       this.#emitLocal("disconnect");
     }
-    ws?.close();
+    if ("connection" in lifecycle) lifecycle.connection.socket.close();
     this.#rejectPending(new Error("Socket disconnected"));
   }
   onStateChange(handler) {
@@ -653,15 +659,15 @@ var ClientSocketSession = class {
     this.#eventHandlers.get(event)?.delete(handler);
   }
   send(message) {
-    const ws = this.#ws;
-    if (ws?.readyState !== WebSocket.OPEN) {
+    const socket = this.#connection?.socket;
+    if (socket?.readyState !== WebSocket.OPEN) {
       return;
     }
-    ws.send(JSON.stringify(message));
+    socket.send(JSON.stringify(message));
   }
   sendRequest(message, timeout = 5e3) {
-    const ws = this.#ws;
-    if (ws?.readyState !== WebSocket.OPEN) {
+    const socket = this.#connection?.socket;
+    if (socket?.readyState !== WebSocket.OPEN) {
       return Promise.reject(new Error("Socket is not connected"));
     }
     const id = String(++this.#requestId);
@@ -676,7 +682,7 @@ var ClientSocketSession = class {
         reject,
         timer
       });
-      ws.send(JSON.stringify(payload));
+      socket.send(JSON.stringify(payload));
     });
   }
   #handleIncoming(raw) {
@@ -710,7 +716,7 @@ var ClientSocketSession = class {
       if (!message || typeof message !== "object" || Array.isArray(message)) {
         return null;
       }
-      if (message.type === "ack" && typeof message.id === "string" && typeof message.ok === "boolean" && (message.error === void 0 || typeof message.error === "string")) {
+      if (message.type === "ack" && typeof message.id === "string" && (message.ok === true && message.error === void 0 || message.ok === false && typeof message.error === "string" && message.data === void 0)) {
         return message;
       }
       if (message.type === "event" && typeof message.event === "string" && (message.channel === void 0 || typeof message.channel === "string")) {
@@ -737,33 +743,75 @@ var ClientSocketSession = class {
       pending.resolve({ ok: false, error: message.error });
     }
   }
-  #handleClose() {
-    const shouldEmitDisconnect = this.#state !== "disconnected";
-    this.#ws = null;
-    this.#setState("disconnected");
+  #handleClose(event) {
+    const lifecycle = this.#lifecycle;
+    const reconnectAttempt = "reconnectAttempt" in lifecycle ? lifecycle.reconnectAttempt : 0;
+    const shouldEmitDisconnect = this.state !== "disconnected";
+    if (lifecycle.kind === "connecting") {
+      lifecycle.deferred.reject(new Error("WebSocket connection failed"));
+    }
+    const disconnected = { kind: "disconnected", reconnectAttempt };
+    this.#setLifecycle(disconnected);
     if (shouldEmitDisconnect) {
       this.#emitLocal("disconnect");
     }
     this.#rejectPending(new Error("Socket disconnected"));
-    this.#scheduleReconnect();
-  }
-  #scheduleReconnect() {
-    if (this.#manualDisconnect || !this.#autoReconnect || this.#reconnectTimer) {
-      return;
+    if (this.#shouldReconnect(event) && this.#lifecycle === disconnected) {
+      this.#scheduleReconnect(disconnected);
     }
+  }
+  #scheduleReconnect(disconnected) {
+    if (!this.#autoReconnect || this.#lifecycle !== disconnected) return;
     const delay = Math.min(
-      this.#reconnectDelay * 2 ** this.#reconnectAttempts,
+      this.#reconnectDelay * 2 ** disconnected.reconnectAttempt,
       this.#reconnectMaxDelay
     );
-    this.#reconnectAttempts += 1;
-    this.#reconnectTimer = setTimeout(() => {
-      this.#reconnectTimer = null;
-      this.connect().catch(() => {
-        if (this.#state === "disconnected") {
-          this.#scheduleReconnect();
-        }
-      });
-    }, delay);
+    const waiting = {
+      kind: "waiting",
+      reconnectAttempt: disconnected.reconnectAttempt + 1,
+      timer: setTimeout(() => {
+        if (this.#lifecycle !== waiting) return;
+        this.#startConnection(waiting.reconnectAttempt).catch(() => {
+          if (this.#lifecycle.kind === "failed") {
+            const failed = this.#lifecycle;
+            const disconnected2 = {
+              kind: "disconnected",
+              reconnectAttempt: failed.reconnectAttempt
+            };
+            this.#setLifecycle(disconnected2);
+            failed.connection.socket.close();
+            if (this.#isCurrent(disconnected2)) this.#scheduleReconnect(disconnected2);
+            return;
+          }
+          if (this.#lifecycle.kind === "disconnected") {
+            this.#scheduleReconnect(this.#lifecycle);
+          }
+        });
+      }, delay)
+    };
+    this.#setLifecycle(waiting);
+  }
+  get #connection() {
+    const lifecycle = this.#lifecycle;
+    return "connection" in lifecycle ? lifecycle.connection : void 0;
+  }
+  get #reconnectAttempt() {
+    const lifecycle = this.#lifecycle;
+    return "reconnectAttempt" in lifecycle ? lifecycle.reconnectAttempt : 0;
+  }
+  #owns(connection) {
+    return this.#connection === connection;
+  }
+  #isCurrent(lifecycle) {
+    return this.#lifecycle === lifecycle;
+  }
+  #setLifecycle(lifecycle) {
+    const previousState = this.state;
+    this.#lifecycle = lifecycle;
+    const state = this.state;
+    if (previousState !== state) {
+      this.#stateHandlers.forEach((handler) => this.#callHandler(handler, state));
+    }
   }
   #rejectPending(error) {
     for (const [id, pending] of this.#pendingRequests) {
@@ -775,13 +823,6 @@ var ClientSocketSession = class {
   #emitLocal(event, data) {
     this.#eventHandlers.get(event)?.forEach((handler) => this.#callHandler(handler, data));
   }
-  #setState(state) {
-    if (this.#state === state) {
-      return;
-    }
-    this.#state = state;
-    this.#stateHandlers.forEach((handler) => this.#callHandler(handler, state));
-  }
   #callHandler(handler, data) {
     callClientHandler(handler, data);
   }
@@ -811,6 +852,7 @@ var Socket = class {
       autoReconnect: options.autoReconnect,
       reconnectDelay: options.reconnectDelay,
       reconnectMaxDelay: options.reconnectMaxDelay,
+      shouldReconnect: options.shouldReconnect,
       onConnected: () => {
         void this.#resubscribeChannels();
       }
@@ -879,6 +921,7 @@ var Socket = class {
       throw new Error(`Unsupported socket URL protocol: ${url.protocol}`);
     }
     url.pathname = this.#path;
+    url.hash = "";
     return url.toString();
   }
   async #resubscribeChannels() {
@@ -896,4 +939,4 @@ export {
   buildChannelName,
   Socket
 };
-//# sourceMappingURL=chunk-QNOOQXYY.js.map
+//# sourceMappingURL=chunk-DR6GWQUW.js.map