evstream 1.0.2 → 1.0.4

package/.me/dump.ts

@@ -0,0 +1,102 @@
+import { EvState, EvStreamManager } from 'evstream'
+import { EvRedisAdapter } from 'evstream/adapter/redis'
+import type Redis from 'ioredis'
+
+type SharedStateMessage =
+    | { action: 'create'; key: string; initialValue: any }
+    | { action: 'remove'; key: string }
+
+export class EvCustomSharedState {
+    private states = new Map<string, EvState>()
+    private redis: Redis
+    private pub: Redis
+    private manager: EvStreamManager
+    private adapter: EvRedisAdapter
+    private controlChannel = 'ev:shared-state'
+
+    constructor(options: {
+        redis: Redis
+        publisher?: Redis
+        manager: EvStreamManager
+        adapter: EvRedisAdapter
+    }) {
+        this.redis = options.redis
+        this.pub = options.publisher ?? options.redis
+        this.manager = options.manager
+        this.adapter = options.adapter
+
+        this.init()
+    }
+
+    private async init() {
+        await this.redis.subscribe(this.controlChannel)
+
+        this.redis.on('message', (_, raw) => {
+            try {
+                const msg = JSON.parse(raw) as SharedStateMessage
+                this.handleMessage(msg)
+            } catch {
+                /* ignore malformed messages */
+            }
+        })
+    }
+
+    private handleMessage(msg: SharedStateMessage) {
+        if (msg.action === 'create') {
+            this.createLocalState(msg.key, msg.initialValue)
+        }
+
+        if (msg.action === 'remove') {
+            this.removeLocalState(msg.key)
+        }
+    }
+
+    private createLocalState(key: string, initialValue: any) {
+        if (this.states.has(key)) return
+
+        const state = new EvState({
+            channel: key,
+            initialValue,
+            manager: this.manager,
+            adapter: this.adapter,
+        })
+
+        this.states.set(key, state)
+    }
+
+    private removeLocalState(key: string) {
+        const state = this.states.get(key)
+        if (!state) return
+
+        // EvState has no destroy API, so we simply stop tracking it
+        this.states.delete(key)
+    }
+
+    /* ================= PUBLIC API ================= */
+
+    async create(key: string, initialValue: any) {
+        await this.pub.publish(
+            this.controlChannel,
+            JSON.stringify({ action: 'create', key, initialValue })
+        )
+    }
+
+    async remove(key: string) {
+        await this.pub.publish(
+            this.controlChannel,
+            JSON.stringify({ action: 'remove', key })
+        )
+    }
+
+    get(key: string): EvState | undefined {
+        return this.states.get(key)
+    }
+
+    has(key: string): boolean {
+        return this.states.has(key)
+    }
+
+    keys(): string[] {
+        return [...this.states.keys()]
+    }
+}

package/dist/adapters/pub-sub.d.ts

@@ -0,0 +1,40 @@
+import { RedisOptions } from 'ioredis';
+/**
+ * Configuration options for EvRedisPubSub
+ */
+interface EvRedisPubSubOptions<T> {
+    /** Redis Pub/Sub channel name */
+    subject: string;
+    /** Redis connection options */
+    options: RedisOptions;
+    /** Optional initial message handler */
+    onMessage?: (message: T) => void;
+}
+/**
+ * Redis-based Pub/Sub helper for cross-process communication.
+ *
+ * - Uses separate publisher and subscriber connections
+ * - Prevents self-message delivery using instance UID
+ * - Typed message payload via generics
+ */
+export declare class EvRedisPubSub<T = unknown> {
+    #private;
+    constructor({ options, subject, onMessage }: EvRedisPubSubOptions<T>);
+    /**
+     * Initializes Redis subscriptions and listeners.
+     */
+    private init;
+    /**
+     * Publishes a message to the Redis channel.
+     */
+    send(msg: T): Promise<void>;
+    /**
+     * Registers or replaces the message handler.
+     */
+    onMessage(callback: (msg: T) => void): void;
+    /**
+     * Gracefully closes Redis connections.
+     */
+    close(): Promise<void>;
+}
+export {};

package/dist/adapters/pub-sub.js

