evstream 1.0.0 → 1.0.1

package/dist/adapters/redis.d.ts

@@ -0,0 +1,10 @@
+import { RedisOptions } from 'ioredis';
+import { EvStateAdapter } from '../types.js';
+export declare class EvRedisAdapter implements EvStateAdapter {
+    #private;
+    constructor(options?: RedisOptions);
+    publish(channel: string, message: any): Promise<void>;
+    subscribe(channel: string, onMessage: (message: any) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+    quit(): void;
+}

package/dist/adapters/redis.js

@@ -0,0 +1,70 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners;
+import Redis from 'ioredis';
+export class EvRedisAdapter {
+    constructor(options) {
+        _EvRedisAdapter_pub.set(this, void 0);
+        _EvRedisAdapter_sub.set(this, void 0);
+        _EvRedisAdapter_listeners.set(this, void 0);
+        __classPrivateFieldSet(this, _EvRedisAdapter_pub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisAdapter_sub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisAdapter_listeners, new Map(), "f");
+        __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").on('message', (channel, message) => {
+            const handlers = __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel);
+            if (handlers) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(message);
+                }
+                catch (_a) {
+                    return;
+                }
+                handlers.forEach(handler => handler(parsed));
+            }
+        });
+    }
+    publish(channel, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify(message));
+        });
+    }
+    subscribe(channel, onMessage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").has(channel)) {
+                __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").set(channel, new Set());
+                yield __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").subscribe(channel);
+            }
+            __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel).add(onMessage);
+        });
+    }
+    unsubscribe(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").unsubscribe(channel);
+            __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").delete(channel);
+        });
+    }
+    quit() {
+        __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").quit();
+        __classPrivateFieldGet(this, _EvRedisAdapter_sub, "f").quit();
+    }
+}
+_EvRedisAdapter_pub = new WeakMap(), _EvRedisAdapter_sub = new WeakMap(), _EvRedisAdapter_listeners = new WeakMap();

package/dist/manager.js

@@ -63,17 +63,29 @@ export class EvStreamManager {
                 onClose(channel);
             }
             isClosed = true;
+            // Remove close event listener to prevent memory leaks
+            res.removeAllListeners('close');
+            // Clean up client
             client.close();
+            // Decrement count
             __classPrivateFieldSet(this, _EvStreamManager_count, __classPrivateFieldGet(this, _EvStreamManager_count, "f") - 1, "f");
+            // Remove from all channels
             channel.forEach(chan => __classPrivateFieldGet(this, _EvStreamManager_instances, "m", _EvStreamManager_unlisten).call(this, chan, id));
+            // Clear channel array to release references
+            channel.length = 0;
+            // Remove client from map
             __classPrivateFieldGet(this, _EvStreamManager_clients, "f").delete(id);
-            res.end();
+            // End response if not already ended
+            if (!res.writableEnded) {
+                res.end();
+            }
         };
