Neural Interface Architecture

import numpy as np
import asyncio
from typing import Dict, List, Tuple, Optional, Callable
from dataclasses import dataclass, field
from concurrent.futures import ThreadPoolExecutor
import threading
from collections import deque
import time
from scipy import signal
from sklearn.svm import SVC
from sklearn.preprocessing import StandardScaler
import logging

@dataclass
class NeuralChannel:
    channel_id: int
    sampling_rate: float
    gain: float
    impedance: float
    is_active: bool = True
    noise_level: float = 0.0
    last_calibration: float = 0.0

@dataclass 
class SignalPacket:
    timestamp: float
    channel_data: np.ndarray  # Shape: (n_channels, n_samples)
    sample_rate: float
    packet_id: int
    quality_metrics: Dict[str, float] = field(default_factory=dict)

@dataclass
class DecodedIntent:
    intent_type: str
    confidence: float
    parameters: Dict[str, float]
    timestamp: float
    latency_ms: float

class RealTimeNeuralProcessor:
    def __init__(self, 
                 n_channels: int = 96,
                 sampling_rate: float = 30000.0,
                 buffer_size_ms: float = 50.0):
        
        self.n_channels = n_channels
        self.sampling_rate = sampling_rate
        self.buffer_size = int(buffer_size_ms * sampling_rate / 1000)
        
        # Signal processing components
        self.channels = self._initialize_channels()
        self.signal_buffer = deque(maxlen=self.buffer_size)
        self.processed_buffer = deque(maxlen=1000)
        
        # Real-time processing pipeline
        self.filter_bank = self._create_filter_bank()
        self.spike_detector = SpikeDetector()
        self.feature_extractor = FeatureExtractor()
        self.decoder = IntentDecoder()
        
        # Threading and performance
        self.processing_thread = None
        self.is_running = False
        self.thread_pool = ThreadPoolExecutor(max_workers=4)
        
        # Performance metrics
        self.metrics = {
            'packets_processed': 0,
            'avg_latency_ms': 0.0,
            'spike_rate_hz': 0.0,
            'decode_accuracy': 0.0,
            'dropped_packets': 0,
            'processing_load': 0.0
        }
        
        # Safety and reliability
        self.health_monitor = SystemHealthMonitor()
        self.redundancy_manager = RedundancyManager()
        self.safety_controller = SafetyController()

    def start_processing(self) -> None:
        """Start real-time neural signal processing"""
        if self.is_running:
            return
            
        self.is_running = True
        self.processing_thread = threading.Thread(
            target=self._processing_loop,
            daemon=True
        )
        self.processing_thread.start()
        
        # Start health monitoring
        self.health_monitor.start()
        
        logging.info(f"Neural processor started: {self.n_channels} channels @ {self.sampling_rate} Hz")

    def stop_processing(self) -> None:
        """Stop real-time processing gracefully"""
        self.is_running = False
        if self.processing_thread:
            self.processing_thread.join(timeout=5.0)
        
        self.health_monitor.stop()
        self.thread_pool.shutdown(wait=True)
        
        logging.info("Neural processor stopped")

    def process_signal_packet(self, raw_data: np.ndarray, timestamp: float) -> Optional[DecodedIntent]:
        """Process incoming neural signal packet"""
        start_time = time.perf_counter()
        
        try:
            # Create signal packet
            packet = SignalPacket(
                timestamp=timestamp,
                channel_data=raw_data,
                sample_rate=self.sampling_rate,
                packet_id=self.metrics['packets_processed']
            )
            
            # Quality assessment
            packet.quality_metrics = self._assess_signal_quality(packet)
            
            # Early rejection of low-quality signals
            if packet.quality_metrics['overall_quality'] < 0.5:
                self.metrics['dropped_packets'] += 1
                return None
            
            # Stage 1: Signal conditioning and filtering
            conditioned_signal = self._condition_signal(packet)
            
            # Stage 2: Spike detection and extraction
            spikes = self.spike_detector.detect_spikes(conditioned_signal)
            
            # Stage 3: Feature extraction from spikes
            features = self.feature_extractor.extract_features(
                spikes, 
                packet.timestamp,
                self.processed_buffer
            )
            
            # Stage 4: Intent decoding
            if features is not None and len(features) > 0:
                decoded_intent = self.decoder.decode_intent(features)
                
                # Safety validation
                if not self.safety_controller.validate_intent(decoded_intent):
                    logging.warning("Intent failed safety validation")
                    return None
                
                # Calculate latency
                processing_latency = (time.perf_counter() - start_time) * 1000
                decoded_intent.latency_ms = processing_latency
                
                # Update metrics
                self._update_metrics(processing_latency, decoded_intent)
                
                return decoded_intent
            
            return None
            
        except Exception as e:
            logging.error(f"Signal processing error: {e}")
            self.safety_controller.handle_processing_error(e)
            return None

    def _processing_loop(self) -> None:
        """Main real-time processing loop"""
        while self.is_running:
            try:
                # Simulate data acquisition
                if len(self.signal_buffer) > 0:
                    packet_data = self.signal_buffer.popleft()
                    
                    # Process packet
                    result = self.process_signal_packet(
                        packet_data['data'], 
                        packet_data['timestamp']
                    )
                    
                    if result:
                        self.processed_buffer.append(result)
                        # Trigger downstream processing
                        asyncio.create_task(self._handle_decoded_intent(result))
                
                # Maintain real-time performance
                time.sleep(0.001)  # 1ms loop time
                
            except Exception as e:
                logging.error(f"Processing loop error: {e}")
                if not self.redundancy_manager.handle_processing_failure():
                    break

    def _condition_signal(self, packet: SignalPacket) -> np.ndarray:
        """Apply signal conditioning and filtering"""
        conditioned = packet.channel_data.copy()
        
        # Apply per-channel conditioning
        for ch_idx in range(self.n_channels):
            if not self.channels[ch_idx].is_active:
                conditioned[ch_idx, :] = 0
                continue
            
            # High-pass filter (remove DC and low-freq artifacts)
            conditioned[ch_idx, :] = signal.filtfilt(
                *self.filter_bank['highpass'], 
                conditioned[ch_idx, :]
            )
            
            # Notch filter (remove 60Hz power line noise)
            conditioned[ch_idx, :] = signal.filtfilt(
                *self.filter_bank['notch'], 
                conditioned[ch_idx, :]
            )
            
            # Band-pass filter for action potentials (300-6000 Hz)
            conditioned[ch_idx, :] = signal.filtfilt(
                *self.filter_bank['bandpass'], 
                conditioned[ch_idx, :]
            )
        
        return conditioned

    def _create_filter_bank(self) -> Dict:
        """Create filter bank for signal conditioning"""
        nyquist = self.sampling_rate / 2
        
        # High-pass filter (300 Hz)
        hp_b, hp_a = signal.butter(4, 300 / nyquist, btype='high')
        
        # Notch filter (60 Hz)
        notch_b, notch_a = signal.iirnotch(60 / nyquist, 30)
        
        # Band-pass filter (300-6000 Hz)
        bp_b, bp_a = signal.butter(4, [300 / nyquist, 6000 / nyquist], btype='band')
        
        return {
            'highpass': (hp_b, hp_a),
            'notch': (notch_b, notch_a),
            'bandpass': (bp_b, bp_a)
        }

    def _assess_signal_quality(self, packet: SignalPacket) -> Dict[str, float]:
        """Assess signal quality metrics"""
        metrics = {}
        
        for ch_idx in range(self.n_channels):
            channel_data = packet.channel_data[ch_idx, :]
            
            # Signal-to-noise ratio
            signal_power = np.var(channel_data)
            noise_floor = self.channels[ch_idx].noise_level
            snr = 10 * np.log10(signal_power / max(noise_floor, 1e-12))
            
            # Impedance check
            impedance_ok = self.channels[ch_idx].impedance < 1e6  # 1 MOhm threshold
            
            # Saturation detection
            max_val = np.max(np.abs(channel_data))
            saturation = max_val > 0.95 * 2**15  # Assume 16-bit ADC
            
            metrics[f'ch_{ch_idx}_snr'] = snr
            metrics[f'ch_{ch_idx}_impedance_ok'] = float(impedance_ok)
            metrics[f'ch_{ch_idx}_saturated'] = float(saturation)
        
        # Overall quality score
        avg_snr = np.mean([v for k, v in metrics.items() if 'snr' in k])
        impedance_score = np.mean([v for k, v in metrics.items() if 'impedance_ok' in k])
        saturation_penalty = np.mean([v for k, v in metrics.items() if 'saturated' in k])
        
        overall_quality = max(0, (avg_snr / 20 + impedance_score - saturation_penalty) / 2)
        metrics['overall_quality'] = min(1.0, overall_quality)
        
        return metrics

    def _update_metrics(self, latency_ms: float, intent: DecodedIntent) -> None:
        """Update performance metrics"""
        self.metrics['packets_processed'] += 1
        
        # Running average latency
        alpha = 0.1  # Smoothing factor
        self.metrics['avg_latency_ms'] = (
            alpha * latency_ms + 
            (1 - alpha) * self.metrics['avg_latency_ms']
        )
        
        # Decode accuracy (simplified)
        self.metrics['decode_accuracy'] = (
            alpha * intent.confidence + 
            (1 - alpha) * self.metrics['decode_accuracy']
        )

    async def _handle_decoded_intent(self, intent: DecodedIntent) -> None:
        """Handle decoded neural intent"""
        try:
            # Send to control system
            await self._send_control_command(intent)
            
            # Update adaptive models
            await self.decoder.update_model(intent)
            
            # Log for analysis
            logging.debug(f"Intent decoded: {intent.intent_type} (conf: {intent.confidence:.3f})")
            
        except Exception as e:
            logging.error(f"Intent handling error: {e}")

    async def _send_control_command(self, intent: DecodedIntent) -> None:
        """Send control command to external device"""
        # This would interface with robotic arms, cursors, etc.
        command = {
            'type': intent.intent_type,
            'parameters': intent.parameters,
            'confidence': intent.confidence,
            'timestamp': intent.timestamp
        }
        
        # Simulate command transmission
        await asyncio.sleep(0.001)  # 1ms transmission delay

    def _initialize_channels(self) -> List[NeuralChannel]:
        """Initialize neural channel configurations"""
        channels = []
        for i in range(self.n_channels):
            channel = NeuralChannel(
                channel_id=i,
                sampling_rate=self.sampling_rate,
                gain=1000.0,  # 80dB gain
                impedance=500e3,  # 500 kOhm
                noise_level=2.0  # 2 μV RMS
            )
            channels.append(channel)
        
        return channels

    def get_performance_metrics(self) -> Dict[str, float]:
        """Get current performance metrics"""
        return {
            **self.metrics,
            'buffer_utilization': len(self.signal_buffer) / self.signal_buffer.maxlen,
            'active_channels': sum(1 for ch in self.channels if ch.is_active),
            'system_health': self.health_monitor.get_health_score()
        }