@@ -0,0 +1,91 @@
+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 _EvRedisPubSub_subject, _EvRedisPubSub_pub, _EvRedisPubSub_sub, _EvRedisPubSub_instanceId, _EvRedisPubSub_onMessage;
+import Redis from 'ioredis';
+import { uid } from '../utils.js';
+/**
+ * Redis-based Pub/Sub helper for cross-process communication.
+ *
+ * - Uses separate publisher and subscriber connections
+ * - Prevents self-message delivery using instance UID
+ * - Typed message payload via generics
+ */
+export class EvRedisPubSub {
+    constructor({ options, subject, onMessage }) {
+        _EvRedisPubSub_subject.set(this, void 0);
+        _EvRedisPubSub_pub.set(this, void 0);
+        _EvRedisPubSub_sub.set(this, void 0);
+        _EvRedisPubSub_instanceId.set(this, void 0);
+        _EvRedisPubSub_onMessage.set(this, void 0);
+        __classPrivateFieldSet(this, _EvRedisPubSub_pub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_sub, new Redis(options), "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_subject, subject, "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, onMessage, "f");
+        __classPrivateFieldSet(this, _EvRedisPubSub_instanceId, uid({ prefix: subject, counter: Math.random() }), "f");
+        this.init();
+    }
+    /**
+     * Initializes Redis subscriptions and listeners.
+     */
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").on('error', () => { });
+            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('error', () => { });
+            yield __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").subscribe(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"));
+            __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").on('message', (_, raw) => {
+                var _a;
+                try {
+                    const data = JSON.parse(raw);
+                    // Ignore messages from the same instance
+                    if ((data === null || data === void 0 ? void 0 : data.uid) !== __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f")) {
+                        (_a = __classPrivateFieldGet(this, _EvRedisPubSub_onMessage, "f")) === null || _a === void 0 ? void 0 : _a.call(this, data.msg);
+                    }
+                }
+                catch (_b) {
+                    // Ignore malformed payloads
+                }
+            });
+        });
+    }
+    /**
+     * Publishes a message to the Redis channel.
+     */
+    send(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").publish(__classPrivateFieldGet(this, _EvRedisPubSub_subject, "f"), JSON.stringify({ uid: __classPrivateFieldGet(this, _EvRedisPubSub_instanceId, "f"), msg }));
+        });
+    }
+    /**
+     * Registers or replaces the message handler.
+     */
+    onMessage(callback) {
+        __classPrivateFieldSet(this, _EvRedisPubSub_onMessage, callback, "f");
+    }
+    /**
+     * Gracefully closes Redis connections.
+     */
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all([__classPrivateFieldGet(this, _EvRedisPubSub_pub, "f").quit(), __classPrivateFieldGet(this, _EvRedisPubSub_sub, "f").quit()]);
+        });
+    }
+}
+_EvRedisPubSub_subject = new WeakMap(), _EvRedisPubSub_pub = new WeakMap(), _EvRedisPubSub_sub = new WeakMap(), _EvRedisPubSub_instanceId = new WeakMap(), _EvRedisPubSub_onMessage = new WeakMap();

package/dist/adapters/redis.d.ts

@@ -1,10 +1,55 @@
 import { RedisOptions } from 'ioredis';
+import { EvRedisPubSub } from './pub-sub.js';
 import { EvStateAdapter } from '../types.js';
