claude-flow-novice 1.6.1 → 1.6.2

package/.claude-flow-novice/dist/src/coordination/v2/transparency/transparency-system.js

@@ -0,0 +1,679 @@
+/**
+ * Agent Transparency System Implementation
+ *
+ * Core transparency system providing real-time monitoring, event streaming,
+ * and hierarchy visualization for V2 multi-level agent coordination.
+ *
+ * @module coordination/v2/transparency/transparency-system
+ */ import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import { Logger } from '../../../core/logger.js';
+/**
+ * Transparency System Implementation
+ *
+ * Provides comprehensive visibility into multi-level agent operations:
+ * - Real-time agent hierarchy tracking
+ * - Agent lifecycle event streaming
+ * - Performance monitoring and alerting
+ * - Resource allocation transparency
+ */ export class TransparencySystem extends EventEmitter {
+    logger = new Logger({
+        level: 'info',
+        format: 'text',
+        destination: 'console'
+    });
+    config;
+    isInitialized = false;
+    isMonitoring = false;
+    // Agent tracking
+    agentHierarchy = new Map();
+    agentStatuses = new Map();
+    agentPerformanceMetrics = new Map();
+    // Event storage
+    lifecycleEvents = [];
+    eventListeners = new Set();
+    // Monitoring intervals
+    metricsUpdateInterval;
+    heartbeatInterval;
+    // Performance tracking
+    performanceThresholds = {
+        maxExecutionTimeMs: 300000,
+        maxMemoryUsage: 512 * 1024 * 1024,
+        maxTokenUsageRate: 100,
+        maxPauseLatencyMs: 50,
+        maxCpuUsage: 80
+    };
+    constructor(){
+        super();
+        this.config = this.getDefaultConfig();
+    }
+    // ===========================
+    // System Lifecycle
+    // ===========================
+    async initialize(config = {}) {
+        if (this.isInitialized) {
+            this.logger.warn('TransparencySystem already initialized');
+            return;
+        }
+        this.config = {
+            ...this.getDefaultConfig(),
+            ...config
+        };
+        this.logger.info('Initializing TransparencySystem', this.config);
+        // Initialize event storage
+        this.lifecycleEvents = [];
+        this.agentHierarchy.clear();
+        this.agentStatuses.clear();
+        this.agentPerformanceMetrics.clear();
+        this.isInitialized = true;
+        this.emit('initialized');
+        this.logger.info('TransparencySystem initialized successfully');
+    }
+    async startMonitoring() {
+        if (!this.isInitialized) {
+            throw new Error('TransparencySystem not initialized');
+        }
+        if (this.isMonitoring) {
+            this.logger.warn('TransparencySystem monitoring already started');
+            return;
+        }
+        this.logger.info('Starting transparency monitoring');
+        // Start metrics update interval
+        this.metricsUpdateInterval = setInterval(()=>this.updateMetrics(), this.config.metricsUpdateIntervalMs);
+        // Start heartbeat monitoring
+        this.heartbeatInterval = setInterval(()=>this.checkAgentHeartbeats(), this.config.heartbeatIntervalMs);
+        this.isMonitoring = true;
+        this.emit('monitoringStarted');
+        this.logger.info('Transparency monitoring started');
+    }
+    async stopMonitoring() {
+        if (!this.isMonitoring) {
+            return;
+        }
+        this.logger.info('Stopping transparency monitoring');
+        // Clear intervals
+        if (this.metricsUpdateInterval) {
+            clearInterval(this.metricsUpdateInterval);
+            this.metricsUpdateInterval = undefined;
+        }
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = undefined;
+        }
+        this.isMonitoring = false;
+        this.emit('monitoringStopped');
+        this.logger.info('Transparency monitoring stopped');
+    }
+    async cleanup() {
+        this.logger.info('Cleaning up TransparencySystem');
+        await this.stopMonitoring();
+        // Clear all data
+        this.lifecycleEvents = [];
+        this.agentHierarchy.clear();
+        this.agentStatuses.clear();
+        this.agentPerformanceMetrics.clear();
+        this.eventListeners.clear();
+        this.removeAllListeners();
+        this.isInitialized = false;
+        this.logger.info('TransparencySystem cleanup complete');
+    }
+    // ===========================
+    // Agent Registration & Tracking
+    // ===========================
+    /**
+   * Register agent with transparency system
+   *
+   * Called when agent is spawned in coordinator
+   */ registerAgent(agent, parentAgentId) {
+        const hierarchyNode = {
+            agentId: agent.agentId,
+            type: agent.type,
+            level: this.calculateAgentLevel(agent.agentId, parentAgentId),
+            parentAgentId,
+            childAgentIds: [],
+            priority: agent.priority,
+            state: agent.state,
+            sessionId: agent.sessionId,
+            createdAt: new Date(),
+            lastStateChange: new Date(),
+            tokensUsed: 0,
+            tokenBudget: agent.metadata.tokenBudget || 10000,
+            isPaused: agent.isPaused,
+            metadata: agent.metadata,
+            metrics: {
+                spawnTimeMs: 0,
+                totalExecutionTimeMs: 0,
+                pauseCount: 0,
+                resumeCount: 0,
+                checkpointCount: 0
+            },
+            currentTask: undefined,
+            waitingFor: [],
+            completedDependencies: []
+        };
+        this.agentHierarchy.set(agent.agentId, hierarchyNode);
+        // Initialize agent status
+        const status = {
+            agentId: agent.agentId,
+            state: agent.state,
+            isPaused: agent.isPaused,
+            activity: 'Spawned',
+            progress: 0,
+            tokensUsed: 0,
+            tokenUsageRate: 0,
+            memoryUsage: 0,
+            cpuUsage: 0,
+            lastHeartbeat: new Date(),
+            recentErrors: []
+        };
+        this.agentStatuses.set(agent.agentId, status);
+        // Update parent's child list
+        if (parentAgentId && this.agentHierarchy.has(parentAgentId)) {
+            const parent = this.agentHierarchy.get(parentAgentId);
+            parent.childAgentIds.push(agent.agentId);
+        }
+        // Record lifecycle event
+        this.recordLifecycleEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            agentId: agent.agentId,
+            eventType: 'spawned',
+            eventData: {
+                metadata: agent.metadata
+            },
+            level: hierarchyNode.level,
+            parentAgentId,
+            sessionId: agent.sessionId,
+            tokensUsed: 0,
+            performanceImpact: {}
+        });
+        this.emit('agentRegistered', {
+            agentId: agent.agentId,
+            hierarchyNode
+        });
+        this.notifyHierarchyChange('agent_added', agent.agentId, hierarchyNode);
+    }
+    /**
+   * Update agent state
+   *
+   * Called when agent state changes
+   */ updateAgentState(agentId, newState, reason) {
+        const hierarchyNode = this.agentHierarchy.get(agentId);
+        const status = this.agentStatuses.get(agentId);
+        if (!hierarchyNode || !status) {
+            this.logger.warn(`Agent ${agentId} not found in transparency tracking`);
+            return;
+        }
+        const previousState = hierarchyNode.state;
+        hierarchyNode.state = newState;
+        hierarchyNode.lastStateChange = new Date();
+        status.state = newState;
+        // Update activity based on state
+        status.activity = this.getActivityForState(newState, reason);
+        // Record lifecycle event
+        this.recordLifecycleEvent({
+            eventId: uuidv4(),
+            timestamp: new Date(),
+            agentId,
+            eventType: 'state_changed',
+            eventData: {
+                previousState,
+                newState,
+                reason
+            },
+            level: hierarchyNode.level,
+            parentAgentId: hierarchyNode.parentAgentId,
+            sessionId: hierarchyNode.sessionId,
+            tokensUsed: hierarchyNode.tokensUsed,
+            performanceImpact: {}
+        });
+        this.emit('agentStateChanged', {
+            agentId,
+            previousState,
+            newState
+        });
+        this.notifyStateChange(agentId, previousState, newState);
+    }
+    /**
+   * Update agent token usage
+   *
+   * Called when agent consumes tokens
+   */ updateTokenUsage(agentId, tokensUsed) {
+        const hierarchyNode = this.agentHierarchy.get(agentId);
+        const status = this.agentStatuses.get(agentId);
+        if (!hierarchyNode || !status) {
+            return;
+        }
+        const previousTokens = hierarchyNode.tokensUsed;
+        hierarchyNode.tokensUsed = tokensUsed;
+        status.tokensUsed = tokensUsed;
+        // Calculate token usage rate
+        const timeDelta = Date.now() - status.lastHeartbeat.getTime();
+        if (timeDelta > 0) {
+            status.tokenUsageRate = (tokensUsed - previousTokens) / (timeDelta / 1000);
+        }
+        // Check performance thresholds
+        this.checkPerformanceThresholds(agentId);
+    }
+    // ===========================
+    // Hierarchy Visualization
+    // ===========================
+    async getAgentHierarchy() {
+        return Array.from(this.agentHierarchy.values());
+    }
+    async getAgentsAtLevel(level) {
+        return Array.from(this.agentHierarchy.values()).filter((agent)=>agent.level === level);
+    }
+    async getChildAgents(parentAgentId) {
+        const parent = this.agentHierarchy.get(parentAgentId);
+        if (!parent) {
+            return [];
+        }
+        return parent.childAgentIds.map((childId)=>this.agentHierarchy.get(childId)).filter(Boolean);
+    }
+    async getRootAgents() {
+        return Array.from(this.agentHierarchy.values()).filter((agent)=>!agent.parentAgentId);
+    }
+    // ===========================
+    // Real-time Monitoring
+    // ===========================
+    async getAllAgentStatuses() {
+        return Array.from(this.agentStatuses.values());
+    }
+    async getAgentStatus(agentId) {
+        const status = this.agentStatuses.get(agentId);
+        if (!status) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        return status;
+    }
+    async getActiveAgents() {
+        return Array.from(this.agentStatuses.values()).filter((status)=>!status.isPaused && status.state !== 'terminated');
+    }
+    async getPausedAgents() {
+        return Array.from(this.agentStatuses.values()).filter((status)=>status.isPaused);
+    }
+    // ===========================
+    // Event Streaming
+    // ===========================
+    async getRecentEvents(limit = 100, eventType) {
+        let events = [
+            ...this.lifecycleEvents
+        ].reverse();
+        if (eventType) {
+            events = events.filter((event)=>event.eventType === eventType);
+        }
+        return events.slice(0, limit);
+    }
+    async getAgentEvents(agentId, limit = 50) {
+        const events = this.lifecycleEvents.filter((event)=>event.agentId === agentId).reverse();
+        return events.slice(0, limit);
+    }
+    async getEventsInTimeRange(startTime, endTime, limit = 100) {
+        const events = this.lifecycleEvents.filter((event)=>event.timestamp >= startTime && event.timestamp <= endTime).reverse();
+        return events.slice(0, limit);
+    }
+    // ===========================
+    // Metrics & Analytics
+    // ===========================
+    async getTransparencyMetrics() {
+        const agents = Array.from(this.agentHierarchy.values());
+        const statuses = Array.from(this.agentStatuses.values());
+        // Calculate agents by level
+        const agentsByLevel = {};
+        agents.forEach((agent)=>{
+            agentsByLevel[agent.level] = (agentsByLevel[agent.level] || 0) + 1;
+        });
+        // Calculate agents by state
+        const agentsByState = {};
+        agents.forEach((agent)=>{
+            agentsByState[agent.state] = (agentsByState[agent.state] || 0) + 1;
+        });
+        // Calculate agents by type
+        const agentsByType = {};
+        agents.forEach((agent)=>{
+            agentsByType[agent.type] = (agentsByType[agent.type] || 0) + 1;
+        });
+        // Calculate total tokens
+        const totalTokensConsumed = agents.reduce((sum, agent)=>sum + agent.tokensUsed, 0);
+        const totalTokensSaved = this.calculateTokensSaved();
+        // Calculate performance metrics
+        const executionTimes = agents.map((agent)=>agent.metrics.totalExecutionTimeMs);
+        const averageExecutionTimeMs = executionTimes.length > 0 ? executionTimes.reduce((sum, time)=>sum + time, 0) / executionTimes.length : 0;
+        // Calculate failure rate
+        const terminatedAgents = agents.filter((agent)=>agent.state === 'terminated').length;
+        const failureRate = agents.length > 0 ? terminatedAgents / agents.length * 100 : 0;
+        // Calculate hierarchy depth
+        const hierarchyDepth = Math.max(...agents.map((agent)=>agent.level), 0);
+        // Calculate dependency resolution rate
+        const totalDependencies = agents.reduce((sum, agent)=>sum + agent.waitingFor.length + agent.completedDependencies.length, 0);
+        const completedDependencies = agents.reduce((sum, agent)=>sum + agent.completedDependencies.length, 0);
+        const dependencyResolutionRate = totalDependencies > 0 ? completedDependencies / totalDependencies * 100 : 100;
+        // Event stream statistics
+        const eventTypes = {};
+        this.lifecycleEvents.forEach((event)=>{
+            eventTypes[event.eventType] = (eventTypes[event.eventType] || 0) + 1;
+        });
+        const recentEvents = this.lifecycleEvents.filter((event)=>Date.now() - event.timestamp.getTime() < 60000 // Last minute
+        );
+        const eventsPerSecond = recentEvents.length / 60;
+        return {
+            totalAgents: agents.length,
+            agentsByLevel,
+            agentsByState,
+            agentsByType,
+            totalTokensConsumed,
+            totalTokensSaved,
+            averageExecutionTimeMs,
+            failureRate,
+            averagePauseResumeLatencyMs: this.calculateAveragePauseResumeLatency(),
+            hierarchyDepth,
+            dependencyResolutionRate,
+            eventStreamStats: {
+                totalEvents: this.lifecycleEvents.length,
+                eventsPerSecond,
+                eventTypes
+            }
+        };
+    }
+    async getAgentPerformanceMetrics(agentId) {
+        const hierarchyNode = this.agentHierarchy.get(agentId);
+        const status = this.agentStatuses.get(agentId);
+        if (!hierarchyNode || !status) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        return {
+            agentId,
+            executionMetrics: hierarchyNode.metrics,
+            currentPerformance: {
+                tokenUsageRate: status.tokenUsageRate,
+                memoryUsage: status.memoryUsage,
+                cpuUsage: status.cpuUsage,
+                progress: status.progress
+            },
+            tokenMetrics: {
+                totalUsed: hierarchyNode.tokensUsed,
+                budget: hierarchyNode.tokenBudget,
+                utilizationRate: hierarchyNode.tokenBudget > 0 ? hierarchyNode.tokensUsed / hierarchyNode.tokenBudget * 100 : 0
+            },
+            stateMetrics: {
+                totalStateChanges: this.lifecycleEvents.filter((event)=>event.agentId === agentId && event.eventType === 'state_changed').length,
+                pauseCount: hierarchyNode.metrics.pauseCount,
+                resumeCount: hierarchyNode.metrics.resumeCount,
+                checkpointCount: hierarchyNode.metrics.checkpointCount
+            },
+            errorMetrics: {
+                totalErrors: status.recentErrors.length,
+                criticalErrors: status.recentErrors.filter((e)=>e.severity === 'critical').length,
+                recentErrors: status.recentErrors.slice(-5)
+            }
+        };
+    }
+    async getHierarchyAnalytics() {
+        const agents = Array.from(this.agentHierarchy.values());
+        const rootAgents = agents.filter((agent)=>!agent.parentAgentId);
+        // Calculate depth
+        const depth = Math.max(...agents.map((agent)=>agent.level), 0);
+        // Calculate branching factor
+        const parentAgents = agents.filter((agent)=>agent.childAgentIds.length > 0);
+        const totalChildren = parentAgents.reduce((sum, agent)=>sum + agent.childAgentIds.length, 0);
+        const branchingFactor = parentAgents.length > 0 ? totalChildren / parentAgents.length : 0;
+        // Calculate balance (standard deviation of children per parent)
+        const childCounts = parentAgents.map((agent)=>agent.childAgentIds.length);
+        const avgChildren = branchingFactor;
+        const variance = childCounts.reduce((sum, count)=>{
+            return sum + Math.pow(count - avgChildren, 2);
+        }, 0) / (parentAgents.length || 1);
+        const balance = Math.max(0, 100 - Math.sqrt(variance));
+        // Calculate efficiency (active agents vs total agents)
+        const activeAgents = agents.filter((agent)=>!agent.isPaused && agent.state !== 'terminated').length;
+        const efficiency = agents.length > 0 ? activeAgents / agents.length * 100 : 0;
+        return {
+            depth,
+            branchingFactor,
+            balance,
+            efficiency
+        };
+    }
+    // ===========================
+    // Event Listeners
+    // ===========================
+    async registerEventListener(listener) {
+        this.eventListeners.add(listener);
+        this.logger.debug('Transparency event listener registered');
+    }
+    async unregisterEventListener(listener) {
+        this.eventListeners.delete(listener);
+        this.logger.debug('Transparency event listener unregistered');
+    }
+    // ===========================
+    // Private Helper Methods
+    // ===========================
+    getDefaultConfig() {
+        return {
+            enableRealTimeMonitoring: true,
+            enableEventStreaming: true,
+            eventRetentionHours: 24,
+            metricsUpdateIntervalMs: 5000,
+            heartbeatIntervalMs: 10000,
+            enablePerformanceTracking: true,
+            enableDependencyTracking: true,
+            maxEventsInMemory: 10000,
+            enableHierarchyNotifications: true
+        };
+    }
+    calculateAgentLevel(agentId, parentAgentId) {
+        if (!parentAgentId) {
+            return 1; // Root level
+        }
+        const parent = this.agentHierarchy.get(parentAgentId);
+        if (parent) {
+            return parent.level + 1;
+        }
+        return 2; // Default to level 2 if parent not found
+    }
+    getActivityForState(state, reason) {
+        const stateActivities = {
+            idle: 'Idle',
+            active: 'Executing task',
+            paused: 'Paused',
+            terminated: 'Terminated',
+            error: 'Error state',
+            completing: 'Completing task',
+            checkpointing: 'Creating checkpoint',
+            waiting_for_dependency: 'Waiting for dependency'
+        };
+        let activity = stateActivities[state] || 'Unknown state';
+        if (reason) {
+            activity += ` (${reason})`;
+        }
+        return activity;
+    }
+    recordLifecycleEvent(event) {
+        this.lifecycleEvents.push(event);
+        // Enforce event retention limit
+        if (this.lifecycleEvents.length > this.config.maxEventsInMemory) {
+            const excess = this.lifecycleEvents.length - this.config.maxEventsInMemory;
+            this.lifecycleEvents.splice(0, excess);
+        }
+        // Notify listeners
+        this.eventListeners.forEach((listener)=>{
+            if (listener.onLifecycleEvent) {
+                try {
+                    listener.onLifecycleEvent(event);
+                } catch (error) {
+                    this.logger.error('Error in lifecycle event listener', error);
+                }
+            }
+        });
+        this.emit('lifecycleEvent', event);
+    }
+    notifyHierarchyChange(type, agentId, data) {
+        if (!this.config.enableHierarchyNotifications) {
+            return;
+        }
+        this.eventListeners.forEach((listener)=>{
+            if (listener.onHierarchyChange) {
+                try {
+                    listener.onHierarchyChange({
+                        type,
+                        agentId,
+                        data
+                    });
+                } catch (error) {
+                    this.logger.error('Error in hierarchy change listener', error);
+                }
+            }
+        });
+        this.emit('hierarchyChange', {
+            type,
+            agentId,
+            data
+        });
+    }
+    notifyStateChange(agentId, previousState, newState) {
+        const timestamp = new Date();
+        this.eventListeners.forEach((listener)=>{
+            if (listener.onAgentStateChange) {
+                try {
+                    listener.onAgentStateChange({
+                        agentId,
+                        previousState,
+                        newState,
+                        timestamp
+                    });
+                } catch (error) {
+                    this.logger.error('Error in state change listener', error);
+                }
+            }
+        });
+        this.emit('agentStateChange', {
+            agentId,
+            previousState,
+            newState,
+            timestamp
+        });
+    }
+    updateMetrics() {
+        if (!this.isMonitoring) {
+            return;
+        }
+        this.getTransparencyMetrics().then((metrics)=>{
+            this.eventListeners.forEach((listener)=>{
+                if (listener.onMetricsUpdate) {
+                    try {
+                        listener.onMetricsUpdate(metrics);
+                    } catch (error) {
+                        this.logger.error('Error in metrics update listener', error);
+                    }
+                }
+            });
+            this.emit('metricsUpdate', metrics);
+        }).catch((error)=>{
+            this.logger.error('Error updating transparency metrics', error);
+        });
+    }
+    checkAgentHeartbeats() {
+        const now = new Date();
+        const staleThreshold = this.config.heartbeatIntervalMs * 3; // 3 intervals
+        this.agentStatuses.forEach((status, agentId)=>{
+            const timeSinceHeartbeat = now.getTime() - status.lastHeartbeat.getTime();
+            if (timeSinceHeartbeat > staleThreshold) {
+                // Agent hasn't sent heartbeat recently
+                status.recentErrors.push({
+                    timestamp: now,
+                    error: `Agent heartbeat timeout (${Math.round(timeSinceHeartbeat / 1000)}s)`,
+                    severity: 'warning'
+                });
+                // Keep only recent errors
+                if (status.recentErrors.length > 10) {
+                    status.recentErrors.splice(0, status.recentErrors.length - 10);
+                }
+            }
+        });
+    }
+    checkPerformanceThresholds(agentId) {
+        const status = this.agentStatuses.get(agentId);
+        if (!status) {
+            return;
+        }
+        const alerts = [];
+        // Check token usage rate
+        if (status.tokenUsageRate > this.performanceThresholds.maxTokenUsageRate) {
+            alerts.push({
+                metric: 'tokenUsageRate',
+                value: status.tokenUsageRate,
+                threshold: this.performanceThresholds.maxTokenUsageRate,
+                severity: status.tokenUsageRate > this.performanceThresholds.maxTokenUsageRate * 1.5 ? 'critical' : 'warning'
+            });
+        }
+        // Check memory usage
+        if (status.memoryUsage > this.performanceThresholds.maxMemoryUsage) {
+            alerts.push({
+                metric: 'memoryUsage',
+                value: status.memoryUsage,
+                threshold: this.performanceThresholds.maxMemoryUsage,
+                severity: 'critical'
+            });
+        }
+        // Check CPU usage
+        if (status.cpuUsage > this.performanceThresholds.maxCpuUsage) {
+            alerts.push({
+                metric: 'cpuUsage',
+                value: status.cpuUsage,
+                threshold: this.performanceThresholds.maxCpuUsage,
+                severity: status.cpuUsage > 95 ? 'critical' : 'warning'
+            });
+        }
+        // Notify listeners of performance alerts
+        alerts.forEach((alert)=>{
+            this.eventListeners.forEach((listener)=>{
+                if (listener.onPerformanceAlert) {
+                    try {
+                        listener.onPerformanceAlert({
+                            agentId,
+                            ...alert
+                        });
+                    } catch (error) {
+                        this.logger.error('Error in performance alert listener', error);
+                    }
+                }
+            });
+            this.emit('performanceAlert', {
+                agentId,
+                ...alert
+            });
+        });
+    }
+    calculateTokensSaved() {
+        const pausedAgents = Array.from(this.agentStatuses.values()).filter((status)=>status.isPaused);
+        return pausedAgents.reduce((total, status)=>{
+            const timeSincePause = Date.now() - status.lastHeartbeat.getTime();
+            const estimatedTokensSaved = status.tokenUsageRate * timeSincePause / 1000;
+            return total + Math.max(0, estimatedTokensSaved);
+        }, 0);
+    }
+    calculateAveragePauseResumeLatencyMs() {
+        const events = this.lifecycleEvents.filter((event)=>event.eventType === 'paused' || event.eventType === 'resumed');
+        if (events.length < 2) {
+            return 0;
+        }
+        // Pair pause/resume events and calculate latencies
+        const latencies = [];
+        const pauseEvents = new Map();
+        events.forEach((event)=>{
+            if (event.eventType === 'paused') {
+                pauseEvents.set(event.agentId, event);
+            } else if (event.eventType === 'resumed') {
+                const pauseEvent = pauseEvents.get(event.agentId);
+                if (pauseEvent && event.performanceImpact.duration) {
+                    latencies.push(event.performanceImpact.duration);
+                }
+                pauseEvents.delete(event.agentId);
+            }
+        });
+        return latencies.length > 0 ? latencies.reduce((sum, latency)=>sum + latency, 0) / latencies.length : 0;
+    }
+}
+
+//# sourceMappingURL=transparency-system.js.map