redux-cluster 1.9.2 → 2.0.0

package/dist/cjs/core/backup.d.ts

@@ -0,0 +1,10 @@
+import { BackupSettings, ReduxClusterStore } from "../types";
+export declare class BackupManager<S = any> {
+    private store;
+    private settings;
+    private createBackupInstance?;
+    constructor(store: ReduxClusterStore<S>, settings: BackupSettings);
+    initialize(): Promise<boolean>;
+    private loadBackup;
+}
+//# sourceMappingURL=backup.d.ts.map

package/dist/cjs/core/backup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.d.ts","sourceRoot":"","sources":["../../../src/core/backup.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAe,MAAM,UAAU,CAAC;AAG1E,qBAAa,aAAa,CAAC,CAAC,GAAG,GAAG;IAI9B,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,QAAQ;IAJlB,OAAO,CAAC,oBAAoB,CAAC,CAAoB;gBAGvC,KAAK,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC3B,QAAQ,EAAE,cAAc;IAGrB,UAAU,IAAI,OAAO,CAAC,OAAO,CAAC;YAiB7B,UAAU;CA+CzB"}

package/dist/cjs/core/backup.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupManager = void 0;
+const fs = __importStar(require("fs"));
+const types_1 = require("../types");
+const crypto_1 = require("../utils/crypto");
+class BackupManager {
+    constructor(store, settings) {
+        this.store = store;
+        this.settings = settings;
+    }
+    async initialize() {
+        try {
+            await this.loadBackup();
+            this.createBackupInstance = new BackupInstance(this.store, this.settings);
+            return true;
+        }
+        catch (err) {
+            if (err.message.toLowerCase().includes("no such file or directory")) {
+                this.createBackupInstance = new BackupInstance(this.store, this.settings);
+                return true;
+            }
+            throw err;
+        }
+    }
+    async loadBackup() {
+        return new Promise((resolve, reject) => {
+            fs.readFile(this.settings.path, (err, data) => {
+                if (err) {
+                    reject(new Error(`ReduxCluster.backup load error: ${err.message}`));
+                    return;
+                }
+                try {
+                    let content = data.toString();
+                    // Decrypt if key is provided
+                    if (this.settings.key) {
+                        content = (0, crypto_1.decrypter)(content, this.settings.key);
+                    }
+                    const state = JSON.parse(content);
+                    // Restore state using internal method
+                    if ("_internalSync" in this.store &&
+                        typeof this.store._internalSync === "function") {
+                        this.store._internalSync(state);
+                    }
+                    else {
+                        // Fallback: use dispatchNEW if available, otherwise skip restore
+                        if ("dispatchNEW" in this.store &&
+                            typeof this.store.dispatchNEW === "function") {
+                            this.store.dispatchNEW({
+                                type: types_1.MessageType.SYNC,
+                                payload: state,
+                                _internal: true,
+                            });
+                        }
+                    }
+                    setTimeout(() => resolve(), 500);
+                }
+                catch (parseErr) {
+                    reject(new Error(`ReduxCluster.backup decoding error: ${parseErr.message}`));
+                }
+            });
+        });
+    }
+}
+exports.BackupManager = BackupManager;
+class BackupInstance {
+    constructor(store, settings) {
+        this.store = store;
+        this.settings = settings;
+        this.count = 0;
+        this.allowed = true;
+        this.unsubscribe = null;
+        this.unsubscribe = this.store.subscribe(() => {
+            this.handleStateChange();
+        });
+    }
+    handleStateChange() {
+        if (typeof this.settings.timeout === "number") {
+            // Priority setting - timeout based backup
+            if (this.allowed) {
+                this.allowed = false;
+                setTimeout(() => {
+                    this.write(true);
+                }, this.settings.timeout * 1000);
+            }
+        }
+        else if (typeof this.settings.count === "number") {
+            // Count based backup
+            this.count++;
+            if (this.count >= this.settings.count) {
+                this.count = 0;
+                this.write();
+            }
+        }
+    }
+    write(restart = false, callback) {
+        if (this.allowed || restart) {
+            try {
+                let content = JSON.stringify(this.store.getState());
+                // Encrypt if key is provided
+                if (this.settings.key) {
+                    content = (0, crypto_1.encrypter)(content, this.settings.key);
+                }
+                this.writeToFile(content, callback);
+            }
+            catch (err) {
+                this.store.stderr(`ReduxCluster.backup write error: ${err.message}`);
+                this.allowed = false;
+                setTimeout(() => this.write(true, callback), 1000);
+            }
+        }
+    }
+    writeToFile(content, callback) {
+        try {
+            fs.writeFileSync(this.settings.path, content);
+            this.allowed = true;
+            if (callback) {
+                callback(true);
+            }
+        }
+        catch (err) {
+            this.store.stderr(`ReduxCluster.backup write error: ${err.message}`);
+            this.allowed = false;
+            setTimeout(() => this.write(true, callback), 1000);
+        }
+    }
+    dispose() {
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+}

package/dist/cjs/core/redux-cluster.d.ts

@@ -0,0 +1,47 @@
+import { Store, Reducer, Action } from "redux";
+import { ReduxClusterStore, SyncMode, Role, ClusterMessage, ServerSettings, ClientSettings, BackupSettings, ErrorHandler, ReduxClusterConfig } from "../types";
+import { ClusterServer } from "../network/server";
+import { ClusterClient } from "../network/client";
+export declare class ReduxCluster<S = any, A extends Action = Action> implements ReduxClusterStore<S, A> {
+    readonly dispatch: Store<S, A>["dispatch"];
+    readonly getState: Store<S, A>["getState"];
+    readonly subscribe: Store<S, A>["subscribe"];
+    readonly replaceReducer: Store<S, A>["replaceReducer"];
+    readonly [Symbol.observable]: Store<S, A>[typeof Symbol.observable];
+    readonly RCHash: string;
+    readonly version: string;
+    readonly homepage: string;
+    readonly role: Role[];
+    connected: boolean;
+    mode: SyncMode;
+    resync: number;
+    stderr: ErrorHandler;
+    readonly config: ReduxClusterConfig;
+    private readonly altReducer;
+    private readonly defaultState;
+    private readonly store;
+    private readonly allsock;
+    private counter?;
+    private dispatchNEW?;
+    private unsubscribe?;
+    private classRegistry;
+    constructor(reducer: Reducer<S, A>, config?: ReduxClusterConfig);
+    private internalSync;
+    _internalSync(payload: S): void;
+    private createNewReducer;
+    private updateCounter;
+    private sendActionsToNodes;
+    private initializeClusterRole;
+    private initializeMaster;
+    private initializeWorker;
+    private handleMasterMessage;
+    private handleWorkerMessage;
+    sendtoall(message?: ClusterMessage): void;
+    sendtoallsock(message?: ClusterMessage): void;
+    createServer(settings?: ServerSettings): ClusterServer;
+    createClient(settings?: ClientSettings): ClusterClient;
+    backup(settings: BackupSettings): Promise<boolean>;
+    registerClass(name: string, classConstructor: any): void;
+    getRegisteredClasses(): string[];
+}
+//# sourceMappingURL=redux-cluster.d.ts.map

package/dist/cjs/core/redux-cluster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redux-cluster.d.ts","sourceRoot":"","sources":["../../../src/core/redux-cluster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AAW5D,OAAO,EACL,iBAAiB,EACjB,QAAQ,EACR,IAAI,EACJ,cAAc,EAEd,cAAc,EACd,cAAc,EACd,cAAc,EACd,YAAY,EACZ,kBAAkB,EAEnB,MAAM,UAAU,CAAC;AAClB,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAMlD,qBAAa,YAAY,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAC1D,YAAW,iBAAiB,CAAC,CAAC,EAAE,CAAC,CAAC;IAGlC,SAAgB,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClD,SAAgB,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;IAClD,SAAgB,SAAS,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;IACpD,SAAgB,cAAc,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC;IAC9D,SAAgB,CAAC,MAAM,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC;IAG3E,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,OAAO,EAAE,MAAM,CAAC;IAChC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,IAAI,EAAE,IAAI,EAAE,CAAM;IAC3B,SAAS,UAAS;IAClB,IAAI,EAAE,QAAQ,CAAY;IAC1B,MAAM,SAAQ;IACd,MAAM,EAAE,YAAY,CAAiB;IAC5C,SAAgB,MAAM,EAAE,kBAAkB,CAAC;IAE3C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAgB;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAI;IACjC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA2B;IACnD,OAAO,CAAC,OAAO,CAAC,CAAS;IACzB,OAAO,CAAC,WAAW,CAAC,CAA0B;IAC9C,OAAO,CAAC,WAAW,CAAC,CAAa;IACjC,OAAO,CAAC,aAAa,CAAyB;gBAElC,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,GAAE,kBAAuB;IA4EnE,OAAO,CAAC,YAAY;IASb,aAAa,CAAC,OAAO,EAAE,CAAC,GAAG,IAAI;IAItC,OAAO,CAAC,gBAAgB;IA2BxB,OAAO,CAAC,aAAa;IAkBrB,OAAO,CAAC,kBAAkB;IA0B1B,OAAO,CAAC,qBAAqB;IAU7B,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,mBAAmB;IAwD3B,OAAO,CAAC,mBAAmB;IAoCpB,SAAS,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IA6BzC,aAAa,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI;IAW7C,YAAY,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa;IAetD,YAAY,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,aAAa;IAetD,MAAM,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;IAKlD,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,GAAG,IAAI;IASxD,oBAAoB,IAAI,MAAM,EAAE;CAMxC"}

package/dist/cjs/core/redux-cluster.js

@@ -0,0 +1,367 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReduxCluster = void 0;
+const redux_1 = require("redux");
+const cluster_1 = __importDefault(require("cluster"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const crypto_1 = require("../utils/crypto");
+const types_1 = require("../types");
+const server_1 = require("../network/server");
+const client_1 = require("../network/client");
+const backup_1 = require("./backup");
+// Global reducers registry to prevent name conflicts
+const reducers = {};
+class ReduxCluster {
+    constructor(reducer, config = {}) {
+        this.role = [];
+        this.connected = false;
+        this.mode = "action";
+        this.resync = 1000;
+        this.stderr = console.error;
+        this.allsock = {};
+        this.classRegistry = (0, crypto_1.createClassRegistry)();
+        this.altReducer = reducer;
+        this.RCHash = (0, crypto_1.hasher)(reducer.name) || "";
+        // Set configuration with defaults
+        this.config = {
+            serializationMode: types_1.SerializationMode.JSON,
+            debug: false,
+            ...config,
+        };
+        // Apply configuration to instance properties
+        if (config.mode)
+            this.mode = config.mode;
+        if (config.role)
+            this.role.push(...config.role);
+        if (config.stderr)
+            this.stderr = config.stderr;
+        if (config.resync)
+            this.resync = config.resync;
+        // Initialize class registry only if ProtoObject mode is enabled
+        if (this.config.serializationMode === types_1.SerializationMode.PROTOOBJECT) {
+            this.classRegistry = (0, crypto_1.createClassRegistry)();
+        }
+        // Load package info
+        try {
+            let packagePath;
+            try {
+                // Try CommonJS approach first (__dirname available)
+                packagePath = (0, path_1.join)(__dirname, "../../package.json");
+            }
+            catch {
+                // Fallback - use relative path from process.cwd()
+                packagePath = (0, path_1.join)(process.cwd(), "package.json");
+            }
+            const packageJson = JSON.parse((0, fs_1.readFileSync)(packagePath, "utf8"));
+            this.version = packageJson.version;
+            this.homepage = packageJson.homepage;
+        }
+        catch {
+            this.version = "2.0.0";
+            this.homepage = "https://github.com/siarheidudko/redux-cluster";
+        }
+        // Validate reducer uniqueness (only if different hash)
+        if (typeof reducers[reducer.name] !== "undefined" &&
+            reducers[reducer.name] !== this.RCHash) {
+            throw new Error("Please don't use a reducer with the same name!");
+        }
+        reducers[reducer.name] = this.RCHash;
+        // Get default state
+        try {
+            const defaultState = this.altReducer(undefined, {});
+            if (typeof defaultState === "object" && defaultState !== null) {
+                this.defaultState = defaultState;
+            }
+            else {
+                throw new Error("The returned value is not an object.");
+            }
+        }
+        catch {
+            this.defaultState = {};
+        }
+        // Create Redux store with custom reducer
+        this.store = (0, redux_1.createStore)(this.createNewReducer());
+        // Bind Redux methods
+        this.dispatch = this.store.dispatch;
+        this.getState = this.store.getState;
+        this.subscribe = this.store.subscribe;
+        this.replaceReducer = this.store.replaceReducer;
+        this[Symbol.observable] = this.store[Symbol.observable];
+        this.initializeClusterRole();
+    }
+    // Internal method for sync actions
+    internalSync(payload) {
+        this.store.dispatch({
+            type: types_1.MessageType.SYNC,
+            payload,
+            _internal: true,
+        });
+    }
+    // Expose internal sync for backup purposes
+    _internalSync(payload) {
+        this.internalSync(payload);
+    }
+    createNewReducer() {
+        return (state = this.defaultState, action) => {
+            // Handle sync action (internal use only)
+            if (action.type === types_1.MessageType.SYNC) {
+                // Check if this is an internal sync call
+                const syncAction = action;
+                if (syncAction._internal) {
+                    return (0, crypto_1.universalClone)(syncAction.payload, this.config.serializationMode, this.classRegistry);
+                }
+                else {
+                    throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                }
+            }
+            // Handle sync mode
+            if (this.mode === "action") {
+                this.updateCounter();
+                this.sendActionsToNodes(action);
+            }
+            return this.altReducer(state, action);
+        };
+    }
+    updateCounter() {
+        if (typeof this.counter === "undefined" || this.counter === this.resync) {
+            this.counter = 1;
+        }
+        else {
+            this.counter++;
+        }
+        // Periodic full sync
+        if (this.counter === this.resync) {
+            if (this.role.includes("master")) {
+                setTimeout(() => this.sendtoall(), 100);
+            }
+            if (this.role.includes("server")) {
+                setTimeout(() => this.sendtoallsock(), 100);
+            }
+        }
+    }
+    sendActionsToNodes(action) {
+        if (this.role.includes("master")) {
+            setTimeout(() => this.sendtoall({
+                _msg: types_1.MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: action,
+            }), 1);
+        }
+        if (this.role.includes("server")) {
+            setTimeout(() => this.sendtoallsock({
+                _msg: types_1.MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: action,
+            }), 1);
+        }
+    }
+    initializeClusterRole() {
+        // Assign "master" role only to primary process in cluster
+        if (cluster_1.default.isPrimary) {
+            this.initializeMaster();
+        }
+        else {
+            // Assign "worker" role to non-master processes
+            this.initializeWorker();
+        }
+    }
+    initializeMaster() {
+        if (!this.role.includes("master")) {
+            this.role.push("master");
+        }
+        // Subscribe to changes in snapshot mode
+        this.unsubscribe = this.subscribe(() => {
+            if (this.mode === "snapshot") {
+                this.sendtoall();
+            }
+        });
+        // Listen for messages from workers
+        cluster_1.default.on("message", (worker, message, _handle) => {
+            if (arguments.length === 2) {
+                _handle = message;
+                message = worker;
+                worker = undefined;
+            }
+            this.handleMasterMessage(message, worker);
+        });
+        this.connected = true;
+    }
+    initializeWorker() {
+        if (!this.role.includes("worker")) {
+            this.role.push("worker");
+        }
+        // Override dispatch to send to master
+        this.dispatchNEW = this.dispatch;
+        this.dispatch = (action) => {
+            if (process.send) {
+                process.send({
+                    _msg: types_1.MessageType.MSG_TO_MASTER,
+                    _hash: this.RCHash,
+                    _action: action,
+                });
+            }
+        };
+        // Listen for messages from master
+        process.on("message", (data) => {
+            this.handleWorkerMessage(data);
+        });
+        this.connected = true;
+        // Request initial state
+        if (process.send) {
+            process.send({
+                _msg: types_1.MessageType.START,
+                _hash: this.RCHash,
+            });
+        }
+    }
+    handleMasterMessage(message, worker) {
+        if (message._hash === this.RCHash) {
+            switch (message._msg) {
+                case types_1.MessageType.MSG_TO_MASTER:
+                    if (message._action.type === types_1.MessageType.SYNC) {
+                        throw new Error("Please don't use REDUX_CLUSTER_SYNC action type!");
+                    }
+                    // Deserialize action if it contains ProtoObject
+                    let action = message._action;
+                    if (message._serialized) {
+                        try {
+                            action = (0, crypto_1.universalDeserialize)(message._serialized, this.config.serializationMode, this.classRegistry)._action;
+                        }
+                        catch {
+                            // Fallback to regular action
+                            action = message._action;
+                        }
+                    }
+                    this.store.dispatch(action);
+                    break;
+                case types_1.MessageType.START:
+                    const responseMsg = {
+                        _msg: types_1.MessageType.MSG_TO_WORKER,
+                        _hash: this.RCHash,
+                        _action: {
+                            type: types_1.MessageType.SYNC,
+                            payload: this.getState(),
+                        },
+                    };
+                    const serializedResponse = {
+                        ...responseMsg,
+                        _serialized: (0, crypto_1.universalSerialize)(responseMsg, this.config.serializationMode, this.classRegistry),
+                    };
+                    if (worker && cluster_1.default.workers && cluster_1.default.workers[worker.id]) {
+                        cluster_1.default.workers[worker.id].send(serializedResponse);
+                    }
+                    else {
+                        this.sendtoall();
+                    }
+                    break;
+                default:
+                    // Ignore unknown message types
+                    break;
+            }
+        }
+    }
+    handleWorkerMessage(data) {
+        if (data._hash === this.RCHash && this.role.includes("worker")) {
+            // Deserialize ProtoObject if needed
+            let processedData = data;
+            if (data._serialized) {
+                try {
+                    processedData = JSON.parse(data._serialized);
+                    processedData = (0, crypto_1.universalDeserialize)(data._serialized, this.config.serializationMode, this.classRegistry);
+                }
+                catch {
+                    // Fallback to regular data if deserialization fails
+                    processedData = data;
+                }
+            }
+            switch (processedData._msg) {
+                case types_1.MessageType.MSG_TO_WORKER:
+                    if (this.dispatchNEW) {
+                        this.dispatchNEW(processedData._action);
+                    }
+                    break;
+                case types_1.MessageType.CONN_STATUS:
+                    this.connected = processedData._connected;
+                    break;
+                default:
+                    // Ignore unknown message types
+                    break;
+            }
+        }
+    }
+    sendtoall(message) {
+        if (cluster_1.default.isPrimary && cluster_1.default.workers) {
+            const msg = message || {
+                _msg: types_1.MessageType.MSG_TO_WORKER,
+                _hash: this.RCHash,
+                _action: {
+                    type: types_1.MessageType.SYNC,
+                    payload: this.getState(),
+                },
+            };
+            // Serialize ProtoObject instances for IPC
+            const serializedMsg = {
+                ...msg,
+                _serialized: (0, crypto_1.universalSerialize)(msg, this.config.serializationMode, this.classRegistry),
+            };
+            for (const id in cluster_1.default.workers) {
+                if (cluster_1.default.workers[id]) {
+                    cluster_1.default.workers[id].send(serializedMsg);
+                }
+            }
+        }
+    }
+    sendtoallsock(message) {
+        for (const id in this.allsock) {
+            if (typeof this.allsock[id] === "object" &&
+                typeof this.allsock[id].sendtoall === "function") {
+                setTimeout(() => this.allsock[id].sendtoall(message), 1);
+            }
+        }
+    }
+    createServer(settings) {
+        if (!cluster_1.default.isPrimary && settings?.path && process.platform === "win32") {
+            throw new Error("Named channel is not supported in the child process, please use TCP-server");
+        }
+        if (!this.role.includes("server")) {
+            this.role.push("server");
+        }
+        this.connected = false;
+        return new server_1.ClusterServer(this, settings);
+    }
+    createClient(settings) {
+        if (this.role.includes("client")) {
+            throw new Error("One storage cannot be connected to two servers at the same time.");
+        }
+        if (!this.role.includes("client")) {
+            this.role.push("client");
+        }
+        this.connected = false;
+        return new client_1.ClusterClient(this, settings);
+    }
+    backup(settings) {
+        return new backup_1.BackupManager(this, settings).initialize();
+    }
+    // Register custom ProtoObject classes for proper serialization
+    registerClass(name, classConstructor) {
+        if (this.config.serializationMode === types_1.SerializationMode.PROTOOBJECT) {
+            this.classRegistry.set(name, classConstructor);
+        }
+        else {
+            console.warn("registerClass() is only available in ProtoObject mode");
+        }
+    }
+    // Get registered classes (useful for debugging)
+    getRegisteredClasses() {
+        if (this.config.serializationMode === types_1.SerializationMode.PROTOOBJECT) {
+            return Array.from(this.classRegistry.keys());
+        }
+        return [];
+    }
+}
+exports.ReduxCluster = ReduxCluster;
+Symbol.observable;

package/dist/cjs/index.d.ts

@@ -0,0 +1,22 @@
+import { Reducer, Action, combineReducers, bindActionCreators, applyMiddleware, compose } from "redux";
+import { ReduxCluster } from "./core/redux-cluster";
+import { ReduxClusterConfig } from "./types";
+import { hasher } from "./utils/crypto";
+export * from "redux";
+export * from "./types";
+export declare const functions: {
+    hasher: typeof hasher;
+};
+export declare function createStore<S = any, A extends Action = Action>(reducer: Reducer<S, A>, config?: ReduxClusterConfig): ReduxCluster<S, A>;
+declare const _default: {
+    createStore: typeof createStore;
+    functions: {
+        hasher: typeof hasher;
+    };
+    combineReducers: typeof combineReducers;
+    bindActionCreators: typeof bindActionCreators;
+    applyMiddleware: typeof applyMiddleware;
+    compose: typeof compose;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,MAAM,EACN,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,OAAO,EACR,MAAM,OAAO,CAAC;AACf,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAGxC,cAAc,OAAO,CAAC;AAGtB,cAAc,SAAS,CAAC;AAGxB,eAAO,MAAM,SAAS;;CAErB,CAAC;AAGF,wBAAgB,WAAW,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,EAC5D,OAAO,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EACtB,MAAM,CAAC,EAAE,kBAAkB,GAC1B,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAEpB;;;;;;;;;;;AAGD,wBAQE"}

package/dist/cjs/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functions = void 0;
+exports.createStore = createStore;
+const redux_1 = require("redux");
+const redux_cluster_1 = require("./core/redux-cluster");
+const crypto_1 = require("./utils/crypto");
+// Re-export Redux functions and types
+__exportStar(require("redux"), exports);
+// Export our types
+__exportStar(require("./types"), exports);
+// Export utility functions
+exports.functions = {
+    hasher: crypto_1.hasher,
+};
+// Main function to create a ReduxCluster store
+function createStore(reducer, config) {
+    return new redux_cluster_1.ReduxCluster(reducer, config);
+}
+// Default export for CommonJS compatibility
+exports.default = {
+    createStore,
+    functions: exports.functions,
+    // Re-export Redux
+    combineReducers: redux_1.combineReducers,
+    bindActionCreators: redux_1.bindActionCreators,
+    applyMiddleware: redux_1.applyMiddleware,
+    compose: redux_1.compose,
+};