# Supporting classes (simplified implementations)

class SpikeDetector:
    def __init__(self, threshold_factor: float = -4.5):
        self.threshold_factor = threshold_factor
        
    def detect_spikes(self, signal_data: np.ndarray) -> List[Dict]:
        """Detect action potential spikes in neural signals"""
        spikes = []
        
        for ch_idx in range(signal_data.shape[0]):
            channel_signal = signal_data[ch_idx, :]
            
            # Adaptive threshold based on noise level
            noise_std = np.std(channel_signal)
            threshold = self.threshold_factor * noise_std
            
            # Find threshold crossings
            spike_indices = np.where(channel_signal < threshold)[0]
            
            if len(spike_indices) > 0:
                # Group nearby spikes and extract waveforms
                grouped_spikes = self._group_spike_events(spike_indices, channel_signal)
                
                for spike in grouped_spikes:
                    spikes.append({
                        'channel': ch_idx,
                        'timestamp': spike['timestamp'],
                        'amplitude': spike['amplitude'],
                        'waveform': spike['waveform']
                    })
        
        return spikes
    
    def _group_spike_events(self, indices: np.ndarray, signal: np.ndarray) -> List[Dict]:
        """Group nearby spike events and extract waveforms"""
        # Simplified implementation
        return []

class FeatureExtractor:
    def extract_features(self, spikes: List[Dict], timestamp: float, history: deque) -> Optional[np.ndarray]:
        """Extract features from detected spikes for decoding"""
        if not spikes:
            return None
        
        # Extract features like spike rate, waveform shape, timing
        features = []
        
        # Spike rate features (per channel)
        spike_counts = np.zeros(96)  # Assuming 96 channels
        for spike in spikes:
            spike_counts[spike['channel']] += 1
        
        features.extend(spike_counts)
        
        # Waveform features (simplified)
        avg_amplitude = np.mean([spike['amplitude'] for spike in spikes])
        features.append(avg_amplitude)
        
        # Temporal features
        if len(history) > 0:
            recent_intent = history[-1]
            time_since_last = timestamp - recent_intent.timestamp
            features.append(time_since_last)
        else:
            features.append(0.0)
        
        return np.array(features)