-export declare class EvRedisAdapter implements EvStateAdapter {
+/**
+ * Redis-based implementation of {@link EvStateAdapter}.
+ *
+ * This adapter enables distributed state updates using Redis Pub/Sub.
+ * It supports:
+ * - Channel-based subscriptions
+ * - Multiple listeners per channel
+ * - Self-message filtering via instance ID
+ *
+ * Designed to be used by EvState / EvStateManager for
+ * cross-process state synchronization.
+ */
+declare class EvRedisAdapter implements EvStateAdapter {
     #private;
+    /**
+     * Creates a new Redis state adapter.
+     *
+     * @param options - Optional Redis connection options
+     */
     constructor(options?: RedisOptions);
+    /**
+     * Publishes a message to a Redis channel.
+     *
+     * The payload is wrapped with the instance ID to
+     * prevent self-delivery.
+     *
+     * @param channel - Redis channel name
+     * @param message - Message payload
+     */
     publish(channel: string, message: any): Promise<void>;
+    /**
+     * Subscribes to a Redis channel.
+     *
+     * Multiple listeners can be registered per channel.
+     * The Redis subscription is created only once per channel.
+     *
+     * @param channel - Redis channel name
+     * @param onMessage - Callback invoked on incoming messages
+     */
     subscribe(channel: string, onMessage: (message: any) => void): Promise<void>;
+    /**
+     * Unsubscribes from a Redis channel and removes all listeners.
+     *
+     * @param channel - Redis channel name
+     */
     unsubscribe(channel: string): Promise<void>;
+    /**
+     * Gracefully closes Redis connections.
+     */
     quit(): void;
 }
+export { EvRedisPubSub, EvRedisAdapter };

package/dist/adapters/redis.js

@@ -18,35 +18,85 @@ 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 _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners;
+var _EvRedisAdapter_pub, _EvRedisAdapter_sub, _EvRedisAdapter_listeners, _EvRedisAdapter_instanceId;
 import Redis from 'ioredis';
-export class EvRedisAdapter {
+import { EvRedisPubSub } from './pub-sub.js';
+import { uid } from '../utils.js';
+/**
+ * Redis-based implementation of {@link EvStateAdapter}.
+ *
+ * This adapter enables distributed state updates using Redis Pub/Sub.
+ * It supports:
+ * - Channel-based subscriptions
+ * - Multiple listeners per channel
+ * - Self-message filtering via instance ID
+ *
+ * Designed to be used by EvState / EvStateManager for
+ * cross-process state synchronization.
+ */
+class EvRedisAdapter {
+    /**
+     * Creates a new Redis state adapter.
+     *
+     * @param options - Optional Redis connection options
+     */
     constructor(options) {
+        /** Publisher Redis client */
         _EvRedisAdapter_pub.set(this, void 0);
+        /** Subscriber Redis client */
         _EvRedisAdapter_sub.set(this, void 0);
+        /**
+         * Channel → listeners mapping.
+         * Each channel may have multiple local handlers.
+         */
         _EvRedisAdapter_listeners.set(this, void 0);
+        /** Unique identifier for this adapter instance */
+        _EvRedisAdapter_instanceId.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");
+        __classPrivateFieldSet(this, _EvRedisAdapter_instanceId, uid({ counter: Math.ceil(Math.random() * 100) }), "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));
+            if (!handlers)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(message);
             }
+            catch (_a) {
+                // Ignore malformed payloads
+                return;
+            }
+            // Ignore messages published by this instance
+            if ((parsed === null || parsed === void 0 ? void 0 : parsed.id) === __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"))
+                return;
+            handlers.forEach((handler) => handler(parsed === null || parsed === void 0 ? void 0 : parsed.message));
         });
     }
+    /**
+     * Publishes a message to a Redis channel.
+     *
+     * The payload is wrapped with the instance ID to
+     * prevent self-delivery.
+     *
+     * @param channel - Redis channel name
+     * @param message - Message payload
+     */
     publish(channel, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify(message));
+            yield __classPrivateFieldGet(this, _EvRedisAdapter_pub, "f").publish(channel, JSON.stringify({ id: __classPrivateFieldGet(this, _EvRedisAdapter_instanceId, "f"), message }));
         });
     }
+    /**
+     * Subscribes to a Redis channel.
+     *
+     * Multiple listeners can be registered per channel.
+     * The Redis subscription is created only once per channel.
+     *
+     * @param channel - Redis channel name
+     * @param onMessage - Callback invoked on incoming messages
+     */
     subscribe(channel, onMessage) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!__classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").has(channel)) {
@@ -56,15 +106,24 @@ export class EvRedisAdapter {
             __classPrivateFieldGet(this, _EvRedisAdapter_listeners, "f").get(channel).add(onMessage);
         });
     }
+    /**
+     * Unsubscribes from a Redis channel and removes all listeners.
+     *
+     * @param channel - Redis channel name
+     */
     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);
         });
     }