-        res.on('close', () => {
+        const onCloseHandler = () => {
             if (!isClosed) {
                 close();
             }
-        });
+        };
+        res.on('close', onCloseHandler);
         return {
             authenticate: client.authenticate.bind(client),
             message: client.message.bind(client),
@@ -91,6 +103,8 @@ export class EvStreamManager {
      */
     send(name, msg) {
         const listeners = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
+        if (!listeners)
+            return;
         for (const [_, id] of listeners.entries()) {
             const client = __classPrivateFieldGet(this, _EvStreamManager_clients, "f").get(id);
             if (client) {
@@ -102,15 +116,15 @@ export class EvStreamManager {
     }
 }
 _EvStreamManager_clients = new WeakMap(), _EvStreamManager_listeners = new WeakMap(), _EvStreamManager_count = new WeakMap(), _EvStreamManager_maxConnections = new WeakMap(), _EvStreamManager_maxListeners = new WeakMap(), _EvStreamManager_id = new WeakMap(), _EvStreamManager_instances = new WeakSet(), _EvStreamManager_listen = function _EvStreamManager_listen(name, id) {
-    var _a;
-    if (!__classPrivateFieldGet(this, _EvStreamManager_listeners, "f").has(name)) {
-        const size = (_a = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name)) === null || _a === void 0 ? void 0 : _a.size;
-        if (size >= __classPrivateFieldGet(this, _EvStreamManager_maxListeners, "f")) {
-            throw new EvMaxListenerError(size, name);
-        }
-        __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").set(name, new Set());
+    let listeners = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
+    if (!listeners) {
+        listeners = new Set();
+        __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").set(name, listeners);
+    }
+    if (listeners.size >= __classPrivateFieldGet(this, _EvStreamManager_maxListeners, "f")) {
+        throw new EvMaxListenerError(listeners.size, name);
     }
-    __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name).add(id);
+    listeners.add(id);
 }, _EvStreamManager_unlisten = function _EvStreamManager_unlisten(name, id) {
     const isListenerExists = __classPrivateFieldGet(this, _EvStreamManager_listeners, "f").get(name);
     if (isListenerExists) {

package/dist/state.d.ts

@@ -5,7 +5,7 @@ type EvSetState<T> = (val: T) => T;
  */
 export declare class EvState<T> {
     #private;
-    constructor({ channel, initialValue, manager, key }: EvStateOptions<T>);
+    constructor({ channel, initialValue, manager, key, adapter }: EvStateOptions<T>);
     /**
      * Returns the current state value.
      */

package/dist/state.js

@@ -9,22 +9,30 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EvState_value, _EvState_channel, _EvState_manager, _EvState_key;
+var _EvState_instances, _EvState_value, _EvState_channel, _EvState_manager, _EvState_key, _EvState_adapter, _EvState_handleRemoteUpdate;
 import loadash from 'lodash';
 const { isEqual } = loadash;
 /**
  * EvState holds a reactive state and broadcasts updates to a channel using EvStreamManager.
  */
 export class EvState {
-    constructor({ channel, initialValue, manager, key }) {
+    constructor({ channel, initialValue, manager, key, adapter }) {
+        _EvState_instances.add(this);
         _EvState_value.set(this, void 0);
         _EvState_channel.set(this, void 0);
         _EvState_manager.set(this, void 0);
         _EvState_key.set(this, void 0);
+        _EvState_adapter.set(this, void 0);
         __classPrivateFieldSet(this, _EvState_value, initialValue, "f");
         __classPrivateFieldSet(this, _EvState_channel, channel, "f");
         __classPrivateFieldSet(this, _EvState_manager, manager, "f");
         __classPrivateFieldSet(this, _EvState_key, key || 'value', "f");
+        __classPrivateFieldSet(this, _EvState_adapter, adapter, "f");
+        if (__classPrivateFieldGet(this, _EvState_adapter, "f")) {
+            __classPrivateFieldGet(this, _EvState_adapter, "f").subscribe(__classPrivateFieldGet(this, _EvState_channel, "f"), (data) => {
+                __classPrivateFieldGet(this, _EvState_instances, "m", _EvState_handleRemoteUpdate).call(this, data);
+            });
+        }
     }
     /**
      * Returns the current state value.
@@ -46,7 +54,23 @@ export class EvState {
                     [__classPrivateFieldGet(this, _EvState_key, "f")]: newValue,
                 },
             });
+            if (__classPrivateFieldGet(this, _EvState_adapter, "f")) {
+                __classPrivateFieldGet(this, _EvState_adapter, "f").publish(__classPrivateFieldGet(this, _EvState_channel, "f"), { [__classPrivateFieldGet(this, _EvState_key, "f")]: newValue });
+            }
         }
     }
 }
-_EvState_value = new WeakMap(), _EvState_channel = new WeakMap(), _EvState_manager = new WeakMap(), _EvState_key = new WeakMap();
+_EvState_value = new WeakMap(), _EvState_channel = new WeakMap(), _EvState_manager = new WeakMap(), _EvState_key = new WeakMap(), _EvState_adapter = new WeakMap(), _EvState_instances = new WeakSet(), _EvState_handleRemoteUpdate = function _EvState_handleRemoteUpdate(data) {
+    if (data && typeof data === 'object' && __classPrivateFieldGet(this, _EvState_key, "f") in data) {
+        const newValue = data[__classPrivateFieldGet(this, _EvState_key, "f")];
+        if (!isEqual(newValue, __classPrivateFieldGet(this, _EvState_value, "f"))) {
+            __classPrivateFieldSet(this, _EvState_value, newValue, "f");
+            __classPrivateFieldGet(this, _EvState_manager, "f").send(__classPrivateFieldGet(this, _EvState_channel, "f"), {
+                event: __classPrivateFieldGet(this, _EvState_channel, "f"),
+                data: {
+                    [__classPrivateFieldGet(this, _EvState_key, "f")]: newValue,
+                },
+            });
+        }
+    }
+};

package/dist/stream.d.ts

@@ -26,6 +26,7 @@ export declare class Evstream {
     message(msg: EvMessage): void;
     /**
      * Sends an "end" event and closes the SSE connection.
+     * Cleans up heartbeat interval and event listeners to prevent memory leaks.
      */
     close(): void;
 }

package/dist/stream.js

@@ -18,7 +18,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Evstream_res, _Evstream_opts, _Evstream_url;
+var _Evstream_instances, _Evstream_res, _Evstream_opts, _Evstream_url, _Evstream_heartbeatInterval, _Evstream_onCloseHandler, _Evstream_clearHeartbeat, _Evstream_removeCloseListener;
 import { message } from './message.js';
 /**
  * Evstream manages a Server-Sent Events (SSE) connection.
@@ -33,9 +33,12 @@ import { message } from './message.js';
  */
 export class Evstream {
     constructor(req, res, opts) {
+        _Evstream_instances.add(this);
         _Evstream_res.set(this, void 0);
         _Evstream_opts.set(this, void 0);
         _Evstream_url.set(this, void 0);
+        _Evstream_heartbeatInterval.set(this, void 0);
+        _Evstream_onCloseHandler.set(this, void 0);
         __classPrivateFieldSet(this, _Evstream_res, res, "f");
         __classPrivateFieldSet(this, _Evstream_opts, opts, "f");
         __classPrivateFieldSet(this, _Evstream_url, new URL(req.url, `http://${req.headers.host}`), "f");
@@ -44,12 +47,13 @@ export class Evstream {
         __classPrivateFieldGet(this, _Evstream_res, "f").setHeader('Connection', 'keep-alive');
         __classPrivateFieldGet(this, _Evstream_res, "f").flushHeaders();
         if (opts === null || opts === void 0 ? void 0 : opts.heartbeat) {
-            const timeout = setInterval(() => {
+            __classPrivateFieldSet(this, _Evstream_heartbeatInterval, setInterval(() => {
                 __classPrivateFieldGet(this, _Evstream_res, "f").write(message({ event: 'heartbeat', data: '' }));
-            }, __classPrivateFieldGet(this, _Evstream_opts, "f").heartbeat);
-            __classPrivateFieldGet(this, _Evstream_res, "f").on('close', () => {
-                clearTimeout(timeout);
-            });
+            }, __classPrivateFieldGet(this, _Evstream_opts, "f").heartbeat), "f");
+            __classPrivateFieldSet(this, _Evstream_onCloseHandler, () => {
+                __classPrivateFieldGet(this, _Evstream_instances, "m", _Evstream_clearHeartbeat).call(this);
+            }, "f");
+            __classPrivateFieldGet(this, _Evstream_res, "f").on('close', __classPrivateFieldGet(this, _Evstream_onCloseHandler, "f"));
         }
     }
     /**
@@ -63,6 +67,7 @@ export class Evstream {
                 const isAuthenticated = yield __classPrivateFieldGet(this, _Evstream_opts, "f").authentication.verify(token);
                 if (typeof isAuthenticated === 'boolean') {
                     if (!isAuthenticated) {
+                        __classPrivateFieldGet(this, _Evstream_instances, "m", _Evstream_clearHeartbeat).call(this);
                         this.message({
                             data: { message: 'authentication failed' },
                             event: 'error',
@@ -89,8 +94,11 @@ export class Evstream {
     }
     /**
      * Sends an "end" event and closes the SSE connection.
+     * Cleans up heartbeat interval and event listeners to prevent memory leaks.
      */
     close() {
+        __classPrivateFieldGet(this, _Evstream_instances, "m", _Evstream_clearHeartbeat).call(this);
+        __classPrivateFieldGet(this, _Evstream_instances, "m", _Evstream_removeCloseListener).call(this);
         this.message({
             event: 'end',
             data: '',
@@ -98,4 +106,14 @@ export class Evstream {
         __classPrivateFieldGet(this, _Evstream_res, "f").end();
     }
 }
-_Evstream_res = new WeakMap(), _Evstream_opts = new WeakMap(), _Evstream_url = new WeakMap();
+_Evstream_res = new WeakMap(), _Evstream_opts = new WeakMap(), _Evstream_url = new WeakMap(), _Evstream_heartbeatInterval = new WeakMap(), _Evstream_onCloseHandler = new WeakMap(), _Evstream_instances = new WeakSet(), _Evstream_clearHeartbeat = function _Evstream_clearHeartbeat() {
+    if (__classPrivateFieldGet(this, _Evstream_heartbeatInterval, "f")) {
+        clearInterval(__classPrivateFieldGet(this, _Evstream_heartbeatInterval, "f"));
+        __classPrivateFieldSet(this, _Evstream_heartbeatInterval, undefined, "f");
+    }
+}, _Evstream_removeCloseListener = function _Evstream_removeCloseListener() {
+    if (__classPrivateFieldGet(this, _Evstream_onCloseHandler, "f")) {
+        __classPrivateFieldGet(this, _Evstream_res, "f").removeListener('close', __classPrivateFieldGet(this, _Evstream_onCloseHandler, "f"));
+        __classPrivateFieldSet(this, _Evstream_onCloseHandler, undefined, "f");
+    }
+};

package/dist/types.d.ts

@@ -19,10 +19,16 @@ export interface EvManagerOptions {
     maxConnection?: number;
     maxListeners?: number;
 }
+export interface EvStateAdapter {
+    publish(channel: string, message: any): Promise<void>;
+    subscribe(channel: string, onMessage: (message: any) => void): Promise<void>;
+    unsubscribe(channel: string): Promise<void>;
+}
 export interface EvStateOptions<T> {
     initialValue: T;
     channel: string;
     manager: EvStreamManager;
     key?: string;
+    adapter?: EvStateAdapter;
 }
 export type EvOnClose = (channels: string[]) => Promise<void>;

package/package.json

@@ -1,47 +1,60 @@
-{
-  "name": "evstream",
-  "version": "1.0.0",
-  "description": "A simple and easy to implement server sent event library for express.js",
-  "keywords": [
-    "sse",
-    "server-sent-events",
-    "event-source"
-  ],
-  "homepage": "https://github.com/kisshan13/evstream#readme",
-  "bugs": {
-    "url": "https://github.com/kisshan13/evstream/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/kisshan13/evstream.git"
-  },
-  "license": "MIT",
-  "author": "Kishan Sharma",
-  "type": "module",
-  "main": "./dist/index.js",
-  "scripts": {
-    "dev": "tsc --watch",
-    "clean": "rimraf ./dist",
-    "build": "rimraf ./dist && tsc --incremental false"
-  },
-  "engines": {
-    "node": ">=17.8.0"
-  },
-  "devDependencies": {
-    "@types/lodash": "^4.17.19",
-    "@types/node": "^24.0.7",
-    "@typescript-eslint/eslint-plugin": "^8.35.0",
-    "@typescript-eslint/parser": "^8.35.0",
-    "eslint": "^9.30.0",
-    "eslint-config-prettier": "^10.1.5",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-prettier": "^5.5.1",
-    "eslint-plugin-simple-import-sort": "^12.1.1",
-    "prettier": "^3.6.2",
-    "rimraf": "^6.0.1",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "lodash": "^4.17.21"
-  }
-}
+{
+  "name": "evstream",
+  "version": "1.0.1",
+  "description": "A simple and easy to implement server sent event library for express.js",
+  "keywords": [
+    "sse",
+    "server-sent-events",
+    "event-source"
+  ],
+  "homepage": "https://github.com/kisshan13/evstream#readme",
+  "bugs": {
+    "url": "https://github.com/kisshan13/evstream/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kisshan13/evstream.git"
+  },
+  "license": "MIT",
+  "author": "Kishan Sharma",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./adapter/redis": {
+      "import": "./dist/adapters/redis.js",
+      "types": "./dist/adapters/redis.d.ts"
+    }
+  },
+  "scripts": {
+    "dev": "tsc --watch",
+    "clean": "rimraf ./dist",
+    "build": "rimraf ./dist && tsc --incremental false"
+  },
+  "engines": {
+    "node": ">=17.8.0"
+  },
+  "devDependencies": {
+    "@types/ioredis": "^5.0.0",
+    "@types/lodash": "^4.17.19",
+    "@types/node": "^24.0.7",
+    "@typescript-eslint/eslint-plugin": "^8.35.0",
+    "@typescript-eslint/parser": "^8.35.0",
+    "eslint": "^9.30.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-prettier": "^5.5.1",
+    "eslint-plugin-simple-import-sort": "^12.1.1",
+    "ioredis": "^5.5.0",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21"
+  }
+}

package/readme.md

@@ -188,7 +188,35 @@ Reactive states are data which you can shared across multiple clients within the
 
   **See** `channel` **and the value pass to the** `listen()` **must be the same**
 
-### 5. Sending data to a channel
+### 5. Distributed Reactive State (Redis)
+
+When running multiple server instances, you can synchronize `EvState` across them using the built-in Redis adapter.
+
+1.  **Install the peer dependency:**
+    ```bash
+    npm install ioredis
+    ```
+
+2.  **Use the adapter:**
+
+    ```javascript
+    import { EvState, EvStreamManager } from "evstream"
+    import { EvRedisAdapter } from "evstream/adapter/redis"
+
+    const manager = new EvStreamManager();
+    const redisAdapter = new EvRedisAdapter("redis://localhost:6379");
+    
+    const userCount = new EvState({ 
+        channel: "user-count", 
+        initialValue: 0, 
+        manager: manager,
+        adapter: redisAdapter 
+    })
+    ```
+    
+    Updates to `userCount` will now be synchronized across all instances connected to the same Redis.
+
+### 6. Sending data to a channel
 
 To send data to a channel you can use `send()` method from `EvStreamManager` class.
 
@@ -202,7 +230,7 @@ const manager = new EvStreamManager();
 manager.send("<channel-name>", {event: "custom-event", data: {"foo": "bar"}})
 ```
 
-### 6. Listening for channels
+### 7. Listening for channels
 
 To listen for data from any channel you can use `listen()` function from `Evstream` class.
 
@@ -368,7 +396,8 @@ new EvState<T>({
   channel,
   initialValue,
   manager,
-  key
+  key,
+  adapter
 }: EvStateOptions<T>)
 ```
 
@@ -378,6 +407,7 @@ new EvState<T>({
 * `initialValue`: `T` – The initial state value.
 * `manager`: `EvStreamManager` – The SSE manager instance used for broadcasting.
 * `key` *(optional)*: `string` – The key used in the broadcasted data object (default: `'value'`).
+* `adapter` *(optional)*: `EvStateAdapter` – Adapter for distributed state synchronization (e.g. `EvRedisAdapter`).
 
 ---
 
@@ -437,13 +467,31 @@ new EvMaxConnectionsError(connections: number)
 ```ts
 const manager = new EvStreamManager({ maxConnection: 100 });
 if (tooManyConnections) {
+```
+
   throw new EvMaxConnectionsError(100)
 }
 ```
 
 ---
-
-## `EvMaxListenerError`
+ 
+ ## `EvRedisAdapter`
+ 
+ Adapter for synchronizing `EvState` across multiple instances using Redis Pub/Sub.
+ 
+ ### Constructor
+ 
+ ```ts
+ new EvRedisAdapter(options?: RedisOptions | string)
+ ```
+ 
+ #### Parameters:
+ 
+ * `options`: `RedisOptions | string` – Configuration options for the Redis client (from `ioredis`), or a Redis connection URL.
+ 
+ ---
+ 
+ ## `EvMaxListenerError`
 
 Represents an error thrown when the number of listeners on a given channel exceeds the allowed `maxListeners` limit (default: `5000`).
 
@@ -573,6 +621,7 @@ Options for initializing a reactive state with `EvState`.
 - `channel`: Channel name for broadcasting
 - `manager`: Instance of `EvStreamManager`
 - `key` *(optional)*: Key for wrapping state in the broadcast (default: `'value'`)
+- `adapter` *(optional)*: Instance of `EvStateAdapter` (e.g., `EvRedisAdapter`) for distributed synchronization.
 
 ---