class IntentDecoder:
    def __init__(self):
        self.model = SVC(probability=True)
        self.scaler = StandardScaler()
        self.is_trained = False
    
    def decode_intent(self, features: np.ndarray) -> DecodedIntent:
        """Decode user intent from neural features"""
        if not self.is_trained:
            # Return default intent for untrained model
            return DecodedIntent(
                intent_type='idle',
                confidence=0.5,
                parameters={},
                timestamp=time.time(),
                latency_ms=0.0
            )
        
        # Scale features and predict
        features_scaled = self.scaler.transform(features.reshape(1, -1))
        prediction = self.model.predict(features_scaled)[0]
        confidence = np.max(self.model.predict_proba(features_scaled))
        
        return DecodedIntent(
            intent_type=prediction,
            confidence=confidence,
            parameters={'strength': confidence},
            timestamp=time.time(),
            latency_ms=0.0
        )
    
    async def update_model(self, intent: DecodedIntent) -> None:
        """Update model with new data (online learning)"""
        # Implement online learning updates
        pass

class SystemHealthMonitor:
    def __init__(self):
        self.health_score = 100.0
        self.is_monitoring = False
    
    def start(self) -> None:
        self.is_monitoring = True
    
    def stop(self) -> None:
        self.is_monitoring = False
    
    def get_health_score(self) -> float:
        return self.health_score