+    /**
+     * Gracefully closes Redis connections.
+     */
     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();
+_EvRedisAdapter_pub = new WeakMap(), _EvRedisAdapter_sub = new WeakMap(), _EvRedisAdapter_listeners = new WeakMap(), _EvRedisAdapter_instanceId = new WeakMap();
+export { EvRedisPubSub, EvRedisAdapter };

package/dist/extensions/state-manager.d.ts

@@ -0,0 +1,95 @@
+import type { EvStreamManager } from '../manager.js';
+import type { EvRedisAdapter } from '../adapters/redis.js';
+import type { EvRedisPubSub } from '../adapters/pub-sub.js';
+import { EvState } from '../state.js';
+/**
+ * Options for creating an {@link EvStateManager}.
+ */
+interface EvStateManagerOptions {
+    /**
+     * Stream manager responsible for managing client connections
+     * and broadcasting state updates.
+     */
+    manager: EvStreamManager;
+    /**
+     * Optional distributed state adapter (e.g. Redis).
+     * Enables cross-process state propagation.
+     */
+    adapter?: EvRedisAdapter;
+    /**
+     * Optional Pub/Sub instance used to synchronize
+     * state creation and removal across instances.
+     */
+    pubsub?: EvRedisPubSub;
+}
+/**
+ * Manages a collection of named {@link EvState} instances.
+ *
+ * Responsibilities:
+ * - Create and cache state objects locally
+ * - Synchronize state lifecycle (create/remove) across processes
+ * - Bridge EvState with stream manager and adapters
+ *
+ * Internally, all state keys are converted to strings to remain
+ * Redis-safe and transport-friendly.
+ *
+ * @typeParam S - Mapping of state keys to their value types
+ */
+export declare class EvStateManager<S extends Record<string, any>> {
+    #private;
+    /**
+     * Creates a new state manager.
+     *
+     * @param options - Initialization options
+     */
+    constructor({ manager, adapter, pubsub }: EvStateManagerOptions);
+    /**
+     * Creates a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     * @param initialValue - Initial state value
+     */
+    private createLocalState;
+    /**
+     * Removes a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     */
+    private removeLocalState;
+    /**
+     * Creates or returns an existing state.
+     *
+     * If Pub/Sub is enabled, the creation is broadcast
+     * to other instances.
+     *
+     * @param key - State key
+     * @param initialValue - Initial state value
+     */
+    createState<K extends keyof S>(key: K, initialValue: S[K]): EvState<S[K]>;
+    /**
+     * Retrieves an existing state.
+     *
+     * @param key - State key
+     */
+    getState<K extends keyof S>(key: K): EvState<S[K]> | undefined;
+    /**
+     * Checks whether a state exists.
+     *
+     * @param key - State key
+     */
+    hasState<K extends keyof S>(key: K): boolean;
+    /**
+     * Removes a state locally and propagates the removal
+     * to other instances via Pub/Sub.
+     *
+     * @param key - State key
+     */
+    removeState<K extends keyof S>(key: K): void;
+    /**
+     * Handles incoming Pub/Sub lifecycle events.
+     *
+     * @param msg - Pub/Sub message payload
+     */
+    private pubSubCallback;
+}
+export {};

package/dist/extensions/state-manager.js

