snow-flow 3.0.9 → 3.0.10

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

@@ -1,716 +0,0 @@
-"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