class RedundancyManager:
    def handle_processing_failure(self) -> bool:
        """Handle processing failures with redundancy"""
        # Implement redundancy logic
        return True

class SafetyController:
    def validate_intent(self, intent: DecodedIntent) -> bool:
        """Validate decoded intent for safety"""
        # Implement safety validation
        return intent.confidence > 0.3
    
    def handle_processing_error(self, error: Exception) -> None:
        """Handle processing errors safely"""
        logging.error(f"Safety controller handling error: {error}")

# Usage example
async def demonstrate_neural_processing():
    # Initialize processor
    processor = RealTimeNeuralProcessor(
        n_channels=96,
        sampling_rate=30000.0,
        buffer_size_ms=50.0
    )
    
    # Start processing
    processor.start_processing()
    
    try:
        # Simulate neural data acquisition
        for i in range(100):
            # Generate simulated neural data
            fake_data = np.random.randn(96, 300) * 50  # 10ms of data at 30kHz
            timestamp = time.time()
            
            # Process the data
            result = processor.process_signal_packet(fake_data, timestamp)
            
            if result:
                print(f"Decoded: {result.intent_type} (conf: {result.confidence:.3f}, "
                      f"latency: {result.latency_ms:.1f}ms)")
            
            await asyncio.sleep(0.01)  # 10ms between packets
        
        # Get performance metrics
        metrics = processor.get_performance_metrics()
        print(f"Performance: {metrics['avg_latency_ms']:.1f}ms avg latency, "
              f"{metrics['decode_accuracy']:.3f} accuracy")
    
    finally:
        processor.stop_processing()

if __name__ == "__main__":
    asyncio.run(demonstrate_neural_processing())

import { EventEmitter } from 'events';
import * as tf from '@tensorflow/tfjs-node';

