snow-flow 1.1.74 → 1.1.76

package/dist/orchestration/state/distributed-state-manager.js

@@ -0,0 +1,716 @@
+"use strict";
+/**
+ * Distributed State Management System
+ *
+ * Manages distributed shared memory and state synchronization across
+ * external Claude Code instances using consensus algorithms and conflict resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedStateError = exports.DistributedStateManager = void 0;
+const events_1 = require("events");
+const distributed_orchestration_interface_js_1 = require("../interfaces/distributed-orchestration.interface.js");
+const logger_js_1 = require("../../utils/logger.js");
+class DistributedStateManager extends events_1.EventEmitter {
+    constructor(instanceId, config) {
+        super();
+        this.config = config;
+        this.localCache = new Map();
+        this.subscriptions = new Map();
+        this.instanceId = instanceId;
+        this.distributedStore = new DistributedStore(config.storage);
+        this.conflictResolver = new ConflictResolver(config.conflictResolution);
+        this.eventBus = new EventBus(config.eventBus);
+        this.consensusManager = new ConsensusManager(config.consensus);
+        this.replicationManager = new ReplicationManager(config.replication);
+        this.setupEventHandlers();
+        this.startPeriodicSync();
+    }
+    // ========================================
+    // Core State Management Operations
+    // ========================================
+    async store(key, value, ttl, consistency = distributed_orchestration_interface_js_1.ConsistencyLevel.EVENTUAL) {
+        logger_js_1.logger.info(`💾 Storing distributed state`, { key, consistency, ttl });
+        try {
+            // Create memory value with metadata
+            const memoryValue = {
+                value,
+                timestamp: Date.now(),
+                version: await this.getNextVersion(key),
+                instanceId: this.instanceId,
+                metadata: {
+                    ttl: ttl ? Date.now() + ttl : undefined,
+                    checksum: this.calculateChecksum(value),
+                    consistency,
+                    tags: this.extractTags(key, value)
+                }
+            };
+            // Handle different consistency levels
+            switch (consistency) {
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.STRONG:
+                    await this.storeWithStrongConsistency(key, memoryValue);
+                    break;
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.EVENTUAL:
+                    await this.storeWithEventualConsistency(key, memoryValue);
+                    break;
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.WEAK:
+                    await this.storeWithWeakConsistency(key, memoryValue);
+                    break;
+            }
+            logger_js_1.logger.info(`✅ Successfully stored state: ${key}`);
+            this.emit('state:stored', { key, value: memoryValue, consistency });
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Failed to store state: ${key}`, { error: error.message });
+            throw new DistributedStateError(`Store operation failed: ${error.message}`);
+        }
+    }
+    async retrieve(key, consistency = distributed_orchestration_interface_js_1.ConsistencyLevel.EVENTUAL) {
+        logger_js_1.logger.debug(`🔍 Retrieving distributed state: ${key}`, { consistency });
+        try {
+            let memoryValue = null;
+            switch (consistency) {
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.STRONG:
+                    memoryValue = await this.retrieveWithStrongConsistency(key);
+                    break;
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.EVENTUAL:
+                    memoryValue = await this.retrieveWithEventualConsistency(key);
+                    break;
+                case distributed_orchestration_interface_js_1.ConsistencyLevel.WEAK:
+                    memoryValue = await this.retrieveWithWeakConsistency(key);
+                    break;
+            }
+            if (!memoryValue) {
+                logger_js_1.logger.debug(`🔍 State not found: ${key}`);
+                return undefined;
+            }
+            // Check TTL expiration
+            if (this.isExpired(memoryValue)) {
+                await this.delete(key);
+                return undefined;
+            }
+            logger_js_1.logger.debug(`✅ Successfully retrieved state: ${key}`);
+            this.emit('state:retrieved', { key, value: memoryValue, consistency });
+            return memoryValue.value;
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Failed to retrieve state: ${key}`, { error: error.message });
+            throw new DistributedStateError(`Retrieve operation failed: ${error.message}`);
+        }
+    }
+    async delete(key) {
+        logger_js_1.logger.info(`🗑️ Deleting distributed state: ${key}`);
+        try {
+            // Remove from local cache
+            this.localCache.delete(key);
+            // Remove from distributed store
+            await this.distributedStore.delete(key);
+            // Notify subscribers
+            this.notifySubscribers(key, undefined, 'delete');
+            logger_js_1.logger.info(`✅ Successfully deleted state: ${key}`);
+            this.emit('state:deleted', { key });
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Failed to delete state: ${key}`, { error: error.message });
+            throw new DistributedStateError(`Delete operation failed: ${error.message}`);
+        }
+    }
+    // ========================================
+    // Subscription Management
+    // ========================================
+    async subscribe(pattern, callback) {
+        const subscriptionId = this.generateSubscriptionId();
+        logger_js_1.logger.info(`👁️ Creating subscription: ${subscriptionId}`, { pattern });
+        const subscription = {
+            id: subscriptionId,
+            pattern,
+            callback,
+            createdAt: new Date(),
+            lastNotified: new Date()
+        };
+        this.subscriptions.set(subscriptionId, subscription);
+        // Register with event bus
+        await this.eventBus.subscribe(`state.${pattern}`, (event) => {
+            this.handleSubscriptionEvent(subscriptionId, event);
+        });
+        logger_js_1.logger.info(`✅ Subscription created: ${subscriptionId}`);
+        return subscriptionId;
+    }
+    async unsubscribe(subscriptionId) {
+        logger_js_1.logger.info(`🛑 Removing subscription: ${subscriptionId}`);
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (!subscription) {
+            throw new DistributedStateError(`Subscription not found: ${subscriptionId}`);
+        }
+        // Unregister from event bus
+        await this.eventBus.unsubscribe(`state.${subscription.pattern}`);
+        // Remove from local subscriptions
+        this.subscriptions.delete(subscriptionId);
+        logger_js_1.logger.info(`✅ Subscription removed: ${subscriptionId}`);
+    }
+    // ========================================
+    // State Synchronization
+    // ========================================
+    async synchronize(targetInstances, keys) {
+        logger_js_1.logger.info(`🔄 Starting state synchronization`, {
+            targetInstances: targetInstances.length,
+            keys: keys?.length || 'all'
+        });
+        const startTime = Date.now();
+        const synchronized = [];
+        const conflicts = [];
+        const errors = [];
+        try {
+            // Determine which keys to sync
+            const keysToSync = keys || Array.from(this.localCache.keys());
+            // Sync each key with target instances
+            for (const key of keysToSync) {
+                try {
+                    const keyResult = await this.synchronizeKey(key, targetInstances);
+                    if (keyResult.synchronized) {
+                        synchronized.push(key);
+                    }
+                    conflicts.push(...keyResult.conflicts);
+                    errors.push(...keyResult.errors);
+                }
+                catch (error) {
+                    logger_js_1.logger.warn(`⚠️ Failed to sync key: ${key}`, { error: error.message });
+                    errors.push({
+                        instanceId: 'local',
+                        error: `Key sync failed: ${error.message}`,
+                        retryable: true
+                    });
+                }
+            }
+            // Resolve conflicts if any
+            if (conflicts.length > 0) {
+                await this.resolveConflicts(conflicts);
+            }
+            const result = {
+                success: errors.length === 0,
+                synchronized,
+                conflicts: conflicts.filter(c => !c.resolutionStrategy),
+                errors,
+                duration: Date.now() - startTime
+            };
+            logger_js_1.logger.info(`✅ Synchronization completed`, {
+                synchronized: synchronized.length,
+                conflicts: conflicts.length,
+                errors: errors.length,
+                duration: result.duration
+            });
+            this.emit('state:synchronized', result);
+            return result;
+        }
+        catch (error) {
+            logger_js_1.logger.error(`❌ Synchronization failed`, { error: error.message });
+            return {
+                success: false,
+                synchronized,
+                conflicts,
+                errors: [...errors, {
+                        instanceId: 'local',
+                        error: `Sync operation failed: ${error.message}`,
+                        retryable: false
+                    }],
+                duration: Date.now() - startTime
+            };
+        }
+    }
+    // ========================================
+    // Consistency Implementation
+    // ========================================
+    async storeWithStrongConsistency(key, memoryValue) {
+        logger_js_1.logger.debug(`🔒 Strong consistency store: ${key}`);
+        // 1. Propose change to consensus group
+        const proposal = await this.consensusManager.proposeChange({
+            type: 'store',
+            key,
+            value: memoryValue,
+            proposer: this.instanceId
+        });
+        if (!proposal.approved) {
+            throw new DistributedStateError(`Consensus failed for key: ${key}`);
+        }
+        // 2. Store locally after consensus
+        this.localCache.set(key, memoryValue);
+        // 3. Replicate to all nodes synchronously
+        await this.replicationManager.replicateSync(key, memoryValue);
+        // 4. Notify subscribers
+        this.notifySubscribers(key, memoryValue, 'create');
+    }
+    async storeWithEventualConsistency(key, memoryValue) {
+        logger_js_1.logger.debug(`⏰ Eventual consistency store: ${key}`);
+        // 1. Store locally first
+        this.localCache.set(key, memoryValue);
+        // 2. Replicate asynchronously
+        this.replicationManager.replicateAsync(key, memoryValue)
+            .catch(error => {
+            logger_js_1.logger.warn(`⚠️ Async replication failed for key: ${key}`, { error: error.message });
+        });
+        // 3. Notify subscribers immediately
+        this.notifySubscribers(key, memoryValue, 'create');
+    }
+    async storeWithWeakConsistency(key, memoryValue) {
+        logger_js_1.logger.debug(`📡 Weak consistency store: ${key}`);
+        // 1. Store locally only
+        this.localCache.set(key, memoryValue);
+        // 2. Broadcast change event (best effort)
+        this.eventBus.broadcast('state.changed', { key, value: memoryValue, instanceId: this.instanceId })
+            .catch(error => {
+            logger_js_1.logger.debug(`📡 Broadcast failed for key: ${key}`, { error: error.message });
+        });
+        // 3. Notify local subscribers
+        this.notifySubscribers(key, memoryValue, 'create');
+    }
+    async retrieveWithStrongConsistency(key) {
+        logger_js_1.logger.debug(`🔒 Strong consistency retrieve: ${key}`);
+        // Read from consensus group to ensure latest value
+        const consensusValue = await this.consensusManager.readWithConsensus(key);
+        if (consensusValue) {
+            // Update local cache with consensus value
+            this.localCache.set(key, consensusValue);
+            return consensusValue;
+        }
+        return null;
+    }
+    async retrieveWithEventualConsistency(key) {
+        logger_js_1.logger.debug(`⏰ Eventual consistency retrieve: ${key}`);
+        // Check local cache first
+        const localValue = this.localCache.get(key);
+        if (localValue) {
+            return localValue;
+        }
+        // Fallback to distributed store
+        const distributedValue = await this.distributedStore.read(key);
+        if (distributedValue) {
+            this.localCache.set(key, distributedValue);
+            return distributedValue;
+        }
+        return null;
+    }
+    async retrieveWithWeakConsistency(key) {
+        logger_js_1.logger.debug(`📡 Weak consistency retrieve: ${key}`);
+        // Only check local cache for weak consistency
+        return this.localCache.get(key) || null;
+    }
+    // ========================================
+    // Key Synchronization
+    // ========================================
+    async synchronizeKey(key, targetInstances) {
+        const localValue = this.localCache.get(key);
+        const synchronized = [];
+        const conflicts = [];
+        const errors = [];
+        for (const instanceId of targetInstances) {
+            try {
+                const remoteValue = await this.getRemoteValue(instanceId, key);
+                if (!remoteValue && localValue) {
+                    // Local has value, remote doesn't - push to remote
+                    await this.pushValueToRemote(instanceId, key, localValue);
+                    synchronized.push(true);
+                }
+                else if (remoteValue && !localValue) {
+                    // Remote has value, local doesn't - pull from remote
+                    this.localCache.set(key, remoteValue);
+                    synchronized.push(true);
+                }
+                else if (remoteValue && localValue) {
+                    // Both have values - check for conflicts
+                    const conflict = this.detectConflict(key, localValue, remoteValue);
+                    if (conflict) {
+                        conflicts.push(conflict);
+                        synchronized.push(false);
+                    }
+                    else {
+                        // Values are compatible
+                        synchronized.push(true);
+                    }
+                }
+                else {
+                    // Neither has value - nothing to sync
+                    synchronized.push(true);
+                }
+            }
+            catch (error) {
+                logger_js_1.logger.warn(`⚠️ Failed to sync key ${key} with instance: ${instanceId}`, { error: error.message });
+                errors.push({
+                    instanceId,
+                    error: error.message,
+                    retryable: true
+                });
+                synchronized.push(false);
+            }
+        }
+        return {
+            synchronized: synchronized.every(s => s),
+            conflicts,
+            errors
+        };
+    }
+    async getRemoteValue(instanceId, key) {
+        // Implementation would make remote call to get value
+        // For now, return null (would use MCPX protocol)
+        return null;
+    }
+    async pushValueToRemote(instanceId, key, value) {
+        // Implementation would push value to remote instance
+        // For now, just log (would use MCPX protocol)
+        logger_js_1.logger.debug(`📤 Pushing value to remote: ${instanceId}`, { key });
+    }
+    // ========================================
+    // Conflict Detection and Resolution
+    // ========================================
+    detectConflict(key, localValue, remoteValue) {
+        // Check if values conflict
+        if (localValue.version !== remoteValue.version ||
+            localValue.timestamp !== remoteValue.timestamp ||
+            localValue.metadata?.checksum !== remoteValue.metadata?.checksum) {
+            return {
+                key,
+                localValue,
+                remoteValues: new Map([[remoteValue.instanceId, remoteValue]]),
+                resolutionStrategy: this.selectConflictResolutionStrategy(localValue, remoteValue)
+            };
+        }
+        return null;
+    }
+    selectConflictResolutionStrategy(localValue, remoteValue) {
+        // Default to last write wins
+        return {
+            type: 'last_write_wins',
+            parameters: {}
+        };
+    }
+    async resolveConflicts(conflicts) {
+        logger_js_1.logger.info(`🔧 Resolving ${conflicts.length} conflicts`);
+        for (const conflict of conflicts) {
+            try {
+                const resolution = await this.conflictResolver.resolve(conflict);
+                if (resolution.resolved) {
+                    // Apply resolution
+                    this.localCache.set(conflict.key, resolution.resolvedValue);
+                    logger_js_1.logger.info(`✅ Conflict resolved for key: ${conflict.key}`);
+                }
+                else {
+                    logger_js_1.logger.warn(`⚠️ Could not resolve conflict for key: ${conflict.key}`);
+                }
+            }
+            catch (error) {
+                logger_js_1.logger.error(`❌ Failed to resolve conflict for key: ${conflict.key}`, { error: error.message });
+            }
+        }
+    }
+    // ========================================
+    // Event Handling and Subscriptions
+    // ========================================
+    setupEventHandlers() {
+        // Handle remote state changes
+        this.eventBus.on('state.remote_change', (event) => {
+            this.handleRemoteStateChange(event);
+        });
+        // Handle consensus events
+        this.consensusManager.on('consensus.change', (event) => {
+            this.handleConsensusChange(event);
+        });
+        // Handle replication events
+        this.replicationManager.on('replication.conflict', (event) => {
+            this.handleReplicationConflict(event);
+        });
+    }
+    handleRemoteStateChange(event) {
+        logger_js_1.logger.debug(`📡 Remote state change received`, { key: event.key, source: event.sourceInstance });
+        // Update local cache with remote change
+        if (event.operation === 'store') {
+            this.localCache.set(event.key, event.value);
+            this.notifySubscribers(event.key, event.value, 'update');
+        }
+        else if (event.operation === 'delete') {
+            this.localCache.delete(event.key);
+            this.notifySubscribers(event.key, undefined, 'delete');
+        }
+    }
+    handleConsensusChange(event) {
+        logger_js_1.logger.info(`🗳️ Consensus change applied`, { key: event.key });
+        // Apply consensus decision to local state
+        if (event.decision.approved) {
+            this.localCache.set(event.key, event.decision.value);
+            this.notifySubscribers(event.key, event.decision.value, 'update');
+        }
+    }
+    handleReplicationConflict(event) {
+        logger_js_1.logger.warn(`⚔️ Replication conflict detected`, { key: event.key });
+        // Queue conflict for resolution
+        this.resolveConflicts([event.conflict]).catch(error => {
+            logger_js_1.logger.error(`❌ Failed to resolve replication conflict`, { error: error.message });
+        });
+    }
+    notifySubscribers(key, value, changeType) {
+        this.subscriptions.forEach((subscription, subscriptionId) => {
+            if (this.matchesPattern(key, subscription.pattern)) {
+                try {
+                    subscription.callback(key, value, changeType);
+                    subscription.lastNotified = new Date();
+                }
+                catch (error) {
+                    logger_js_1.logger.error(`❌ Subscription callback failed: ${subscriptionId}`, { error: error.message });
+                }
+            }
+        });
+    }
+    handleSubscriptionEvent(subscriptionId, event) {
+        const subscription = this.subscriptions.get(subscriptionId);
+        if (subscription) {
+            try {
+                subscription.callback(event.key, event.value, event.changeType);
+                subscription.lastNotified = new Date();
+            }
+            catch (error) {
+                logger_js_1.logger.error(`❌ Subscription event handling failed: ${subscriptionId}`, { error: error.message });
+            }
+        }
+    }
+    // ========================================
+    // Utility Methods
+    // ========================================
+    async getNextVersion(key) {
+        const existing = this.localCache.get(key);
+        return existing ? existing.version + 1 : 1;
+    }
+    calculateChecksum(value) {
+        // Simple checksum calculation - in production would use proper hashing
+        const str = JSON.stringify(value);
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32-bit integer
+        }
+        return Math.abs(hash).toString(16);
+    }
+    extractTags(key, value) {
+        const tags = [];
+        // Add key-based tags
+        if (key.includes('session'))
+            tags.push('session');
+        if (key.includes('task'))
+            tags.push('task');
+        if (key.includes('agent'))
+            tags.push('agent');
+        // Add value-based tags
+        if (typeof value === 'object' && value !== null) {
+            if (value.type)
+                tags.push(`type:${value.type}`);
+            if (value.category)
+                tags.push(`category:${value.category}`);
+        }
+        return tags;
+    }
+    isExpired(memoryValue) {
+        if (!memoryValue.metadata?.ttl)
+            return false;
+        return Date.now() > memoryValue.metadata.ttl;
+    }
+    matchesPattern(key, pattern) {
+        // Simple pattern matching - would implement proper glob pattern matching
+        if (pattern === '*')
+            return true;
+        if (pattern.endsWith('*')) {
+            return key.startsWith(pattern.slice(0, -1));
+        }
+        return key === pattern;
+    }
+    generateSubscriptionId() {
+        return `sub_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    }
+    startPeriodicSync() {
+        const interval = this.config.syncInterval || 60000; // 1 minute default
+        setInterval(async () => {
+            try {
+                logger_js_1.logger.debug('🔄 Running periodic state sync');
+                // Get list of all known instances
+                const instances = await this.getKnownInstances();
+                if (instances.length > 0) {
+                    await this.synchronize(instances);
+                }
+            }
+            catch (error) {
+                logger_js_1.logger.warn('⚠️ Periodic sync failed', { error: error.message });
+            }
+        }, interval);
+    }
+    async getKnownInstances() {
+        // Implementation would get list of known instances from discovery service
+        return [];
+    }
+}
+exports.DistributedStateManager = DistributedStateManager;
+// ========================================
+// Supporting Classes
+// ========================================
+class DistributedStore {
+    constructor(config) {
+        this.config = config;
+    }
+    async read(key) {
+        // Implementation would read from persistent storage
+        return null;
+    }
+    async write(key, value) {
+        // Implementation would write to persistent storage
+    }
+    async delete(key) {
+        // Implementation would delete from persistent storage
+    }
+    async replicate(key, value) {
+        // Implementation would replicate to other storage nodes
+    }
+}
+class ConflictResolver {
+    constructor(config) {
+        this.config = config;
+    }
+    async resolve(conflict) {
+        logger_js_1.logger.info(`🔧 Resolving conflict for key: ${conflict.key}`);
+        switch (conflict.resolutionStrategy.type) {
+            case 'last_write_wins':
+                return this.resolveLastWriteWins(conflict);
+            case 'vector_clock':
+                return this.resolveVectorClock(conflict);
+            case 'merge':
+                return this.resolveMerge(conflict);
+            case 'manual':
+                return this.resolveManual(conflict);
+            default:
+                return { resolved: false, reason: `Unknown resolution strategy: ${conflict.resolutionStrategy.type}` };
+        }
+    }
+    resolveLastWriteWins(conflict) {
+        // Find the value with the latest timestamp
+        let latestValue = conflict.localValue;
+        let latestTimestamp = conflict.localValue.timestamp;
+        for (const remoteValue of conflict.remoteValues.values()) {
+            if (remoteValue.timestamp > latestTimestamp) {
+                latestValue = remoteValue;
+                latestTimestamp = remoteValue.timestamp;
+            }
+        }
+        return {
+            resolved: true,
+            resolvedValue: latestValue,
+            strategy: 'last_write_wins'
+        };
+    }
+    resolveVectorClock(conflict) {
+        // Implementation would use vector clocks for resolution
+        // For now, fallback to last write wins
+        return this.resolveLastWriteWins(conflict);
+    }
+    resolveMerge(conflict) {
+        // Implementation would merge conflicting values
+        // For now, fallback to last write wins
+        return this.resolveLastWriteWins(conflict);
+    }
+    resolveManual(conflict) {
+        // Implementation would queue for manual resolution
+        return {
+            resolved: false,
+            reason: 'Manual resolution required',
+            requiresManualIntervention: true
+        };
+    }
+}
+class EventBus {
+    constructor(config) {
+        this.config = config;
+        this.events = new Map();
+    }
+    on(eventType, callback) {
+        if (!this.events.has(eventType)) {
+            this.events.set(eventType, []);
+        }
+        this.events.get(eventType).push(callback);
+    }
+    off(eventType, callback) {
+        const callbacks = this.events.get(eventType);
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index !== -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    }
+    emit(eventType, event) {
+        const callbacks = this.events.get(eventType);
+        if (callbacks) {
+            callbacks.forEach(callback => {
+                try {
+                    callback(event);
+                }
+                catch (error) {
+                    logger_js_1.logger.error(`❌ Event callback failed`, { eventType, error: error.message });
+                }
+            });
+        }
+    }
+    async subscribe(pattern, callback) {
+        // Implementation would subscribe to distributed event stream
+        this.on(pattern, callback);
+    }
+    async unsubscribe(pattern) {
+        // Implementation would unsubscribe from distributed event stream
+        this.events.delete(pattern);
+    }
+    async broadcast(eventType, event) {
+        // Implementation would broadcast to all instances
+        this.emit(eventType, event);
+    }
+}
+class ConsensusManager extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async proposeChange(proposal) {
+        logger_js_1.logger.info(`🗳️ Proposing consensus change`, { type: proposal.type, key: proposal.key });
+        // Simplified consensus - in production would implement Raft or similar
+        const result = {
+            approved: true,
+            votes: new Map([['local', true]]),
+            proposal
+        };
+        this.emit('consensus.change', {
+            key: proposal.key,
+            decision: result
+        });
+        return result;
+    }
+    async readWithConsensus(key) {
+        // Implementation would read with consensus guarantees
+        return null;
+    }
+}
+class ReplicationManager extends events_1.EventEmitter {
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    async replicateSync(key, value) {
+        logger_js_1.logger.debug(`📋 Synchronous replication: ${key}`);
+        // Implementation would replicate synchronously to all replicas
+    }
+    async replicateAsync(key, value) {
+        logger_js_1.logger.debug(`📋 Asynchronous replication: ${key}`);
+        // Implementation would replicate asynchronously to replicas
+    }
+}
+// ========================================
+// Error Classes
+// ========================================
+class DistributedStateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DistributedStateError';
+    }
+}
+exports.DistributedStateError = DistributedStateError;
+//# sourceMappingURL=distributed-state-manager.js.map