@affectively/aeon 1.0.0 → 1.2.0

package/dist/optimization/index.d.ts

@@ -0,0 +1,347 @@
+import { Operation } from '../core/index.js';
+
+/**
+ * Prefetching Engine (Phase 13)
+ *
+ * Predictively pre-compresses batches based on detected operation patterns.
+ * Analyzes historical data to predict which operations are most likely to occur.
+ */
+
+/**
+ * Pattern in operation sequence
+ */
+interface OperationPattern {
+    sequence: string[];
+    frequency: number;
+    probability: number;
+    lastOccurred: number;
+    avgIntervalMs: number;
+}
+/**
+ * Prediction for next operations
+ */
+interface OperationPrediction {
+    operationType: string;
+    probability: number;
+    reason: string;
+    shouldPrefetch: boolean;
+    estimatedTimeMs: number;
+}
+/**
+ * Prefetched batch
+ */
+interface PrefetchedBatch {
+    id: string;
+    operationType: string;
+    compressed: Uint8Array;
+    compressedSize: number;
+    originalSize: number;
+    compressionRatio: number;
+    compressed_at: number;
+    created_at: number;
+    ttl: number;
+    expiresAt: number;
+    hitCount: number;
+    missCount: number;
+}
+/**
+ * Prefetching statistics
+ */
+interface PrefetchingStats {
+    totalPrefetched: number;
+    totalHits: number;
+    totalMisses: number;
+    totalOverwrites: number;
+    hitRatio: number;
+    bandwidthSaved: number;
+    patternsDetected: number;
+    predictionAccuracy: number;
+}
+declare class PrefetchingEngine {
+    private operationHistory;
+    private patterns;
+    private prefetchCache;
+    private maxHistoryEntries;
+    private maxCachePerType;
+    private prefetchTTL;
+    private predictionThreshold;
+    private stats;
+    private lastPredictionTime;
+    private predictionInterval;
+    constructor();
+    /**
+     * Record operation for pattern analysis
+     */
+    recordOperation(operationType: string, size: number): void;
+    /**
+     * Analyze patterns in operation history
+     */
+    private analyzePatterns;
+    /**
+     * Predict next operations
+     */
+    predictNextOperations(recentOperations: Operation[]): OperationPrediction[];
+    /**
+     * Add prefetched batch
+     */
+    addPrefetchedBatch(operationType: string, compressed: Uint8Array, originalSize: number): PrefetchedBatch;
+    /**
+     * Try to use prefetched batch
+     */
+    getPrefetchedBatch(operationType: string): PrefetchedBatch | null;
+    /**
+     * Update prediction accuracy metric
+     */
+    private updatePredictionAccuracy;
+    /**
+     * Clean expired prefetches
+     */
+    private cleanExpiredPrefetches;
+    /**
+     * Get statistics
+     */
+    getStats(): PrefetchingStats;
+    /**
+     * Clear all caches
+     */
+    clear(): void;
+}
+declare function getPrefetchingEngine(): PrefetchingEngine;
+declare function resetPrefetchingEngine(): void;
+
+/**
+ * Batch Timing Optimizer (Phase 13)
+ *
+ * Intelligently schedules batch transmission based on network conditions,
+ * device resources, and user activity patterns.
+ */
+/**
+ * Network window quality assessment
+ */
+interface NetworkWindow {
+    startTime: number;
+    endTime: number;
+    expectedDurationMs: number;
+    latencyMs: number;
+    bandwidthMbps: number;
+    quality: 'excellent' | 'good' | 'fair' | 'poor';
+    isStable: boolean;
+    congestionLevel: number;
+    recommendedBatchSize: number;
+}
+/**
+ * Activity pattern
+ */
+interface ActivityPattern {
+    type: 'user-active' | 'idle' | 'background' | 'sleep';
+    startTime: number;
+    duration: number;
+    probability: number;
+}
+/**
+ * Batch scheduling decision
+ */
+interface SchedulingDecision {
+    shouldSendNow: boolean;
+    nextOptimalWindowMs: number;
+    recommendedDelay: number;
+    reason: string;
+    priority: 'critical' | 'high' | 'normal' | 'low';
+    estimatedDeliveryMs: number;
+}
+/**
+ * Batch timing statistics
+ */
+interface BatchTimingStats {
+    totalBatches: number;
+    immediateDeliveries: number;
+    deferredBatches: number;
+    averageWaitTimeMs: number;
+    averageDeliveryTimeMs: number;
+    networkWindowsUsed: number;
+    congestionAvoided: number;
+    userFocusedOptimizations: number;
+}
+declare class BatchTimingOptimizer {
+    private networkHistory;
+    private activityHistory;
+    private stats;
+    private lastActivityTime;
+    private isUserActive;
+    private congestionDetectionWindow;
+    private optimalBatchSize;
+    constructor();
+    /**
+     * Record network measurement
+     */
+    recordNetworkMeasurement(latencyMs: number, bandwidthMbps: number): void;
+    /**
+     * Assess network quality
+     */
+    private assessNetworkQuality;
+    /**
+     * Detect congestion in network
+     */
+    private detectCongestion;
+    /**
+     * Find next optimal network window
+     */
+    private findOptimalWindow;
+    /**
+     * Get scheduling decision for a batch
+     */
+    getSchedulingDecision(batchSize: number, batchPriority?: 'critical' | 'high' | 'normal' | 'low', isUserTriggered?: boolean): SchedulingDecision;
+    /**
+     * Apply scheduling and update stats
+     */
+    applyScheduling(batchSize: number, sendNow: boolean, actualDelay: number): void;
+    /**
+     * Get optimal batch size recommendation
+     */
+    getOptimalBatchSize(): number;
+    /**
+     * Get current network window
+     */
+    getCurrentNetworkWindow(): NetworkWindow;
+    /**
+     * Set user activity state
+     */
+    setUserActive(active: boolean): void;
+    /**
+     * Get statistics
+     */
+    getStats(): BatchTimingStats;
+    /**
+     * Clear history
+     */
+    clear(): void;
+}
+declare function getBatchTimingOptimizer(): BatchTimingOptimizer;
+declare function resetBatchTimingOptimizer(): void;
+
+/**
+ * Adaptive Compression Optimizer (Phase 13)
+ *
+ * Automatically adjusts compression level based on network conditions,
+ * device capabilities, and real-time performance metrics.
+ */
+/**
+ * Network conditions affecting compression
+ */
+interface NetworkProfile {
+    estimatedSpeedKbps: number;
+    latencyMs: number;
+    isOnline: boolean;
+    isWifi: boolean;
+    isFast: boolean;
+    isSlow: boolean;
+    isEmpty: boolean;
+}
+/**
+ * Device capabilities for compression
+ */
+interface DeviceProfile {
+    cpuCores: number;
+    cpuUtilization: number;
+    memoryAvailableMB: number;
+    memoryTotalMB: number;
+    isConstrained: boolean;
+    isPremium: boolean;
+    supportsWebWorkers: boolean;
+    supportsWebAssembly: boolean;
+}
+/**
+ * Compression recommendation based on conditions
+ */
+interface CompressionRecommendation {
+    recommendedLevel: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    reason: string;
+    confidence: number;
+    estimatedCompressionMs: number;
+    estimatedRatio: number;
+    networkFactor: number;
+    deviceFactor: number;
+}
+/**
+ * Adaptive compression statistics
+ */
+interface AdaptiveStats {
+    currentLevel: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    averageCompressionMs: number;
+    averageRatio: number;
+    levelsUsed: Set<number>;
+    adjustmentCount: number;
+    totalBatches: number;
+    networkCondition: 'fast' | 'normal' | 'slow' | 'offline';
+}
+declare class AdaptiveCompressionOptimizer {
+    private currentLevel;
+    private networkProfile;
+    private deviceProfile;
+    private compressionHistory;
+    private stats;
+    constructor();
+    /**
+     * Update network conditions
+     */
+    updateNetworkConditions(speedKbps: number, latencyMs?: number, isOnline?: boolean): void;
+    /**
+     * Update device resource usage
+     */
+    updateDeviceResources(cpuUtilization: number, memoryAvailableMB: number): void;
+    /**
+     * Record compression performance
+     */
+    recordCompressionPerformance(level: number, compressionMs: number, ratio: number): void;
+    /**
+     * Get compression recommendation based on conditions
+     */
+    getRecommendedLevel(): CompressionRecommendation;
+    /**
+     * Calculate network factor (0-1)
+     */
+    private calculateNetworkFactor;
+    /**
+     * Calculate device factor (0-1)
+     */
+    private calculateDeviceFactor;
+    /**
+     * Estimate compression time for a level (in ms)
+     */
+    private estimateCompressionTime;
+    /**
+     * Estimate compression ratio for a level
+     */
+    private estimateCompressionRatio;
+    /**
+     * Apply recommendation and get new level
+     */
+    applyRecommendation(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    /**
+     * Get current level
+     */
+    getCurrentLevel(): 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+    /**
+     * Get statistics
+     */
+    getStats(): AdaptiveStats;
+    /**
+     * Get detailed analysis
+     */
+    getDetailedAnalysis(): {
+        stats: AdaptiveStats;
+        network: NetworkProfile;
+        device: DeviceProfile;
+        recommendation: CompressionRecommendation;
+        history: {
+            level: number;
+            ratio: number;
+            timeMs: number;
+            timestamp: number;
+        }[];
+    };
+}
+declare function getAdaptiveCompressionOptimizer(): AdaptiveCompressionOptimizer;
+declare function resetAdaptiveCompressionOptimizer(): void;
+
+export { type ActivityPattern, AdaptiveCompressionOptimizer, type AdaptiveStats, BatchTimingOptimizer, type BatchTimingStats, type CompressionRecommendation, type DeviceProfile, type NetworkProfile, type NetworkWindow, type OperationPattern, type OperationPrediction, type PrefetchedBatch, PrefetchingEngine, type PrefetchingStats, type SchedulingDecision, getAdaptiveCompressionOptimizer, getBatchTimingOptimizer, getPrefetchingEngine, resetAdaptiveCompressionOptimizer, resetBatchTimingOptimizer, resetPrefetchingEngine };