interface NeuralSignal {
  channelId: number;
  timestamp: number;
  samples: Float32Array;
  sampleRate: number;
  impedance?: number;
}

interface MotorIntent {
  type: 'reach' | 'grasp' | 'release' | 'cursor_move' | 'click' | 'idle';
  target?: { x: number; y: number; z?: number };
  velocity?: { x: number; y: number; z?: number };
  force?: number;
  confidence: number;
  timestamp: number;
}

interface CalibrationData {
  userId: string;
  sessionId: string;
  intentLabels: string[];
  neuralFeatures: number[][];
  timestamps: number[];
  performanceMetrics: {
    accuracy: number;
    latency: number;
    stability: number;
  };
}

interface BCIPerformanceMetrics {
  decodeAccuracy: number;
  averageLatency: number;
  throughput: number; // bits per minute
  sessionDuration: number;
  errorRate: number;
  adaptationRate: number;
}

class BCIControlSystem extends EventEmitter {
  private neuralProcessor: NeuralSignalProcessor;
  private intentDecoder: tf.LayersModel | null = null;
  private calibrationManager: CalibrationManager;
  private adaptiveLearning: AdaptiveLearningEngine;
  private safetyMonitor: SafetyMonitor;
  private performanceTracker: PerformanceTracker;
  
  // Real-time processing
  private processingQueue: NeuralSignal[] = [];
  private isProcessing: boolean = false;
  private targetLatency: number = 100; // milliseconds
  
  // State management
  private currentSession: string = '';
  private isCalibrated: boolean = false;
  private systemEnabled: boolean = false;
  
  // Performance optimization
  private featureCache: Map<string, Float32Array> = new Map();
  private predictionBuffer: MotorIntent[] = [];
  private smoothingWindow: number = 5;

  constructor(config: {
    channels: number;
    sampleRate: number;
    targetLatency?: number;
    modelPath?: string;
  }) {
    super();
    
    this.targetLatency = config.targetLatency || 100;
    this.neuralProcessor = new NeuralSignalProcessor(config.channels, config.sampleRate);
    this.calibrationManager = new CalibrationManager();
    this.adaptiveLearning = new AdaptiveLearningEngine();
    this.safetyMonitor = new SafetyMonitor(this.targetLatency);
    this.performanceTracker = new PerformanceTracker();
    
    // Initialize event handlers
    this.setupEventHandlers();
    
    // Load pre-trained model if available
    if (config.modelPath) {
      this.loadModel(config.modelPath);
    }
  }

  async startSession(userId: string): Promise<void> {
    this.currentSession = `${userId}_${Date.now()}`;
    this.systemEnabled = false; // Require calibration first
    
    // Initialize session
    await this.performanceTracker.startSession(this.currentSession);
    await this.safetyMonitor.reset();
    
    // Start neural signal processing
    this.startNeuralProcessing();
    
    this.emit('sessionStarted', { sessionId: this.currentSession, userId });
  }

  async calibrate(calibrationProtocol: {
    duration: number; // seconds
    tasks: Array<{ type: string; target?: any; duration: number }>;
  }): Promise<CalibrationData> {
    const calibrationData = await this.calibrationManager.runCalibration(
      this.currentSession,
      calibrationProtocol,
      this.neuralProcessor
    );
    
    // Train decoder with calibration data
    await this.trainDecoder(calibrationData);
    
    this.isCalibrated = true;
    this.systemEnabled = true;
    
    this.emit('calibrationComplete', calibrationData);
    return calibrationData;
  }

