react-realtime-hooks 1.2.0 → 1.2.2

package/dist/index.cjs

@@ -444,6 +444,11 @@ var createReconnectAttempt = (attempt, trigger, options, lastDelayMs, config = {
     trigger
   };
 };
+var useStableCallback = (callback) => {
+  const callbackRef = react.useRef(callback);
+  callbackRef.current = callback;
+  return react.useCallback((...args) => callbackRef.current(...args), []);
+};
 
 // src/hooks/useReconnect.ts
 var createInitialState = (enabled) => ({
@@ -467,20 +472,20 @@ var useReconnect = (options = {}) => {
       setState(resolved);
     });
   };
-  const runAttempt = react.useEffectEvent((attempt) => {
+  const runAttempt = useStableCallback((attempt) => {
     commitState({
       attempt,
       nextDelayMs: null,
       status: "running"
     });
   });
-  const emitSchedule = react.useEffectEvent((attempt) => {
+  const emitSchedule = useStableCallback((attempt) => {
     normalizedOptions.onSchedule?.(attempt);
   });
-  const emitCancel = react.useEffectEvent(() => {
+  const emitCancel = useStableCallback(() => {
     normalizedOptions.onCancel?.();
   });
-  const emitReset = react.useEffectEvent(() => {
+  const emitReset = useStableCallback(() => {
     normalizedOptions.onReset?.();
   });
   react.useEffect(() => {
@@ -503,7 +508,7 @@ var useReconnect = (options = {}) => {
   react.useEffect(() => () => {
     timeoutRef.current.cancel();
   }, []);
-  const schedule = (trigger = "manual") => {
+  const schedule = useStableCallback((trigger = "manual") => {
     const current = stateRef.current;
     const nextAttempt = current.attempt + 1;
     const attempt = createReconnectAttempt(
@@ -531,8 +536,8 @@ var useReconnect = (options = {}) => {
       status: "scheduled"
     });
     emitSchedule(attempt);
-  };
-  const cancel = () => {
+  });
+  const cancel = useStableCallback(() => {
     const current = stateRef.current;
     const shouldEmitCancel = timeoutRef.current.isActive() || current.status === "scheduled" || current.status === "running";
     timeoutRef.current.cancel();
@@ -544,14 +549,14 @@ var useReconnect = (options = {}) => {
     if (shouldEmitCancel) {
       emitCancel();
     }
-  };
-  const reset = () => {
+  });
+  const reset = useStableCallback(() => {
     timeoutRef.current.cancel();
     lastDelayRef.current = null;
     commitState(createInitialState(normalizedOptions.enabled));
     emitReset();
-  };
-  const markConnected = () => {
+  });
+  const markConnected = useStableCallback(() => {
     timeoutRef.current.cancel();
     if (normalizedOptions.resetOnSuccess) {
       lastDelayRef.current = null;
@@ -564,7 +569,7 @@ var useReconnect = (options = {}) => {
       nextDelayMs: null,
       status: normalizedOptions.enabled ? "idle" : "stopped"
     }));
-  };
+  });
   return {
     attempt: state.attempt,
     cancel,
@@ -600,14 +605,14 @@ var useHeartbeat = (options) => {
     stateRef.current = resolved;
     setState(resolved);
   };
-  const handleTimeout = react.useEffectEvent(() => {
+  const handleTimeout = useStableCallback(() => {
     commitState((current) => ({
       ...current,
       hasTimedOut: true
     }));
     options.onTimeout?.();
   });
-  const scheduleTimeout = react.useEffectEvent(() => {
+  const scheduleTimeout = useStableCallback(() => {
     if (options.timeoutMs === void 0) {
       timeoutRef.current.cancel();
       return;
@@ -616,7 +621,7 @@ var useHeartbeat = (options) => {
       handleTimeout();
     }, options.timeoutMs);
   });
-  const handleBeatSuccess = react.useEffectEvent((performedAt) => {
+  const handleBeatSuccess = useStableCallback((performedAt) => {
     commitState((current) => ({
       ...current,
       hasTimedOut: false,
@@ -625,11 +630,11 @@ var useHeartbeat = (options) => {
     scheduleTimeout();
     options.onBeat?.();
   });
-  const handleBeatError = react.useEffectEvent((error) => {
+  const handleBeatError = useStableCallback((error) => {
     timeoutRef.current.cancel();
     options.onError?.(error);
   });
-  const runBeat = react.useEffectEvent(() => {
+  const runBeat = useStableCallback(() => {
     const generation = generationRef.current;
     const completeBeat = (result) => {
       if (generation !== generationRef.current || result === false) {
@@ -654,7 +659,7 @@ var useHeartbeat = (options) => {
       failBeat(error);
     }
   });
-  const start = () => {
+  const start = useStableCallback(() => {
     if (!enabled) {
       return;
     }
@@ -668,20 +673,20 @@ var useHeartbeat = (options) => {
       hasTimedOut: false,
       isRunning: true
     }));
-  };
-  const stop = () => {
+  });
+  const stop = useStableCallback(() => {
     generationRef.current += 1;
     intervalRef.current.cancel();
     timeoutRef.current.cancel();
     commitState(createInitialState2(false));
-  };
-  const beat = () => {
+  });
+  const beat = useStableCallback(() => {
     if (!enabled) {
       return;
     }
     runBeat();
-  };
-  const notifyAck = (message) => {
+  });
+  const notifyAck = useStableCallback((message) => {
     if (stateRef.current.lastBeatAt === null) {
       return false;
     }
@@ -698,7 +703,7 @@ var useHeartbeat = (options) => {
       latencyMs: current.lastBeatAt === null ? null : acknowledgedAt - current.lastBeatAt
     }));
     return true;
-  };
+  });
   react.useEffect(() => {
     if (!enabled) {
       stop();
@@ -710,7 +715,7 @@ var useHeartbeat = (options) => {
     }
     stop();
     return void 0;
-  }, [enabled, options.intervalMs, startOnMount]);
+  }, [enabled, options.intervalMs, start, startOnMount, stop]);
   react.useEffect(() => () => {
     generationRef.current += 1;
     intervalRef.current.cancel();
@@ -774,6 +779,17 @@ var createConnectionStateSnapshot = (status, config = {}) => {
   }
 };
 
+// src/core/errors.ts
+var RealtimeErrorEvent = class extends Event {
+  cause;
+  kind;
+  constructor(type, init) {
+    super(type, init);
+    this.cause = init.cause;
+    this.kind = init.kind;
+  }
+};
+
 // src/core/url.ts
 var normalizeResolvedUrl = (value) => {
   if (value === null) {
@@ -815,8 +831,9 @@ var toProtocolsDependency = (protocols) => {
   if (protocols === void 0) {
     return "";
   }
-  return Array.isArray(protocols) ? protocols.join("|") : protocols;
+  return JSON.stringify(protocols);
 };
+var parseProtocolsDependency = (protocolsDependency) => protocolsDependency === "" ? void 0 : JSON.parse(protocolsDependency);
 var toHeartbeatConfig = (heartbeat) => heartbeat === void 0 || heartbeat === false ? null : heartbeat;
 var isSocketActive = (socket) => socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING;
 var useWebSocket = (options) => {
@@ -824,8 +841,15 @@ var useWebSocket = (options) => {
   const supported = isWebSocketSupported();
   const resolvedUrl = react.useMemo(() => resolveUrlProvider(options.url), [options.url]);
   const protocolsDependency = toProtocolsDependency(options.protocols);
+  const protocols = react.useMemo(
+    () => parseProtocolsDependency(protocolsDependency),
+    [protocolsDependency]
+  );
   const socketRef = react.useRef(null);
   const socketKeyRef = react.useRef(null);
+  const activeSocketEpochRef = react.useRef(null);
+  const closingSocketEpochRef = react.useRef(null);
+  const nextSocketEpochRef = react.useRef(0);
   const manualCloseRef = react.useRef(false);
   const manualOpenRef = react.useRef(false);
   const skipCloseReconnectRef = react.useRef(false);
@@ -890,14 +914,19 @@ var useWebSocket = (options) => {
     heartbeatHookOptions.onTimeout = () => {
       applyHeartbeatAction(
         heartbeatConfig.timeoutAction ?? defaultHeartbeatAction,
-        new Event("heartbeat-timeout"),
+        new RealtimeErrorEvent("heartbeat-timeout", {
+          kind: "heartbeat-timeout"
+        }),
         "heartbeat-timeout"
       );
       onTimeout?.();
     };
     const onError = heartbeatConfig.onError;
     heartbeatHookOptions.onError = (error) => {
-      const event = error instanceof Event ? error : new Event("heartbeat-error");
+      const event = new RealtimeErrorEvent("heartbeat-error", {
+        cause: error,
+        kind: "heartbeat-error"
+      });
       applyHeartbeatAction(
         heartbeatConfig.errorAction ?? heartbeatConfig.timeoutAction ?? defaultHeartbeatAction,
         event,
@@ -909,23 +938,34 @@ var useWebSocket = (options) => {
   const heartbeat = useHeartbeat(
     heartbeatHookOptions
   );
-  const commitState = (next) => {
+  const commitState = useStableCallback((next) => {
     const resolved = typeof next === "function" ? next(stateRef.current) : next;
     stateRef.current = resolved;
     setState(resolved);
-  };
-  const closeSocket = react.useEffectEvent((code, reason) => {
-    const socket2 = socketRef.current;
-    if (socket2 === null) {
-      return;
-    }
-    socketRef.current = null;
-    socketKeyRef.current = null;
-    if (isSocketActive(socket2)) {
-      socket2.close(code, reason);
-    }
   });
-  const applyHeartbeatAction = react.useEffectEvent(
+  const isActiveSocketEvent = useStableCallback((socketEpoch) => {
+    return activeSocketEpochRef.current === socketEpoch;
+  });
+  const shouldHandleSocketClose = useStableCallback((socketEpoch) => {
+    return activeSocketEpochRef.current === socketEpoch || closingSocketEpochRef.current === socketEpoch;
+  });
+  const closeSocket = useStableCallback(
+    (config = {}) => {
+      const socket2 = socketRef.current;
+      const socketEpoch = activeSocketEpochRef.current;
+      if (socket2 === null || socketEpoch === null) {
+        return;
+      }
+      socketRef.current = null;
+      socketKeyRef.current = null;
+      activeSocketEpochRef.current = null;
+      closingSocketEpochRef.current = config.trackClose ? socketEpoch : null;
+      if (isSocketActive(socket2)) {
+        socket2.close(config.code, config.reason);
+      }
+    }
+  );
+  const applyHeartbeatAction = useStableCallback(
     (action, error, reconnectTrigger) => {
       heartbeat.stop();
       options.onError?.(error);
@@ -959,20 +999,20 @@ var useWebSocket = (options) => {
       };
       skipCloseReconnectRef.current = true;
       suppressReconnectRef.current = true;
-      closeSocket();
+      closeSocket({ trackClose: true });
     }
   );
-  const parseMessage = react.useEffectEvent((event) => {
+  const parseMessage = useStableCallback((event) => {
     const parser = options.parseMessage ?? defaultParseMessage;
     return parser(event);
   });
-  const updateBufferedAmount = react.useEffectEvent(() => {
+  const updateBufferedAmount = useStableCallback(() => {
     commitState((current) => ({
       ...current,
       bufferedAmount: socketRef.current?.bufferedAmount ?? 0
     }));
   });
-  const handleOpen = react.useEffectEvent((event, socket2) => {
+  const handleOpen = useStableCallback((event, socket2) => {
     manualCloseRef.current = false;
     manualOpenRef.current = false;
     suppressReconnectRef.current = false;
@@ -987,7 +1027,7 @@ var useWebSocket = (options) => {
     }));
     options.onOpen?.(event, socket2);
   });
-  const handleMessage = react.useEffectEvent((event) => {
+  const handleMessage = useStableCallback((event) => {
     try {
       const message = parseMessage(event);
       heartbeat.notifyAck(message);
@@ -998,8 +1038,11 @@ var useWebSocket = (options) => {
         lastMessageEvent: event
       }));
       options.onMessage?.(message, event);
-    } catch {
-      const parseError = new Event("error");
+    } catch (error) {
+      const parseError = new RealtimeErrorEvent("error", {
+        cause: error,
+        kind: "parse-error"
+      });
       terminalErrorRef.current = parseError;
       manualOpenRef.current = false;
       skipCloseReconnectRef.current = true;
@@ -1013,10 +1056,17 @@ var useWebSocket = (options) => {
         lastError: parseError,
         status: "error"
       }));
-      closeSocket(1003, "parse-error");
+      closeSocket({
+        code: 1003,
+        reason: "parse-error",
+        trackClose: true
+      });
     }
   });
-  const handleError = react.useEffectEvent((event) => {
+  const handleError = useStableCallback((event, socketEpoch) => {
+    if (!isActiveSocketEvent(socketEpoch)) {
+      return;
+    }
     heartbeat.stop();
     commitState((current) => ({
       ...current,
@@ -1026,9 +1076,18 @@ var useWebSocket = (options) => {
     }));
     options.onError?.(event);
   });
-  const handleClose = react.useEffectEvent((event) => {
-    socketRef.current = null;
-    socketKeyRef.current = null;
+  const handleClose = useStableCallback((event, socketEpoch) => {
+    if (!shouldHandleSocketClose(socketEpoch)) {
+      return;
+    }
+    if (activeSocketEpochRef.current === socketEpoch) {
+      socketRef.current = null;
+      socketKeyRef.current = null;
+      activeSocketEpochRef.current = null;
+    }
+    if (closingSocketEpochRef.current === socketEpoch) {
+      closingSocketEpochRef.current = null;
+    }
     heartbeat.stop();
     updateBufferedAmount();
     const pendingCloseAction = pendingCloseActionRef.current;
@@ -1077,15 +1136,15 @@ var useWebSocket = (options) => {
       suppressReconnectRef.current = false;
     }
   });
-  const open = () => {
+  const open = useStableCallback(() => {
     manualCloseRef.current = false;
     manualOpenRef.current = true;
     suppressReconnectRef.current = false;
     terminalErrorRef.current = null;
     reconnect.cancel();
     setOpenNonce((current) => current + 1);
-  };
-  const reconnectNow = () => {
+  });
+  const reconnectNow = useStableCallback(() => {
     manualCloseRef.current = false;
     manualOpenRef.current = true;
     skipCloseReconnectRef.current = true;
@@ -1095,8 +1154,8 @@ var useWebSocket = (options) => {
     closeSocket();
     suppressReconnectRef.current = false;
     reconnect.schedule("manual");
-  };
-  const close = (code, reason) => {
+  });
+  const close = useStableCallback((code, reason) => {
     manualCloseRef.current = true;
     manualOpenRef.current = false;
     suppressReconnectRef.current = true;
@@ -1108,9 +1167,13 @@ var useWebSocket = (options) => {
       lastChangedAt: Date.now(),
       status: "closing"
     }));
-    closeSocket(code, reason);
-  };
-  const send = (message) => {
+    closeSocket({
+      code,
+      reason,
+      trackClose: true
+    });
+  });
+  const send = useStableCallback((message) => {
     const socket2 = socketRef.current;
     if (socket2 === null || socket2.readyState !== WebSocket.OPEN) {
       return false;
@@ -1119,7 +1182,7 @@ var useWebSocket = (options) => {
     socket2.send(serializer(message));
     updateBufferedAmount();
     return true;
-  };
+  });
   react.useEffect(() => {
     if (!supported) {
       socketKeyRef.current = null;
@@ -1159,9 +1222,13 @@ var useWebSocket = (options) => {
     if (socketRef.current !== null) {
       return;
     }
-    const socket2 = new WebSocket(resolvedUrl, options.protocols);
+    const socket2 = new WebSocket(resolvedUrl, protocols);
+    const socketEpoch = nextSocketEpochRef.current + 1;
     socketRef.current = socket2;
     socketKeyRef.current = nextSocketKey;
+    activeSocketEpochRef.current = socketEpoch;
+    closingSocketEpochRef.current = null;
+    nextSocketEpochRef.current = socketEpoch;
     socket2.binaryType = options.binaryType ?? "blob";
     commitState((current) => ({
       ...current,
@@ -1170,16 +1237,22 @@ var useWebSocket = (options) => {
       status: reconnect.status === "running" || reconnect.status === "scheduled" ? "reconnecting" : "connecting"
     }));
     const handleSocketOpen = (event) => {
+      if (!isActiveSocketEvent(socketEpoch)) {
+        return;
+      }
       handleOpen(event, socket2);
     };
     const handleSocketMessage = (event) => {
+      if (!isActiveSocketEvent(socketEpoch)) {
+        return;
+      }
       handleMessage(event);
     };
     const handleSocketError = (event) => {
-      handleError(event);
+      handleError(event, socketEpoch);
     };
     const handleSocketClose = (event) => {
-      handleClose(event);
+      handleClose(event, socketEpoch);
     };
     socket2.addEventListener("open", handleSocketOpen);
     socket2.addEventListener("message", handleSocketMessage);
@@ -1192,9 +1265,17 @@ var useWebSocket = (options) => {
       socket2.removeEventListener("close", handleSocketClose);
     };
   }, [
+    closeSocket,
+    commitState,
     connect,
+    handleClose,
+    handleError,
+    handleMessage,
+    handleOpen,
+    isActiveSocketEvent,
     openNonce,
     options.binaryType,
+    protocols,
     protocolsDependency,
     reconnect.status,
     resolvedUrl,
@@ -1203,6 +1284,8 @@ var useWebSocket = (options) => {
   react.useEffect(() => () => {
     suppressReconnectRef.current = true;
     socketKeyRef.current = null;
+    activeSocketEpochRef.current = null;
+    closingSocketEpochRef.current = null;
     terminalErrorRef.current = null;
     const socket2 = socketRef.current;
     socketRef.current = null;
@@ -1213,11 +1296,12 @@ var useWebSocket = (options) => {
       socket2.close();
     }
   }, []);
+  const stopHeartbeat = heartbeat.stop;
   react.useEffect(() => {
     if (state.status !== "open") {
-      heartbeat.stop();
+      stopHeartbeat();
     }
-  }, [state.status]);
+  }, [state.status, stopHeartbeat]);
   const status = (reconnect.status === "scheduled" || reconnect.status === "running") && state.status !== "open" ? "reconnecting" : state.status;
   const snapshot = createConnectionStateSnapshot(status, {
     isSupported: supported,
@@ -1273,29 +1357,27 @@ var createInitialState4 = (status = "idle") => ({
   status
 });
 var defaultParseMessage2 = (event) => event.data;
-var toEventsDependency = (events) => {
-  if (events === void 0 || events.length === 0) {
-    return "";
-  }
-  return [...new Set(events)].sort().join("|");
-};
 var normalizeNamedEvents = (events) => {
   if (events === void 0 || events.length === 0) {
     return [];
   }
-  return [...new Set(events)].filter((eventName) => eventName !== "message");
+  return [...new Set(events)].filter((eventName) => eventName !== "message").sort();
 };
+var toEventsDependency = (events) => JSON.stringify(normalizeNamedEvents(events));
+var parseEventsDependency = (eventsDependency) => JSON.parse(eventsDependency);
 var useEventSource = (options) => {
   const connect = options.connect ?? true;
   const supported = isEventSourceSupported();
   const resolvedUrl = react.useMemo(() => resolveUrlProvider(options.url), [options.url]);
   const eventsDependency = toEventsDependency(options.events);
   const namedEvents = react.useMemo(
-    () => normalizeNamedEvents(options.events),
+    () => parseEventsDependency(eventsDependency),
     [eventsDependency]
   );
   const eventSourceRef = react.useRef(null);
   const eventSourceKeyRef = react.useRef(null);
+  const activeEventSourceEpochRef = react.useRef(null);
+  const nextEventSourceEpochRef = react.useRef(0);
   const manualCloseRef = react.useRef(false);
   const manualOpenRef = react.useRef(false);
   const skipErrorReconnectRef = react.useRef(false);
@@ -1314,25 +1396,29 @@ var useEventSource = (options) => {
       enabled: reconnectEnabled && (options.reconnect?.enabled ?? true)
     }
   );
-  const commitState = (next) => {
+  const commitState = useStableCallback((next) => {
     const resolved = typeof next === "function" ? next(stateRef.current) : next;
     stateRef.current = resolved;
     setState(resolved);
-  };
-  const closeEventSource = react.useEffectEvent(() => {
+  });
+  const closeEventSource = useStableCallback(() => {
     const source = eventSourceRef.current;
     if (source === null) {
       return;
     }
     eventSourceRef.current = null;
     eventSourceKeyRef.current = null;
+    activeEventSourceEpochRef.current = null;
     source.close();
   });
-  const parseMessage = react.useEffectEvent((event) => {
+  const isActiveEventSourceEvent = useStableCallback((sourceEpoch) => {
+    return activeEventSourceEpochRef.current === sourceEpoch;
+  });
+  const parseMessage = useStableCallback((event) => {
     const parser = options.parseMessage ?? defaultParseMessage2;
     return parser(event);
   });
-  const handleOpen = react.useEffectEvent((event, source) => {
+  const handleOpen = useStableCallback((event, source) => {
     manualCloseRef.current = false;
     manualOpenRef.current = false;
     suppressReconnectRef.current = false;
@@ -1345,7 +1431,7 @@ var useEventSource = (options) => {
     }));
     options.onOpen?.(event, source);
   });
-  const commitParsedMessage = react.useEffectEvent(
+  const commitParsedMessage = useStableCallback(
     (eventName, event, isNamedEvent) => {
       try {
         const message = parseMessage(event);
@@ -1360,8 +1446,11 @@ var useEventSource = (options) => {
           return;
         }
         options.onMessage?.(message, event);
-      } catch {
-        const parseError = new Event("error");
+      } catch (error) {
+        const parseError = new RealtimeErrorEvent("error", {
+          cause: error,
+          kind: "parse-error"
+        });
         terminalErrorRef.current = parseError;
         manualOpenRef.current = false;
         suppressReconnectRef.current = true;
@@ -1377,7 +1466,10 @@ var useEventSource = (options) => {
       }
     }
   );
-  const handleError = react.useEffectEvent((event, source) => {
+  const handleError = useStableCallback((event, source, sourceEpoch) => {
+    if (!isActiveEventSourceEvent(sourceEpoch)) {
+      return;
+    }
     const terminalError = terminalErrorRef.current;
     if (terminalError !== null) {
       suppressReconnectRef.current = false;
@@ -1392,12 +1484,11 @@ var useEventSource = (options) => {
     const skipErrorReconnect = skipErrorReconnectRef.current;
     skipErrorReconnectRef.current = false;
     const shouldReconnect = !suppressReconnectRef.current && !skipErrorReconnect && reconnectEnabled && (options.shouldReconnect?.(event) ?? true);
-    const readyState = source.readyState;
     commitState((current) => ({
       ...current,
       lastChangedAt: Date.now(),
       lastError: event,
-      status: readyState === EventSource.OPEN ? "open" : shouldReconnect ? "reconnecting" : "closed"
+      status: shouldReconnect ? "reconnecting" : "closed"
     }));
     options.onError?.(event);
     if (!shouldReconnect) {
@@ -1405,21 +1496,18 @@ var useEventSource = (options) => {
       closeEventSource();
       return;
     }
-    if (readyState === EventSource.CLOSED) {
-      eventSourceRef.current = null;
-      eventSourceKeyRef.current = null;
-      reconnect.schedule("error");
-    }
+    closeEventSource();
+    reconnect.schedule("error");
   });
-  const open = () => {
+  const open = useStableCallback(() => {
     manualCloseRef.current = false;
     manualOpenRef.current = true;
     suppressReconnectRef.current = false;
     terminalErrorRef.current = null;
     reconnect.cancel();
     setOpenNonce((current) => current + 1);
-  };
-  const reconnectNow = () => {
+  });
+  const reconnectNow = useStableCallback(() => {
     manualCloseRef.current = false;
     manualOpenRef.current = true;
     skipErrorReconnectRef.current = true;
@@ -1428,8 +1516,8 @@ var useEventSource = (options) => {
     closeEventSource();
     suppressReconnectRef.current = false;
     reconnect.schedule("manual");
-  };
-  const close = () => {
+  });
+  const close = useStableCallback(() => {
     manualCloseRef.current = true;
     manualOpenRef.current = false;
     suppressReconnectRef.current = true;
@@ -1441,7 +1529,7 @@ var useEventSource = (options) => {
       lastChangedAt: Date.now(),
       status: "closed"
     }));
-  };
+  });
   react.useEffect(() => {
     if (!supported) {
       eventSourceKeyRef.current = null;
@@ -1460,7 +1548,7 @@ var useEventSource = (options) => {
       }));
       return;
     }
-    const shouldConnect = terminalErrorRef.current === null && (connect && !manualCloseRef.current || manualOpenRef.current || reconnect.status === "running");
+    const shouldConnect = terminalErrorRef.current === null && (reconnect.status === "running" || reconnect.status !== "scheduled" && (connect && !manualCloseRef.current || manualOpenRef.current));
     const nextEventSourceKey = [
       resolvedUrl,
       options.withCredentials ? "credentials" : "anonymous",
@@ -1488,27 +1576,39 @@ var useEventSource = (options) => {
     const source = new EventSource(resolvedUrl, {
       withCredentials: options.withCredentials ?? false
     });
+    const sourceEpoch = nextEventSourceEpochRef.current + 1;
     eventSourceRef.current = source;
     eventSourceKeyRef.current = nextEventSourceKey;
+    activeEventSourceEpochRef.current = sourceEpoch;
+    nextEventSourceEpochRef.current = sourceEpoch;
     commitState((current) => ({
       ...current,
       lastChangedAt: Date.now(),
       status: reconnect.status === "running" || reconnect.status === "scheduled" ? "reconnecting" : "connecting"
     }));
     const handleSourceOpen = (event) => {
+      if (!isActiveEventSourceEvent(sourceEpoch)) {
+        return;
+      }
       handleOpen(event, source);
     };
     const handleSourceMessage = (event) => {
+      if (!isActiveEventSourceEvent(sourceEpoch)) {
+        return;
+      }
       commitParsedMessage("message", event, false);
     };
     const namedEventHandlers = /* @__PURE__ */ new Map();
     const handleSourceError = (event) => {
-      handleError(event, source);
+      handleError(event, source, sourceEpoch);
     };
     source.addEventListener("open", handleSourceOpen);
     source.addEventListener("message", handleSourceMessage);
     for (const eventName of namedEvents) {
       const handler = (event) => {
+        if (!isActiveEventSourceEvent(sourceEpoch)) {
+          return;
+        }
         commitParsedMessage(eventName, event, true);
       };
       namedEventHandlers.set(eventName, handler);
@@ -1524,8 +1624,14 @@ var useEventSource = (options) => {
       source.removeEventListener("error", handleSourceError);
     };
   }, [
+    closeEventSource,
+    commitParsedMessage,
+    commitState,
     connect,
     eventsDependency,
+    handleError,
+    handleOpen,
+    isActiveEventSourceEvent,
     namedEvents,
     openNonce,
     options.withCredentials,
@@ -1536,6 +1642,7 @@ var useEventSource = (options) => {
   react.useEffect(() => () => {
     suppressReconnectRef.current = true;
     eventSourceKeyRef.current = null;
+    activeEventSourceEpochRef.current = null;
     terminalErrorRef.current = null;
     const source = eventSourceRef.current;
     eventSourceRef.current = null;
@@ -1580,6 +1687,7 @@ var useEventSource = (options) => {
   };
 };
 
+exports.RealtimeErrorEvent = RealtimeErrorEvent;
 exports.useConnectionGate = useConnectionGate;
 exports.useEventSource = useEventSource;
 exports.useHeartbeat = useHeartbeat;