claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/coordination/event-bus/qe-event-bus.js

@@ -4,780 +4,640 @@
  * Target: 10,000+ events/sec with 52x speedup via Rust WASM regex engine
  *
  * Sprint 1.2 Deliverable 1.2.1: Real Rust WASM Integration
- */
-
-import { EventEmitter } from 'events';
-import { performance } from 'perf_hooks';
-import { createHash } from 'crypto';
-
-// REAL WASM Regex Engine Import (Sprint 1.2)
-let wasmEngine = null;
-let wasmAvailable = false;
-
-// Attempt to load WASM module with graceful fallback
-async function initializeWASM() {
-  try {
-    // Import the REAL compiled Rust WASM module (from _bg.js which has RegexEngine)
-    const wasm = await import('../../wasm-regex-engine/pkg/wasm_regex_engine_bg.js');
-
-    // Create regex engine for event validation patterns
-    const eventPatterns = [
-      '^cfn\\.loop\\.',           // CFN Loop events
-      '^agent\\.',                // Agent lifecycle events
-      '^swarm\\.',                // Swarm coordination events
-      '^fleet\\.',                // Fleet management events
-      '^compliance\\.',           // Compliance validation events
-      '^performance\\.',          // Performance monitoring events
-      '^dashboard\\.',            // Dashboard events
-      '^eventbus\\.'              // Event bus internal events
-    ];
-
-    wasmEngine = new wasm.RegexEngine(eventPatterns);
-    wasmAvailable = true;
-
-    console.log('✅ WASM Regex Engine loaded successfully (52x acceleration enabled)');
-    console.log(`   Patterns compiled: ${wasmEngine.pattern_count()}`);
-
-    return true;
-  } catch (error) {
-    console.warn('⚠️ WASM unavailable, falling back to JavaScript validation:', error.message);
-    wasmAvailable = false;
-    return false;
-  }
-}
-
-// Initialize WASM on module load
-const wasmInitPromise = initializeWASM();
-
+ */ import { EventEmitter } from "events";
+import { performance } from "perf_hooks";
+// REAL WASM Regex Engine Import (Sprint 1.2)
+let wasmEngine = null;
+let wasmAvailable = false;
+// Attempt to load WASM module with graceful fallback
+async function initializeWASM() {
+    try {
+        // Import the REAL compiled Rust WASM module (from _bg.js which has RegexEngine)
+        const wasm = await import("../../wasm-regex-engine/pkg/wasm_regex_engine_bg.js");
+        // Create regex engine for event validation patterns
+        const eventPatterns = [
+            '^cfn\\.loop\\.',
+            '^agent\\.',
+            '^swarm\\.',
+            '^fleet\\.',
+            '^compliance\\.',
+            '^performance\\.',
+            '^dashboard\\.',
+            '^eventbus\\.' // Event bus internal events
+        ];
+        wasmEngine = new wasm.RegexEngine(eventPatterns);
+        wasmAvailable = true;
+        console.log('✅ WASM Regex Engine loaded successfully (52x acceleration enabled)');
+        console.log(`   Patterns compiled: ${wasmEngine.pattern_count()}`);
+        return true;
+    } catch (error) {
+        console.warn('⚠️ WASM unavailable, falling back to JavaScript validation:', error.message);
+        wasmAvailable = false;
+        return false;
+    }
+}
+// Initialize WASM on module load
+const wasmInitPromise = initializeWASM();
 /**
  * High-Performance Event Bus with WASM Acceleration
  * Implements mandatory Redis pub/sub coordination (Critical Rule #19)
- */
-export class QEEventBus extends EventEmitter {
-  constructor(config = {}) {
-    super();
-
-    this.config = {
-      throughputTarget: 10000,        // events/sec
-      latencyTarget: 50,              // ms
-      workerThreads: 4,
-      batchSize: 100,
-      batchTimeout: 10,               // ms
-      enableWASM: true,
-      enableSIMD: true,
-      enableZeroCopy: true,
-      priorityLevels: 10,
-      failureThreshold: 5,            // Circuit breaker: failures before opening
-      recoveryTimeout: 30000,         // Circuit breaker: 30s before retry
-      ...config
-    };
-
-    // Event routing tables (hash-based O(1) lookup)
-    this.subscribers = new Map();     // pattern -> Set<handler>
-    this.routingCache = new Map();    // eventType -> cachedRoute
-    this.priorityQueues = Array.from({ length: this.config.priorityLevels }, () => []);
-
-    // Performance metrics
-    this.metrics = {
-      eventsProcessed: 0,
-      eventsPublished: 0,
-      totalLatency: 0,
-      wasmValidations: 0,
-      jsValidations: 0,
-      wasmErrors: 0,
-      wasmCleanupsPerformed: 0,
-      batchesProcessed: 0,
-      routingHits: 0,
-      routingMisses: 0,
-      errors: 0,
-      throughput: 0,
-      avgLatency: 0,
-      // Circuit breaker metrics
-      circuitState: 'CLOSED',
-      circuitOpens: 0,
-      eventsRejected: 0,
-      bypassEvents: 0,
-      recoveryAttempts: 0
-    };
-
-    // Circuit breaker state machine
-    this.circuitBreaker = {
-      state: 'CLOSED',                           // CLOSED | OPEN | HALF-OPEN
-      consecutiveFailures: 0,
-      failureThreshold: this.config.failureThreshold,
-      recoveryTimeout: this.config.recoveryTimeout,
-      halfOpenSuccesses: 0,
-      halfOpenThreshold: 3,                      // Successes needed to close circuit
-      lastStateChange: Date.now(),
-      openedAt: null
-    };
-
-    // Batching state
-    this.eventBatch = [];
-    this.batchTimer = null;
-
-    // WASM state
-    this.wasmReady = false;
-
-    // Active state
-    this.active = false;
-    this.startTime = null;
-  }
-
-  /**
+ */ export class QEEventBus extends EventEmitter {
+    /**
    * Initialize QE Event Bus with WASM acceleration
-   */
-  async initialize() {
-    console.log('🚀 Initializing QE Event Bus with WASM acceleration...');
-
-    try {
-      // Wait for WASM initialization
-      await wasmInitPromise;
-      this.wasmReady = wasmAvailable;
-
-      if (this.wasmReady) {
-        console.log('✅ WASM Regex Engine ready for 52x speedup');
-        console.log('   SIMD validation: ENABLED');
-        console.log('   Zero-copy batching: ENABLED');
-        console.log('   Hash-based routing: ENABLED');
-      } else {
-        console.log('⚠️ Running in JavaScript fallback mode');
-      }
-
-      // Start batch processing
-      this.enableBatching();
-
-      this.active = true;
-      this.startTime = performance.now();
-
-      console.log(`✅ QE Event Bus initialized (target: ${this.config.throughputTarget} events/sec)`);
-
-      return true;
-    } catch (error) {
-      console.error('❌ Failed to initialize QE Event Bus:', error.message);
-      throw error;
-    }
-  }
-
-  /**
+   */ async initialize() {
+        console.log('🚀 Initializing QE Event Bus with WASM acceleration...');
+        try {
+            // Wait for WASM initialization
+            await wasmInitPromise;
+            this.wasmReady = wasmAvailable;
+            if (this.wasmReady) {
+                console.log('✅ WASM Regex Engine ready for 52x speedup');
+                console.log('   SIMD validation: ENABLED');
+                console.log('   Zero-copy batching: ENABLED');
+                console.log('   Hash-based routing: ENABLED');
+            } else {
+                console.log('⚠️ Running in JavaScript fallback mode');
+            }
+            // Start batch processing
+            this.enableBatching();
+            this.active = true;
+            this.startTime = performance.now();
+            console.log(`✅ QE Event Bus initialized (target: ${this.config.throughputTarget} events/sec)`);
+            return true;
+        } catch (error) {
+            console.error('❌ Failed to initialize QE Event Bus:', error.message);
+            throw error;
+        }
+    }
+    /**
    * Subscribe to event pattern with handler
    * Builds hash-based routing table for O(1) lookup
-   */
-  subscribe(pattern, handler, options = {}) {
-    if (!this.subscribers.has(pattern)) {
-      this.subscribers.set(pattern, new Set());
-    }
-
-    const handlerInfo = {
-      handler,
-      priority: options.priority || 5,
-      batchSize: options.batchSize || this.config.batchSize,
-      filter: options.filter
-    };
-
-    this.subscribers.get(pattern).add(handlerInfo);
-
-    // Invalidate routing cache for this pattern
-    this.routingCache.clear();
-
-    console.log(`📡 Subscribed to pattern: ${pattern} (priority: ${handlerInfo.priority})`);
-
-    return () => this.unsubscribe(pattern, handler);
-  }
-
-  /**
+   */ subscribe(pattern, handler, options = {}) {
+        if (!this.subscribers.has(pattern)) {
+            this.subscribers.set(pattern, new Set());
+        }
+        const handlerInfo = {
+            handler,
+            priority: options.priority || 5,
+            batchSize: options.batchSize || this.config.batchSize,
+            filter: options.filter
+        };
+        this.subscribers.get(pattern).add(handlerInfo);
+        // Invalidate routing cache for this pattern
+        this.routingCache.clear();
+        console.log(`📡 Subscribed to pattern: ${pattern} (priority: ${handlerInfo.priority})`);
+        return ()=>this.unsubscribe(pattern, handler);
+    }
+    /**
    * Unsubscribe handler from pattern
-   */
-  unsubscribe(pattern, handler) {
-    const handlers = this.subscribers.get(pattern);
-    if (handlers) {
-      handlers.forEach(info => {
-        if (info.handler === handler) {
-          handlers.delete(info);
-        }
-      });
-
-      if (handlers.size === 0) {
-        this.subscribers.delete(pattern);
-      }
-
-      this.routingCache.clear();
-    }
-  }
-
-  /**
+   */ unsubscribe(pattern, handler) {
+        const handlers = this.subscribers.get(pattern);
+        if (handlers) {
+            handlers.forEach((info)=>{
+                if (info.handler === handler) {
+                    handlers.delete(info);
+                }
+            });
+            if (handlers.size === 0) {
+                this.subscribers.delete(pattern);
+            }
+            this.routingCache.clear();
+        }
+    }
+    /**
    * Publish event with WASM-accelerated validation
    * Lines 352-396: WASM validation logic
-   */
-  async publish(eventType, data, options = {}) {
-    if (!this.active) {
-      throw new Error('QE Event Bus not active');
-    }
-
-    const startTime = performance.now();
-    const priority = options.priority || 5;
-
-    // Create event envelope
-    const event = {
-      id: this.generateEventId(),
-      type: eventType,
-      data,
-      timestamp: startTime,
-      priority,
-      source: options.source || 'unknown'
-    };
-
-    // WASM-ACCELERATED VALIDATION (52x speedup)
-    // Lines 352-396: Replace with WASM validation
-    const validationStart = performance.now();
-    let isValid = false;
-
-    if (this.wasmReady && this.config.enableWASM) {
-      try {
-        // REAL WASM validation using compiled Rust regex engine
-        // has_match is the fastest check (SIMD-accelerated)
-        isValid = wasmEngine.has_match(eventType);
-        this.metrics.wasmValidations++;
-
-        // Optional: Get detailed match info for logging
-        if (isValid && options.verbose) {
-          const matches = wasmEngine.match_all(eventType);
-          console.log(`✓ WASM validated: ${eventType}`, matches);
-        }
-      } catch (error) {
-        console.warn('⚠️ WASM validation failed, falling back to JS:', error.message);
-        isValid = this.validateEventTypeJS(eventType);
-        this.metrics.jsValidations++;
-        this.metrics.wasmErrors = (this.metrics.wasmErrors || 0) + 1;
-      } finally {
-        // Ensure WASM buffer cleanup even on error (Sprint 1.3 memory safety)
-        if (wasmEngine && typeof wasmEngine.clearBuffer === 'function') {
-          try {
-            wasmEngine.clearBuffer();
-          } catch (cleanupError) {
-            // Log but don't fail on cleanup errors
-            console.warn('⚠️ WASM buffer cleanup warning:', cleanupError.message);
-          }
-        }
-      }
-    } else {
-      // JavaScript fallback validation
-      isValid = this.validateEventTypeJS(eventType);
-      this.metrics.jsValidations++;
-    }
-
-    const validationTime = performance.now() - validationStart;
-
-    if (!isValid) {
-      this.metrics.errors++;
-      throw new Error(`Invalid event type: ${eventType} (validation: ${validationTime.toFixed(3)}ms)`);
-    }
-
-    // Add to priority queue
-    this.priorityQueues[priority].push(event);
-    this.metrics.eventsPublished++;
-
-    // High priority events are processed immediately
-    if (priority >= 8) {
-      await this.processEvent(event);
-    } else {
-      // Normal/low priority events are batched
-      this.eventBatch.push(event);
-
-      // Process batch if full
-      if (this.eventBatch.length >= this.config.batchSize) {
-        await this.processBatch();
-      }
-    }
-
-    const totalLatency = performance.now() - startTime;
-    this.metrics.totalLatency += totalLatency;
-
-    return {
-      eventId: event.id,
-      latency: totalLatency,
-      validationTime,
-      wasmAccelerated: this.wasmReady && this.config.enableWASM
-    };
-  }
-
-  /**
+   */ async publish(eventType, data, options = {}) {
+        if (!this.active) {
+            throw new Error('QE Event Bus not active');
+        }
+        const startTime = performance.now();
+        const priority = options.priority || 5;
+        // Create event envelope
+        const event = {
+            id: this.generateEventId(),
+            type: eventType,
+            data,
+            timestamp: startTime,
+            priority,
+            source: options.source || 'unknown'
+        };
+        // WASM-ACCELERATED VALIDATION (52x speedup)
+        // Lines 352-396: Replace with WASM validation
+        const validationStart = performance.now();
+        let isValid = false;
+        if (this.wasmReady && this.config.enableWASM) {
+            try {
+                // REAL WASM validation using compiled Rust regex engine
+                // has_match is the fastest check (SIMD-accelerated)
+                isValid = wasmEngine.has_match(eventType);
+                this.metrics.wasmValidations++;
+                // Optional: Get detailed match info for logging
+                if (isValid && options.verbose) {
+                    const matches = wasmEngine.match_all(eventType);
+                    console.log(`✓ WASM validated: ${eventType}`, matches);
+                }
+            } catch (error) {
+                console.warn('⚠️ WASM validation failed, falling back to JS:', error.message);
+                isValid = this.validateEventTypeJS(eventType);
+                this.metrics.jsValidations++;
+                this.metrics.wasmErrors = (this.metrics.wasmErrors || 0) + 1;
+            } finally{
+                // Ensure WASM buffer cleanup even on error (Sprint 1.3 memory safety)
+                if (wasmEngine && typeof wasmEngine.clearBuffer === 'function') {
+                    try {
+                        wasmEngine.clearBuffer();
+                    } catch (cleanupError) {
+                        // Log but don't fail on cleanup errors
+                        console.warn('⚠️ WASM buffer cleanup warning:', cleanupError.message);
+                    }
+                }
+            }
+        } else {
+            // JavaScript fallback validation
+            isValid = this.validateEventTypeJS(eventType);
+            this.metrics.jsValidations++;
+        }
+        const validationTime = performance.now() - validationStart;
+        if (!isValid) {
+            this.metrics.errors++;
+            throw new Error(`Invalid event type: ${eventType} (validation: ${validationTime.toFixed(3)}ms)`);
+        }
+        // Add to priority queue
+        this.priorityQueues[priority].push(event);
+        this.metrics.eventsPublished++;
+        // High priority events are processed immediately
+        if (priority >= 8) {
+            await this.processEvent(event);
+        } else {
+            // Normal/low priority events are batched
+            this.eventBatch.push(event);
+            // Process batch if full
+            if (this.eventBatch.length >= this.config.batchSize) {
+                await this.processBatch();
+            }
+        }
+        const totalLatency = performance.now() - startTime;
+        this.metrics.totalLatency += totalLatency;
+        return {
+            eventId: event.id,
+            latency: totalLatency,
+            validationTime,
+            wasmAccelerated: this.wasmReady && this.config.enableWASM
+        };
+    }
+    /**
    * JavaScript fallback validation (no WASM)
-   */
-  validateEventTypeJS(eventType) {
-    // JavaScript regex validation (slower fallback)
-    const validPatterns = [
-      /^cfn\.loop\./,
-      /^agent\./,
-      /^swarm\./,
-      /^fleet\./,
-      /^compliance\./,
-      /^performance\./,
-      /^dashboard\./,
-      /^eventbus\./
-    ];
-
-    return validPatterns.some(pattern => pattern.test(eventType));
-  }
-
-  /**
+   */ validateEventTypeJS(eventType) {
+        // JavaScript regex validation (slower fallback)
+        const validPatterns = [
+            /^cfn\.loop\./,
+            /^agent\./,
+            /^swarm\./,
+            /^fleet\./,
+            /^compliance\./,
+            /^performance\./,
+            /^dashboard\./,
+            /^eventbus\./
+        ];
+        return validPatterns.some((pattern)=>pattern.test(eventType));
+    }
+    /**
    * Enable batching for high throughput
-   */
-  enableBatching() {
-    this.batchTimer = setInterval(() => {
-      if (this.eventBatch.length > 0) {
-        this.processBatch();
-      }
-    }, this.config.batchTimeout);
-  }
-
-  /**
+   */ enableBatching() {
+        this.batchTimer = setInterval(()=>{
+            if (this.eventBatch.length > 0) {
+                this.processBatch();
+            }
+        }, this.config.batchTimeout);
+    }
+    /**
    * Process event batch with zero-copy optimization
    * Lines 523-530: Zero-copy batching implementation
-   */
-  async processBatch() {
-    if (this.eventBatch.length === 0) return;
-
-    const batchStart = performance.now();
-
-    // ZERO-COPY BATCH PROCESSING (Lines 523-530)
-    // Extract batch without copying (swap reference)
-    const batch = this.eventBatch;
-    this.eventBatch = [];
-
-    try {
-      // SIMD-style parallel processing (simulate with Promise.all)
-      await Promise.all(batch.map(event => this.processEvent(event)));
-
-      this.metrics.batchesProcessed++;
-
-      const batchTime = performance.now() - batchStart;
-      const eventsPerSec = (batch.length / (batchTime / 1000)).toFixed(0);
-
-      if (batch.length > 10) {
-        console.log(`📦 Batch processed: ${batch.length} events in ${batchTime.toFixed(2)}ms (${eventsPerSec} events/sec)`);
-      }
-    } catch (error) {
-      console.error('❌ Batch processing failed:', error.message);
-      this.metrics.errors++;
-    }
-  }
-
-  /**
+   */ async processBatch() {
+        if (this.eventBatch.length === 0) return;
+        const batchStart = performance.now();
+        // ZERO-COPY BATCH PROCESSING (Lines 523-530)
+        // Extract batch without copying (swap reference)
+        const batch = this.eventBatch;
+        this.eventBatch = [];
+        try {
+            // SIMD-style parallel processing (simulate with Promise.all)
+            await Promise.all(batch.map((event)=>this.processEvent(event)));
+            this.metrics.batchesProcessed++;
+            const batchTime = performance.now() - batchStart;
+            const eventsPerSec = (batch.length / (batchTime / 1000)).toFixed(0);
+            if (batch.length > 10) {
+                console.log(`📦 Batch processed: ${batch.length} events in ${batchTime.toFixed(2)}ms (${eventsPerSec} events/sec)`);
+            }
+        } catch (error) {
+            console.error('❌ Batch processing failed:', error.message);
+            this.metrics.errors++;
+        }
+    }
+    /**
    * Process single event with hash-based routing and circuit breaker protection
    * Lines 623-646: O(1) hash-based routing implementation
-   */
-  async processEvent(event) {
-    // CIRCUIT BREAKER: Check if event should be processed
-    // Priority 8-9 events bypass circuit breaker for critical coordination
-    if (!this.isHighPriority(event)) {
-      const canProcess = this.checkCircuit();
-      if (!canProcess) {
-        this.metrics.eventsRejected++;
-        const error = new Error(`Circuit breaker OPEN - event rejected: ${event.type}`);
-        error.code = 'CIRCUIT_OPEN';
-        throw error;
-      }
-    } else {
-      // Track priority bypass events
-      this.metrics.bypassEvents++;
-    }
-
-    const routingStart = performance.now();
-
-    try {
-      // HASH-BASED O(1) ROUTING (Lines 623-646)
-      // Check routing cache first
-      let routes = this.routingCache.get(event.type);
-
-      if (!routes) {
-        // Cache miss: compute routes and cache them
-        routes = this.computeRoutes(event.type);
-        this.routingCache.set(event.type, routes);
-        this.metrics.routingMisses++;
-
-        // Limit cache size to prevent memory bloat
-        if (this.routingCache.size > 10000) {
-          // Evict oldest 1000 entries
-          const keysToDelete = Array.from(this.routingCache.keys()).slice(0, 1000);
-          keysToDelete.forEach(key => this.routingCache.delete(key));
-        }
-      } else {
-        this.metrics.routingHits++;
-      }
-
-      const routingTime = performance.now() - routingStart;
-
-      // Execute handlers
-      const handlerStart = performance.now();
-      const handlerPromises = routes.map(({ handler, filter }) => {
-        // Apply filter if present
-        if (filter && !filter(event)) {
-          return Promise.resolve();
-        }
-
-        // Execute handler
-        return Promise.resolve(handler(event)).catch(error => {
-          console.error(`❌ Handler failed for ${event.type}:`, error.message);
-          this.metrics.errors++;
-          throw error; // Re-throw to trigger circuit breaker
-        });
-      });
-
-      await Promise.all(handlerPromises);
-
-      const handlerTime = performance.now() - handlerStart;
-      this.metrics.eventsProcessed++;
-
-      // Emit for local listeners
-      this.emit('event', event);
-      this.emit(`event:${event.type}`, event);
-
-      // Performance logging (only for slow events)
-      if (handlerTime > 10) {
-        console.warn(`⚠️ Slow event processing: ${event.type} (routing: ${routingTime.toFixed(3)}ms, handlers: ${handlerTime.toFixed(3)}ms)`);
-      }
-
-      // CIRCUIT BREAKER: Record successful processing
-      this.recordSuccess();
-
-    } catch (error) {
-      // CIRCUIT BREAKER: Record failure
-      this.recordFailure(error);
-      throw error; // Re-throw for caller
-    }
-  }
-
-  /**
+   */ async processEvent(event) {
+        // CIRCUIT BREAKER: Check if event should be processed
+        // Priority 8-9 events bypass circuit breaker for critical coordination
+        if (!this.isHighPriority(event)) {
+            const canProcess = this.checkCircuit();
+            if (!canProcess) {
+                this.metrics.eventsRejected++;
+                const error = new Error(`Circuit breaker OPEN - event rejected: ${event.type}`);
+                error.code = 'CIRCUIT_OPEN';
+                throw error;
+            }
+        } else {
+            // Track priority bypass events
+            this.metrics.bypassEvents++;
+        }
+        const routingStart = performance.now();
+        try {
+            // HASH-BASED O(1) ROUTING (Lines 623-646)
+            // Check routing cache first
+            let routes = this.routingCache.get(event.type);
+            if (!routes) {
+                // Cache miss: compute routes and cache them
+                routes = this.computeRoutes(event.type);
+                this.routingCache.set(event.type, routes);
+                this.metrics.routingMisses++;
+                // Limit cache size to prevent memory bloat
+                if (this.routingCache.size > 10000) {
+                    // Evict oldest 1000 entries
+                    const keysToDelete = Array.from(this.routingCache.keys()).slice(0, 1000);
+                    keysToDelete.forEach((key)=>this.routingCache.delete(key));
+                }
+            } else {
+                this.metrics.routingHits++;
+            }
+            const routingTime = performance.now() - routingStart;
+            // Execute handlers
+            const handlerStart = performance.now();
+            const handlerPromises = routes.map(({ handler, filter })=>{
+                // Apply filter if present
+                if (filter && !filter(event)) {
+                    return Promise.resolve();
+                }
+                // Execute handler
+                return Promise.resolve(handler(event)).catch((error)=>{
+                    console.error(`❌ Handler failed for ${event.type}:`, error.message);
+                    this.metrics.errors++;
+                    throw error; // Re-throw to trigger circuit breaker
+                });
+            });
+            await Promise.all(handlerPromises);
+            const handlerTime = performance.now() - handlerStart;
+            this.metrics.eventsProcessed++;
+            // Emit for local listeners
+            this.emit('event', event);
+            this.emit(`event:${event.type}`, event);
+            // Performance logging (only for slow events)
+            if (handlerTime > 10) {
+                console.warn(`⚠️ Slow event processing: ${event.type} (routing: ${routingTime.toFixed(3)}ms, handlers: ${handlerTime.toFixed(3)}ms)`);
+            }
+            // CIRCUIT BREAKER: Record successful processing
+            this.recordSuccess();
+        } catch (error) {
+            // CIRCUIT BREAKER: Record failure
+            this.recordFailure(error);
+            throw error; // Re-throw for caller
+        }
+    }
+    /**
    * Compute routes for event type using pattern matching
    * Uses JavaScript regex (compiled and cached for O(1) routing)
-   */
-  computeRoutes(eventType) {
-    const routes = [];
-
-    for (const [pattern, handlers] of this.subscribers.entries()) {
-      // JavaScript regex pattern matching (very fast for routing)
-      // WASM is used for event validation, JS is fine for routing patterns
-      try {
-        const regex = new RegExp(pattern);
-        if (regex.test(eventType)) {
-          handlers.forEach(handlerInfo => {
-            routes.push(handlerInfo);
-          });
-        }
-      } catch (error) {
-        // Invalid regex pattern, skip it
-        console.warn(`Invalid pattern: ${pattern}`, error.message);
-      }
-    }
-
-    // Sort by priority (higher priority first)
-    routes.sort((a, b) => b.priority - a.priority);
-
-    return routes;
-  }
-
-  /**
+   */ computeRoutes(eventType) {
+        const routes = [];
+        for (const [pattern, handlers] of this.subscribers.entries()){
+            // JavaScript regex pattern matching (very fast for routing)
+            // WASM is used for event validation, JS is fine for routing patterns
+            try {
+                const regex = new RegExp(pattern);
+                if (regex.test(eventType)) {
+                    handlers.forEach((handlerInfo)=>{
+                        routes.push(handlerInfo);
+                    });
+                }
+            } catch (error) {
+                // Invalid regex pattern, skip it
+                console.warn(`Invalid pattern: ${pattern}`, error.message);
+            }
+        }
+        // Sort by priority (higher priority first)
+        routes.sort((a, b)=>b.priority - a.priority);
+        return routes;
+    }
+    /**
    * Generate unique event ID
-   */
-  generateEventId() {
-    // High-performance ID generation
-    const timestamp = Date.now();
-    const random = Math.random().toString(36).substr(2, 9);
-    return `evt_${timestamp}_${random}`;
-  }
-
-  /**
+   */ generateEventId() {
+        // High-performance ID generation
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substr(2, 9);
+        return `evt_${timestamp}_${random}`;
+    }
+    /**
    * Get performance metrics
-   */
-  getMetrics() {
-    const uptime = this.startTime ? (performance.now() - this.startTime) / 1000 : 0;
-    const avgLatency = this.metrics.eventsProcessed > 0
-      ? this.metrics.totalLatency / this.metrics.eventsProcessed
-      : 0;
-    const throughput = uptime > 0
-      ? this.metrics.eventsProcessed / uptime
-      : 0;
-
-    return {
-      ...this.metrics,
-      avgLatency: avgLatency.toFixed(3),
-      throughput: throughput.toFixed(0),
-      uptime: uptime.toFixed(1),
-      wasmEnabled: this.wasmReady,
-      wasmSpeedup: this.wasmReady ? '52x' : 'N/A',
-      routingHitRate: this.metrics.routingMisses > 0
-        ? ((this.metrics.routingHits / (this.metrics.routingHits + this.metrics.routingMisses)) * 100).toFixed(1)
-        : '0',
-      targetThroughput: this.config.throughputTarget,
-      targetLatency: this.config.latencyTarget
-    };
-  }
-
-  /**
+   */ getMetrics() {
+        const uptime = this.startTime ? (performance.now() - this.startTime) / 1000 : 0;
+        const avgLatency = this.metrics.eventsProcessed > 0 ? this.metrics.totalLatency / this.metrics.eventsProcessed : 0;
+        const throughput = uptime > 0 ? this.metrics.eventsProcessed / uptime : 0;
+        return {
+            ...this.metrics,
+            avgLatency: avgLatency.toFixed(3),
+            throughput: throughput.toFixed(0),
+            uptime: uptime.toFixed(1),
+            wasmEnabled: this.wasmReady,
+            wasmSpeedup: this.wasmReady ? '52x' : 'N/A',
+            routingHitRate: this.metrics.routingMisses > 0 ? (this.metrics.routingHits / (this.metrics.routingHits + this.metrics.routingMisses) * 100).toFixed(1) : '0',
+            targetThroughput: this.config.throughputTarget,
+            targetLatency: this.config.latencyTarget
+        };
+    }
+    /**
    * Get real-time dashboard data
-   */
-  getDashboard() {
-    const metrics = this.getMetrics();
-
-    return {
-      status: this.active ? 'active' : 'inactive',
-      health: this.computeHealth(metrics),
-      metrics,
-      queues: {
-        batch: this.eventBatch.length,
-        priorities: this.priorityQueues.map((q, i) => ({
-          priority: i,
-          size: q.length
-        })).filter(q => q.size > 0)
-      },
-      cache: {
-        routes: this.routingCache.size,
-        hitRate: metrics.routingHitRate
-      },
-      wasm: {
-        enabled: this.wasmReady,
-        validations: this.metrics.wasmValidations,
-        fallbacks: this.metrics.jsValidations
-      },
-      circuitBreaker: this.getCircuitStatus()
-    };
-  }
-
-  /**
+   */ getDashboard() {
+        const metrics = this.getMetrics();
+        return {
+            status: this.active ? 'active' : 'inactive',
+            health: this.computeHealth(metrics),
+            metrics,
+            queues: {
+                batch: this.eventBatch.length,
+                priorities: this.priorityQueues.map((q, i)=>({
+                        priority: i,
+                        size: q.length
+                    })).filter((q)=>q.size > 0)
+            },
+            cache: {
+                routes: this.routingCache.size,
+                hitRate: metrics.routingHitRate
+            },
+            wasm: {
+                enabled: this.wasmReady,
+                validations: this.metrics.wasmValidations,
+                fallbacks: this.metrics.jsValidations
+            },
+            circuitBreaker: this.getCircuitStatus()
+        };
+    }
+    /**
    * Compute overall health score
-   */
-  computeHealth(metrics) {
-    let score = 100;
-
-    // Throughput check
-    if (parseFloat(metrics.throughput) < this.config.throughputTarget * 0.5) {
-      score -= 20;
-    }
-
-    // Latency check
-    if (parseFloat(metrics.avgLatency) > this.config.latencyTarget) {
-      score -= 15;
-    }
-
-    // Error rate check
-    const errorRate = metrics.eventsProcessed > 0
-      ? (metrics.errors / metrics.eventsProcessed) * 100
-      : 0;
-    if (errorRate > 5) {
-      score -= 25;
-    }
-
-    // Routing efficiency check
-    if (parseFloat(metrics.routingHitRate) < 80) {
-      score -= 10;
-    }
-
-    // Circuit breaker check
-    if (this.circuitBreaker.state === 'OPEN') {
-      score -= 30; // Major health impact when circuit is open
-    } else if (this.circuitBreaker.state === 'HALF-OPEN') {
-      score -= 15; // Moderate impact during recovery
-    }
-
-    return {
-      score: Math.max(0, score),
-      status: score >= 80 ? 'healthy' : score >= 60 ? 'degraded' : 'unhealthy'
-    };
-  }
-
-  /**
+   */ computeHealth(metrics) {
+        let score = 100;
+        // Throughput check
+        if (parseFloat(metrics.throughput) < this.config.throughputTarget * 0.5) {
+            score -= 20;
+        }
+        // Latency check
+        if (parseFloat(metrics.avgLatency) > this.config.latencyTarget) {
+            score -= 15;
+        }
+        // Error rate check
+        const errorRate = metrics.eventsProcessed > 0 ? metrics.errors / metrics.eventsProcessed * 100 : 0;
+        if (errorRate > 5) {
+            score -= 25;
+        }
+        // Routing efficiency check
+        if (parseFloat(metrics.routingHitRate) < 80) {
+            score -= 10;
+        }
+        // Circuit breaker check
+        if (this.circuitBreaker.state === 'OPEN') {
+            score -= 30; // Major health impact when circuit is open
+        } else if (this.circuitBreaker.state === 'HALF-OPEN') {
+            score -= 15; // Moderate impact during recovery
+        }
+        return {
+            score: Math.max(0, score),
+            status: score >= 80 ? 'healthy' : score >= 60 ? 'degraded' : 'unhealthy'
+        };
+    }
+    /**
    * Check if event is high priority (8-9) and should bypass circuit breaker
-   */
-  isHighPriority(event) {
-    return event.priority !== undefined && event.priority >= 8;
-  }
-
-  /**
+   */ isHighPriority(event) {
+        return event.priority !== undefined && event.priority >= 8;
+    }
+    /**
    * Check circuit breaker state and determine if event can be processed
    * @returns {boolean} true if event can be processed, false if rejected
-   */
-  checkCircuit() {
-    const now = Date.now();
-
-    switch (this.circuitBreaker.state) {
-      case 'CLOSED':
-        return true; // Normal operation
-
-      case 'OPEN':
-        const timeOpen = now - this.circuitBreaker.openedAt;
-        if (timeOpen >= this.circuitBreaker.recoveryTimeout) {
-          this.transitionTo('HALF-OPEN');
-          this.metrics.recoveryAttempts++;
-          return true; // Allow testing
-        }
-        return false; // Reject events
-
-      case 'HALF-OPEN':
-        return true; // Allow for testing
-
-      default:
-        return true;
-    }
-  }
-
-  /**
+   */ checkCircuit() {
+        const now = Date.now();
+        switch(this.circuitBreaker.state){
+            case 'CLOSED':
+                return true; // Normal operation
+            case 'OPEN':
+                const timeOpen = now - this.circuitBreaker.openedAt;
+                if (timeOpen >= this.circuitBreaker.recoveryTimeout) {
+                    this.transitionTo('HALF-OPEN');
+                    this.metrics.recoveryAttempts++;
+                    return true; // Allow testing
+                }
+                return false; // Reject events
+            case 'HALF-OPEN':
+                return true; // Allow for testing
+            default:
+                return true;
+        }
+    }
+    /**
    * Record successful event processing for circuit breaker
-   */
-  recordSuccess() {
-    switch (this.circuitBreaker.state) {
-      case 'CLOSED':
-        // Reset failure counter on success
-        this.circuitBreaker.consecutiveFailures = 0;
-        break;
-
-      case 'HALF-OPEN':
-        // Track successes in half-open state
-        this.circuitBreaker.halfOpenSuccesses++;
-        if (this.circuitBreaker.halfOpenSuccesses >= this.circuitBreaker.halfOpenThreshold) {
-          this.transitionTo('CLOSED');
-        }
-        break;
-    }
-  }
-
-  /**
+   */ recordSuccess() {
+        switch(this.circuitBreaker.state){
+            case 'CLOSED':
+                // Reset failure counter on success
+                this.circuitBreaker.consecutiveFailures = 0;
+                break;
+            case 'HALF-OPEN':
+                // Track successes in half-open state
+                this.circuitBreaker.halfOpenSuccesses++;
+                if (this.circuitBreaker.halfOpenSuccesses >= this.circuitBreaker.halfOpenThreshold) {
+                    this.transitionTo('CLOSED');
+                }
+                break;
+        }
+    }
+    /**
    * Record failed event processing for circuit breaker
-   */
-  recordFailure(error) {
-    this.circuitBreaker.consecutiveFailures++;
-
-    switch (this.circuitBreaker.state) {
-      case 'CLOSED':
-        if (this.circuitBreaker.consecutiveFailures >= this.circuitBreaker.failureThreshold) {
-          this.transitionTo('OPEN');
-        }
-        break;
-
-      case 'HALF-OPEN':
-        // Any failure in half-open immediately reopens circuit
-        this.transitionTo('OPEN');
-        break;
-    }
-  }
-
-  /**
+   */ recordFailure(error) {
+        this.circuitBreaker.consecutiveFailures++;
+        switch(this.circuitBreaker.state){
+            case 'CLOSED':
+                if (this.circuitBreaker.consecutiveFailures >= this.circuitBreaker.failureThreshold) {
+                    this.transitionTo('OPEN');
+                }
+                break;
+            case 'HALF-OPEN':
+                // Any failure in half-open immediately reopens circuit
+                this.transitionTo('OPEN');
+                break;
+        }
+    }
+    /**
    * Transition circuit breaker to new state
-   */
-  transitionTo(newState) {
-    const oldState = this.circuitBreaker.state;
-    this.circuitBreaker.state = newState;
-    this.circuitBreaker.lastStateChange = Date.now();
-
-    if (newState === 'OPEN') {
-      this.circuitBreaker.openedAt = Date.now();
-      this.metrics.circuitOpens++;
-      console.log(`🔌 Circuit breaker: ${oldState} → OPEN (failures: ${this.circuitBreaker.consecutiveFailures})`);
-    } else if (newState === 'HALF-OPEN') {
-      this.circuitBreaker.halfOpenSuccesses = 0;
-      console.log(`🔌 Circuit breaker: ${oldState} → HALF-OPEN (testing recovery)`);
-    } else if (newState === 'CLOSED') {
-      this.circuitBreaker.consecutiveFailures = 0;
-      this.circuitBreaker.halfOpenSuccesses = 0;
-      console.log(`🔌 Circuit breaker: ${oldState} → CLOSED (recovered)`);
-    }
-
-    this.metrics.circuitState = newState;
-  }
-
-  /**
+   */ transitionTo(newState) {
+        const oldState = this.circuitBreaker.state;
+        this.circuitBreaker.state = newState;
+        this.circuitBreaker.lastStateChange = Date.now();
+        if (newState === 'OPEN') {
+            this.circuitBreaker.openedAt = Date.now();
+            this.metrics.circuitOpens++;
+            console.log(`🔌 Circuit breaker: ${oldState} → OPEN (failures: ${this.circuitBreaker.consecutiveFailures})`);
+        } else if (newState === 'HALF-OPEN') {
+            this.circuitBreaker.halfOpenSuccesses = 0;
+            console.log(`🔌 Circuit breaker: ${oldState} → HALF-OPEN (testing recovery)`);
+        } else if (newState === 'CLOSED') {
+            this.circuitBreaker.consecutiveFailures = 0;
+            this.circuitBreaker.halfOpenSuccesses = 0;
+            console.log(`🔌 Circuit breaker: ${oldState} → CLOSED (recovered)`);
+        }
+        this.metrics.circuitState = newState;
+    }
+    /**
    * Get circuit breaker status and metrics
-   */
-  getCircuitStatus() {
-    return {
-      state: this.circuitBreaker.state,
-      consecutiveFailures: this.circuitBreaker.consecutiveFailures,
-      openedAt: this.circuitBreaker.openedAt,
-      lastStateChange: this.circuitBreaker.lastStateChange,
-      failureThreshold: this.circuitBreaker.failureThreshold,
-      recoveryTimeout: this.circuitBreaker.recoveryTimeout,
-      metrics: {
-        circuitOpens: this.metrics.circuitOpens,
-        eventsRejected: this.metrics.eventsRejected,
-        bypassEvents: this.metrics.bypassEvents,
-        recoveryAttempts: this.metrics.recoveryAttempts
-      }
-    };
-  }
-
-  /**
+   */ getCircuitStatus() {
+        return {
+            state: this.circuitBreaker.state,
+            consecutiveFailures: this.circuitBreaker.consecutiveFailures,
+            openedAt: this.circuitBreaker.openedAt,
+            lastStateChange: this.circuitBreaker.lastStateChange,
+            failureThreshold: this.circuitBreaker.failureThreshold,
+            recoveryTimeout: this.circuitBreaker.recoveryTimeout,
+            metrics: {
+                circuitOpens: this.metrics.circuitOpens,
+                eventsRejected: this.metrics.eventsRejected,
+                bypassEvents: this.metrics.bypassEvents,
+                recoveryAttempts: this.metrics.recoveryAttempts
+            }
+        };
+    }
+    /**
    * Graceful shutdown
-   */
-  async shutdown() {
-    console.log('🛑 Shutting down QE Event Bus...');
-
-    this.active = false;
-
-    // Process remaining events
-    if (this.eventBatch.length > 0) {
-      console.log(`📦 Processing ${this.eventBatch.length} remaining events...`);
-      await this.processBatch();
-    }
-
-    // Process remaining priority queues
-    for (let i = this.priorityQueues.length - 1; i >= 0; i--) {
-      const queue = this.priorityQueues[i];
-      if (queue.length > 0) {
-        console.log(`📦 Processing ${queue.length} priority ${i} events...`);
-        await Promise.all(queue.map(event => this.processEvent(event)));
-        queue.length = 0;
-      }
-    }
-
-    // Clear batch timer
-    if (this.batchTimer) {
-      clearInterval(this.batchTimer);
-      this.batchTimer = null;
-    }
-
-    // Free WASM resources
-    if (this.wasmReady && wasmEngine) {
-      try {
-        wasmEngine.free();
-        console.log('✅ WASM resources freed');
-      } catch (error) {
-        console.warn('⚠️ WASM cleanup warning:', error.message);
-      }
-    }
-
-    // Print final metrics
-    const finalMetrics = this.getMetrics();
-    const circuitStatus = this.getCircuitStatus();
-    console.log('\n📊 Final QE Event Bus Metrics:');
-    console.log(`   Events Processed: ${finalMetrics.eventsProcessed}`);
-    console.log(`   Events Published: ${finalMetrics.eventsPublished}`);
-    console.log(`   Avg Latency: ${finalMetrics.avgLatency}ms`);
-    console.log(`   Throughput: ${finalMetrics.throughput} events/sec`);
-    console.log(`   WASM Validations: ${finalMetrics.wasmValidations}`);
-    console.log(`   JS Validations: ${finalMetrics.jsValidations}`);
-    console.log(`   Routing Hit Rate: ${finalMetrics.routingHitRate}%`);
-    console.log(`   Errors: ${finalMetrics.errors}`);
-    console.log(`\n🔌 Circuit Breaker Metrics:`);
-    console.log(`   Final State: ${circuitStatus.state}`);
-    console.log(`   Circuit Opens: ${circuitStatus.metrics.circuitOpens}`);
-    console.log(`   Events Rejected: ${circuitStatus.metrics.eventsRejected}`);
-    console.log(`   Priority Bypass: ${circuitStatus.metrics.bypassEvents}`);
-    console.log(`   Recovery Attempts: ${circuitStatus.metrics.recoveryAttempts}`);
-
-    console.log('✅ QE Event Bus shutdown complete');
-  }
-}
-
-// Export singleton instance
-export default QEEventBus;
-
-// Export factory function
-export function createQEEventBus(config = {}) {
-  return new QEEventBus(config);
-}
-
-// Export WASM initialization status checker
-export async function isWASMAvailable() {
-  await wasmInitPromise;
-  return wasmAvailable;
-}
+   */ async shutdown() {
+        console.log('🛑 Shutting down QE Event Bus...');
+        this.active = false;
+        // Process remaining events
+        if (this.eventBatch.length > 0) {
+            console.log(`📦 Processing ${this.eventBatch.length} remaining events...`);
+            await this.processBatch();
+        }
+        // Process remaining priority queues
+        for(let i = this.priorityQueues.length - 1; i >= 0; i--){
+            const queue = this.priorityQueues[i];
+            if (queue.length > 0) {
+                console.log(`📦 Processing ${queue.length} priority ${i} events...`);
+                await Promise.all(queue.map((event)=>this.processEvent(event)));
+                queue.length = 0;
+            }
+        }
+        // Clear batch timer
+        if (this.batchTimer) {
+            clearInterval(this.batchTimer);
+            this.batchTimer = null;
+        }
+        // Free WASM resources
+        if (this.wasmReady && wasmEngine) {
+            try {
+                wasmEngine.free();
+                console.log('✅ WASM resources freed');
+            } catch (error) {
+                console.warn('⚠️ WASM cleanup warning:', error.message);
+            }
+        }
+        // Print final metrics
+        const finalMetrics = this.getMetrics();
+        const circuitStatus = this.getCircuitStatus();
+        console.log('\n📊 Final QE Event Bus Metrics:');
+        console.log(`   Events Processed: ${finalMetrics.eventsProcessed}`);
+        console.log(`   Events Published: ${finalMetrics.eventsPublished}`);
+        console.log(`   Avg Latency: ${finalMetrics.avgLatency}ms`);
+        console.log(`   Throughput: ${finalMetrics.throughput} events/sec`);
+        console.log(`   WASM Validations: ${finalMetrics.wasmValidations}`);
+        console.log(`   JS Validations: ${finalMetrics.jsValidations}`);
+        console.log(`   Routing Hit Rate: ${finalMetrics.routingHitRate}%`);
+        console.log(`   Errors: ${finalMetrics.errors}`);
+        console.log(`\n🔌 Circuit Breaker Metrics:`);
+        console.log(`   Final State: ${circuitStatus.state}`);
+        console.log(`   Circuit Opens: ${circuitStatus.metrics.circuitOpens}`);
+        console.log(`   Events Rejected: ${circuitStatus.metrics.eventsRejected}`);
+        console.log(`   Priority Bypass: ${circuitStatus.metrics.bypassEvents}`);
+        console.log(`   Recovery Attempts: ${circuitStatus.metrics.recoveryAttempts}`);
+        console.log('✅ QE Event Bus shutdown complete');
+    }
+    constructor(config = {}){
+        super();
+        this.config = {
+            throughputTarget: 10000,
+            latencyTarget: 50,
+            workerThreads: 4,
+            batchSize: 100,
+            batchTimeout: 10,
+            enableWASM: true,
+            enableSIMD: true,
+            enableZeroCopy: true,
+            priorityLevels: 10,
+            failureThreshold: 5,
+            recoveryTimeout: 30000,
+            ...config
+        };
+        // Event routing tables (hash-based O(1) lookup)
+        this.subscribers = new Map(); // pattern -> Set<handler>
+        this.routingCache = new Map(); // eventType -> cachedRoute
+        this.priorityQueues = Array.from({
+            length: this.config.priorityLevels
+        }, ()=>[]);
+        // Performance metrics
+        this.metrics = {
+            eventsProcessed: 0,
+            eventsPublished: 0,
+            totalLatency: 0,
+            wasmValidations: 0,
+            jsValidations: 0,
+            wasmErrors: 0,
+            wasmCleanupsPerformed: 0,
+            batchesProcessed: 0,
+            routingHits: 0,
+            routingMisses: 0,
+            errors: 0,
+            throughput: 0,
+            avgLatency: 0,
+            // Circuit breaker metrics
+            circuitState: 'CLOSED',
+            circuitOpens: 0,
+            eventsRejected: 0,
+            bypassEvents: 0,
+            recoveryAttempts: 0
+        };
+        // Circuit breaker state machine
+        this.circuitBreaker = {
+            state: 'CLOSED',
+            consecutiveFailures: 0,
+            failureThreshold: this.config.failureThreshold,
+            recoveryTimeout: this.config.recoveryTimeout,
+            halfOpenSuccesses: 0,
+            halfOpenThreshold: 3,
+            lastStateChange: Date.now(),
+            openedAt: null
+        };
+        // Batching state
+        this.eventBatch = [];
+        this.batchTimer = null;
+        // WASM state
+        this.wasmReady = false;
+        // Active state
+        this.active = false;
+        this.startTime = null;
+    }
+}
+// Export singleton instance
+export default QEEventBus;
+// Export factory function
+export function createQEEventBus(config = {}) {
+    return new QEEventBus(config);
+}
+// Export WASM initialization status checker
+export async function isWASMAvailable() {
+    await wasmInitPromise;
+    return wasmAvailable;
+}