  private async trainDecoder(data: CalibrationData): Promise<void> {
    const { neuralFeatures, intentLabels } = data;
    
    // Convert labels to one-hot encoding
    const uniqueLabels = [...new Set(intentLabels)];
    const numClasses = uniqueLabels.length;
    
    const yTensor = tf.oneHot(
      intentLabels.map(label => uniqueLabels.indexOf(label)),
      numClasses
    );
    
    const xTensor = tf.tensor2d(neuralFeatures);
    
    // Create neural network model
    this.intentDecoder = tf.sequential({
      layers: [
        tf.layers.dense({ 
          inputShape: [neuralFeatures[0].length], 
          units: 128, 
          activation: 'relu',
          kernelRegularizer: tf.regularizers.l2({ l2: 0.01 })
        }),
        tf.layers.dropout({ rate: 0.3 }),
        tf.layers.dense({ units: 64, activation: 'relu' }),
        tf.layers.dropout({ rate: 0.2 }),
        tf.layers.dense({ units: 32, activation: 'relu' }),
        tf.layers.dense({ units: numClasses, activation: 'softmax' })
      ]
    });
    
    // Compile model
    this.intentDecoder.compile({
      optimizer: tf.train.adam(0.001),
      loss: 'categoricalCrossentropy',
      metrics: ['accuracy']
    });
    
    // Train model
    const history = await this.intentDecoder.fit(xTensor, yTensor, {
      epochs: 50,
      batchSize: 32,
      validationSplit: 0.2,
      callbacks: {
        onEpochEnd: (epoch, logs) => {
          this.emit('trainingProgress', { epoch, ...logs });
        }
      }
    });
    
    // Cleanup tensors
    xTensor.dispose();
    yTensor.dispose();
    
    console.log('Decoder training complete:', history.history);
  }

  private startNeuralProcessing(): void {
    this.isProcessing = true;
    
    // Main processing loop
    const processLoop = async () => {
      while (this.isProcessing) {
        const startTime = performance.now();
        
        try {
          // Process queued neural signals
          if (this.processingQueue.length > 0) {
            const signals = this.processingQueue.splice(0, 10); // Process in batches
            
            for (const signal of signals) {
              await this.processNeuralSignal(signal);
            }
          }
          
          // Maintain target processing rate
          const processingTime = performance.now() - startTime;
          const targetInterval = 10; // 10ms = 100Hz processing
          const sleepTime = Math.max(0, targetInterval - processingTime);
          
          if (sleepTime > 0) {
            await new Promise(resolve => setTimeout(resolve, sleepTime));
          }
          
        } catch (error) {
          this.emit('processingError', error);
          await this.safetyMonitor.handleError(error);
        }
      }
    };
    
    processLoop();
  }

  private async processNeuralSignal(signal: NeuralSignal): Promise<void> {
    const processingStartTime = performance.now();
    
    try {
      // Step 1: Extract features from neural signal
      const features = await this.neuralProcessor.extractFeatures(signal);
      
      if (!features || !this.intentDecoder || !this.isCalibrated) {
        return;
      }
      
      // Step 2: Decode motor intent
      const rawIntent = await this.decodeIntent(features);
      
      // Step 3: Apply temporal smoothing and filtering
      const smoothedIntent = await this.temporalSmoothing(rawIntent);
      
      // Step 4: Safety validation
      const safeIntent = await this.safetyMonitor.validateIntent(smoothedIntent);
      
      if (safeIntent && this.systemEnabled) {
        // Step 5: Execute control command
        await this.executeControlCommand(safeIntent);
        
        // Step 6: Adaptive learning update
        await this.adaptiveLearning.updateModel(safeIntent, features);
        
        // Step 7: Performance tracking
        const latency = performance.now() - processingStartTime;
        await this.performanceTracker.recordDecoding(safeIntent, latency);
        
        this.emit('intentDecoded', safeIntent);
      }
      
    } catch (error) {
      this.emit('signalProcessingError', { signal, error });
    }
  }

  private async decodeIntent(features: Float32Array): Promise<MotorIntent> {
    if (!this.intentDecoder) {
      throw new Error('Intent decoder not initialized');
    }
    
    // Create tensor from features
    const inputTensor = tf.tensor2d([Array.from(features)]);
    
    // Run inference
    const prediction = this.intentDecoder.predict(inputTensor) as tf.Tensor;
    const probabilities = await prediction.data();
    
    // Find highest probability class
    const maxProbIndex = probabilities.indexOf(Math.max(...Array.from(probabilities)));
    const confidence = probabilities[maxProbIndex];
    
    // Map index to intent type
    const intentTypes = ['reach', 'grasp', 'release', 'cursor_move', 'click', 'idle'];
    const intentType = intentTypes[maxProbIndex] as MotorIntent['type'];
    
    // Extract movement parameters if applicable
    let target, velocity, force;
    
    if (intentType === 'reach' || intentType === 'cursor_move') {
      // Extract target coordinates from additional network outputs
      target = { x: probabilities[6] || 0, y: probabilities[7] || 0 };
      velocity = { x: probabilities[8] || 0, y: probabilities[9] || 0 };
    }
    
    if (intentType === 'grasp') {
      force = probabilities[10] || 0.5;
    }
    
    // Cleanup tensors
    inputTensor.dispose();
    prediction.dispose();
    
    return {
      type: intentType,
      target,
      velocity,
      force,
      confidence,
      timestamp: Date.now()
    };
  }