@@ -0,0 +1,155 @@
+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 _EvStateManager_states, _EvStateManager_manager, _EvStateManager_adapter, _EvStateManager_pubsub;
+import { EvState } from '../state.js';
+/**
+ * Manages a collection of named {@link EvState} instances.
+ *
+ * Responsibilities:
+ * - Create and cache state objects locally
+ * - Synchronize state lifecycle (create/remove) across processes
+ * - Bridge EvState with stream manager and adapters
+ *
+ * Internally, all state keys are converted to strings to remain
+ * Redis-safe and transport-friendly.
+ *
+ * @typeParam S - Mapping of state keys to their value types
+ */
+export class EvStateManager {
+    /**
+     * Creates a new state manager.
+     *
+     * @param options - Initialization options
+     */
+    constructor({ manager, adapter, pubsub }) {
+        /**
+         * Internal state registry.
+         * Keyed by string channel name.
+         */
+        _EvStateManager_states.set(this, new Map()
+        /** Stream manager used by all states */
+        );
+        /** Stream manager used by all states */
+        _EvStateManager_manager.set(this, void 0);
+        /** Optional distributed adapter */
+        _EvStateManager_adapter.set(this, void 0);
+        /** Optional Pub/Sub synchronizer */
+        _EvStateManager_pubsub.set(this, void 0);
+        __classPrivateFieldSet(this, _EvStateManager_manager, manager, "f");
+        __classPrivateFieldSet(this, _EvStateManager_adapter, adapter, "f");
+        __classPrivateFieldSet(this, _EvStateManager_pubsub, pubsub, "f");
+        this.pubSubCallback = this.pubSubCallback.bind(this);
+        if (__classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) {
+            __classPrivateFieldGet(this, _EvStateManager_pubsub, "f").onMessage(this.pubSubCallback);
+        }
+    }
+    /**
+     * Creates a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     * @param initialValue - Initial state value
+     */
+    createLocalState(channel, initialValue) {
+        const state = new EvState({
+            channel,
+            initialValue,
+            manager: __classPrivateFieldGet(this, _EvStateManager_manager, "f"),
+            adapter: __classPrivateFieldGet(this, _EvStateManager_adapter, "f"),
+        });
+        __classPrivateFieldGet(this, _EvStateManager_states, "f").set(channel, state);
+        return state;
+    }
+    /**
+     * Removes a state locally without emitting Pub/Sub events.
+     *
+     * @param channel - State channel name
+     */
+    removeLocalState(channel) {
+        __classPrivateFieldGet(this, _EvStateManager_states, "f").delete(channel);
+    }
+    /**
+     * Creates or returns an existing state.
+     *
+     * If Pub/Sub is enabled, the creation is broadcast
+     * to other instances.
+     *
+     * @param key - State key
+     * @param initialValue - Initial state value
+     */
+    createState(key, initialValue) {
+        var _a;
+        const channel = String(key);
+        if (__classPrivateFieldGet(this, _EvStateManager_states, "f").has(channel)) {
+            return __classPrivateFieldGet(this, _EvStateManager_states, "f").get(channel);
+        }
+        const state = this.createLocalState(channel, initialValue);
+        (_a = __classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) === null || _a === void 0 ? void 0 : _a.send({
+            type: 'create',
+            channel,
+            initialValue,
+        });
+        return state;
+    }
+    /**
+     * Retrieves an existing state.
+     *
+     * @param key - State key
+     */
+    getState(key) {
+        return __classPrivateFieldGet(this, _EvStateManager_states, "f").get(String(key));
+    }
+    /**
+     * Checks whether a state exists.
+     *
+     * @param key - State key
+     */
+    hasState(key) {
+        return __classPrivateFieldGet(this, _EvStateManager_states, "f").has(String(key));
+    }
+    /**
+     * Removes a state locally and propagates the removal
+     * to other instances via Pub/Sub.
+     *
+     * @param key - State key
+     */
+    removeState(key) {
+        var _a;
+        const channel = String(key);
+        this.removeLocalState(channel);
+        (_a = __classPrivateFieldGet(this, _EvStateManager_pubsub, "f")) === null || _a === void 0 ? void 0 : _a.send({
+            type: 'remove',
+            channel,
+        });
+    }
+    /**
+     * Handles incoming Pub/Sub lifecycle events.
+     *
+     * @param msg - Pub/Sub message payload
+     */
+    pubSubCallback(msg) {
+        if (!msg || typeof msg.channel !== 'string')
+            return;
+        switch (msg.type) {
+            case 'create': {
+                if (!__classPrivateFieldGet(this, _EvStateManager_states, "f").has(msg.channel)) {
+                    this.createLocalState(msg.channel, msg.initialValue);
+                }
+                break;
+            }
+            case 'remove': {
+                this.removeLocalState(msg.channel);
+                break;
+            }
+        }
+    }
+}
+_EvStateManager_states = new WeakMap(), _EvStateManager_manager = new WeakMap(), _EvStateManager_adapter = new WeakMap(), _EvStateManager_pubsub = new WeakMap();