  private async temporalSmoothing(intent: MotorIntent): Promise<MotorIntent> {
    // Add to prediction buffer
    this.predictionBuffer.push(intent);
    
    // Maintain buffer size
    if (this.predictionBuffer.length > this.smoothingWindow) {
      this.predictionBuffer.shift();
    }
    
    // Apply temporal smoothing
    if (this.predictionBuffer.length < 3) {
      return intent; // Need minimum history
    }
    
    // Smooth continuous parameters
    const smoothedIntent = { ...intent };
    
    if (intent.target) {
      const recentTargets = this.predictionBuffer
        .filter(p => p.target)
        .map(p => p.target!)
        .slice(-3);
      
      if (recentTargets.length > 0) {
        smoothedIntent.target = {
          x: recentTargets.reduce((sum, t) => sum + t.x, 0) / recentTargets.length,
          y: recentTargets.reduce((sum, t) => sum + t.y, 0) / recentTargets.length,
          z: recentTargets.reduce((sum, t) => sum + (t.z || 0), 0) / recentTargets.length
        };
      }
    }
    
    if (intent.velocity) {
      const recentVelocities = this.predictionBuffer
        .filter(p => p.velocity)
        .map(p => p.velocity!)
        .slice(-3);
      
      if (recentVelocities.length > 0) {
        smoothedIntent.velocity = {
          x: recentVelocities.reduce((sum, v) => sum + v.x, 0) / recentVelocities.length,
          y: recentVelocities.reduce((sum, v) => sum + v.y, 0) / recentVelocities.length,
          z: recentVelocities.reduce((sum, v) => sum + (v.z || 0), 0) / recentVelocities.length
        };
      }
    }
    
    // Majority vote for discrete actions
    const recentTypes = this.predictionBuffer.slice(-3).map(p => p.type);
    const typeCounts = recentTypes.reduce((counts, type) => {
      counts[type] = (counts[type] || 0) + 1;
      return counts;
    }, {} as Record<string, number>);
    
    const mostCommonType = Object.entries(typeCounts)
      .sort(([,a], [,b]) => b - a)[0][0] as MotorIntent['type'];
    
    smoothedIntent.type = mostCommonType;
    
    return smoothedIntent;
  }

  private async executeControlCommand(intent: MotorIntent): Promise<void> {
    try {
      // Convert intent to control commands
      const command = this.intentToCommand(intent);
      
      // Send to external control system (robotic arm, cursor, etc.)
      await this.sendControlCommand(command);
      
      this.emit('commandExecuted', { intent, command });
      
    } catch (error) {
      this.emit('commandExecutionError', { intent, error });
    }
  }

  private intentToCommand(intent: MotorIntent): any {
    switch (intent.type) {
      case 'cursor_move':
        return {
          type: 'mouse_move',
          x: intent.target?.x || 0,
          y: intent.target?.y || 0,
          smooth: true
        };
      
      case 'click':
        return {
          type: 'mouse_click',
          button: 'left'
        };
      
      case 'reach':
        return {
          type: 'robot_move',
          target: intent.target,
          velocity: intent.velocity,
          precision: 'high'
        };
      
      case 'grasp':
        return {
          type: 'robot_grasp',
          force: intent.force || 0.5
        };
      
      case 'release':
        return {
          type: 'robot_release'
        };
      
      default:
        return { type: 'no_action' };
    }
  }

  private async sendControlCommand(command: any): Promise<void> {
    // Simulate command transmission
    await new Promise(resolve => setTimeout(resolve, 1));
    
    // In real implementation, this would interface with:
    // - Robotic control systems
    // - Computer interfaces
    // - Prosthetic devices
    // - Virtual reality systems
  }

  async getPerformanceMetrics(): Promise<BCIPerformanceMetrics> {
    return await this.performanceTracker.getMetrics();
  }

  async stopSession(): Promise<void> {
    this.isProcessing = false;
    this.systemEnabled = false;
    
    const metrics = await this.getPerformanceMetrics();
    await this.performanceTracker.endSession();
    
    this.emit('sessionEnded', { sessionId: this.currentSession, metrics });
  }

  private setupEventHandlers(): void {
    this.on('processingError', (error) => {
      console.error('BCI Processing Error:', error);
    });
    
    this.on('commandExecuted', (data) => {
      console.log('Command executed:', data.command);
    });
  }

  private async loadModel(path: string): Promise<void> {
    try {
      this.intentDecoder = await tf.loadLayersModel(path);
      console.log('Pre-trained model loaded successfully');
    } catch (error) {
      console.warn('Failed to load pre-trained model:', error);
    }
  }

  // Public method to add neural signal to processing queue
  addNeuralSignal(signal: NeuralSignal): void {
    if (this.processingQueue.length < 1000) { // Prevent memory overflow
      this.processingQueue.push(signal);
    } else {
      console.warn('Neural signal queue overflow - dropping signal');
    }
  }
}

// Supporting classes (simplified implementations)

class NeuralSignalProcessor {
  constructor(private channels: number, private sampleRate: number) {}
  
  async extractFeatures(signal: NeuralSignal): Promise<Float32Array | null> {
    // Extract relevant features from neural signal
    // This would include spike rates, spectral features, etc.
    const features = new Float32Array(64); // Example feature vector
    
    // Simulate feature extraction
    for (let i = 0; i < features.length; i++) {
      features[i] = Math.random() * 2 - 1; // Normalized features
    }
    
    return features;
  }
}

class CalibrationManager {
  async runCalibration(sessionId: string, protocol: any, processor: NeuralSignalProcessor): Promise<CalibrationData> {
    // Simulate calibration process
    return {
      userId: 'test_user',
      sessionId,
      intentLabels: ['reach', 'grasp', 'idle'],
      neuralFeatures: Array(100).fill(0).map(() => Array(64).fill(0).map(() => Math.random() * 2 - 1)),
      timestamps: Array(100).fill(0).map((_, i) => Date.now() + i * 100),
      performanceMetrics: {
        accuracy: 0.85,
        latency: 120,
        stability: 0.92
      }
    };
  }
}

class AdaptiveLearningEngine {
  async updateModel(intent: MotorIntent, features: Float32Array): Promise<void> {
    // Implement online learning updates
  }
}

class SafetyMonitor {
  constructor(private maxLatency: number) {}
  
  async validateIntent(intent: MotorIntent): Promise<MotorIntent | null> {
    // Validate intent for safety
    if (intent.confidence < 0.5) {
      return null; // Reject low-confidence intents
    }
    
    return intent;
  }
  
  async handleError(error: Error): Promise<void> {
    console.error('Safety monitor handling error:', error);
  }
  
  async reset(): Promise<void> {
    // Reset safety state
  }
}

class PerformanceTracker {
  private metrics: BCIPerformanceMetrics = {
    decodeAccuracy: 0,
    averageLatency: 0,
    throughput: 0,
    sessionDuration: 0,
    errorRate: 0,
    adaptationRate: 0
  };
  
  async startSession(sessionId: string): Promise<void> {
    // Initialize session tracking
  }
  
  async recordDecoding(intent: MotorIntent, latency: number): Promise<void> {
    // Update performance metrics
    this.metrics.averageLatency = (this.metrics.averageLatency + latency) / 2;
  }
  
  async getMetrics(): Promise<BCIPerformanceMetrics> {
    return { ...this.metrics };
  }
  
  async endSession(): Promise<void> {
    // Finalize session metrics
  }
}