@affectively/aeon 1.0.0 → 1.2.0

package/dist/optimization/index.js

@@ -0,0 +1,787 @@
+// src/utils/logger.ts
+var consoleLogger = {
+  debug: (...args) => {
+    console.debug("[AEON:DEBUG]", ...args);
+  },
+  info: (...args) => {
+    console.info("[AEON:INFO]", ...args);
+  },
+  warn: (...args) => {
+    console.warn("[AEON:WARN]", ...args);
+  },
+  error: (...args) => {
+    console.error("[AEON:ERROR]", ...args);
+  }
+};
+var currentLogger = consoleLogger;
+function getLogger() {
+  return currentLogger;
+}
+
+// src/optimization/PrefetchingEngine.ts
+var logger = getLogger();
+var PrefetchingEngine = class {
+  operationHistory = [];
+  patterns = /* @__PURE__ */ new Map();
+  prefetchCache = /* @__PURE__ */ new Map();
+  maxHistoryEntries = 1e3;
+  maxCachePerType = 5;
+  prefetchTTL = 5 * 60 * 1e3;
+  // 5 minutes
+  predictionThreshold = 0.3;
+  stats = {
+    totalPrefetched: 0,
+    totalHits: 0,
+    totalMisses: 0,
+    totalOverwrites: 0,
+    hitRatio: 0,
+    bandwidthSaved: 0,
+    patternsDetected: 0,
+    predictionAccuracy: 0
+  };
+  lastPredictionTime = 0;
+  predictionInterval = 30 * 1e3;
+  constructor() {
+    logger.debug("[PrefetchingEngine] Initialized", {
+      ttl: this.prefetchTTL,
+      threshold: this.predictionThreshold
+    });
+  }
+  /**
+   * Record operation for pattern analysis
+   */
+  recordOperation(operationType, size) {
+    const now = Date.now();
+    this.operationHistory.push({
+      type: operationType,
+      timestamp: now,
+      size
+    });
+    if (this.operationHistory.length > this.maxHistoryEntries) {
+      this.operationHistory.shift();
+    }
+    if (Math.random() < 0.1) {
+      this.cleanExpiredPrefetches();
+    }
+    logger.debug("[PrefetchingEngine] Operation recorded", {
+      type: operationType,
+      size,
+      historySize: this.operationHistory.length
+    });
+  }
+  /**
+   * Analyze patterns in operation history
+   */
+  analyzePatterns() {
+    if (this.operationHistory.length < 5) {
+      return;
+    }
+    const patterns = /* @__PURE__ */ new Map();
+    for (let length = 2; length <= 3; length++) {
+      for (let i = 0; i < this.operationHistory.length - length; i++) {
+        const sequence = this.operationHistory.slice(i, i + length).map((op) => op.type);
+        const key = sequence.join(" \u2192 ");
+        if (!patterns.has(key)) {
+          patterns.set(key, {
+            sequence,
+            frequency: 0,
+            probability: 0,
+            lastOccurred: 0,
+            avgIntervalMs: 0
+          });
+        }
+        const pattern = patterns.get(key);
+        pattern.frequency++;
+        pattern.lastOccurred = Date.now();
+      }
+    }
+    const totalSequences = this.operationHistory.length;
+    for (const [key, pattern] of patterns.entries()) {
+      pattern.probability = Math.min(1, pattern.frequency / totalSequences);
+    }
+    this.patterns = patterns;
+    this.stats.patternsDetected = patterns.size;
+    logger.debug("[PrefetchingEngine] Patterns analyzed", {
+      patternsFound: patterns.size
+    });
+  }
+  /**
+   * Predict next operations
+   */
+  predictNextOperations(recentOperations) {
+    const now = Date.now();
+    if (now - this.lastPredictionTime > this.predictionInterval) {
+      this.analyzePatterns();
+      this.lastPredictionTime = now;
+    }
+    if (this.patterns.size === 0) {
+      return [];
+    }
+    const predictions = [];
+    const recentTypeSequence = recentOperations.slice(-3).map((op) => op.type).join(" \u2192 ");
+    for (const [key, pattern] of this.patterns.entries()) {
+      if (key.includes(recentTypeSequence)) {
+        const nextType = pattern.sequence[pattern.sequence.length - 1];
+        const prediction = {
+          operationType: nextType,
+          probability: pattern.probability,
+          reason: `Detected pattern: ${key}`,
+          shouldPrefetch: pattern.probability > this.predictionThreshold,
+          estimatedTimeMs: pattern.avgIntervalMs
+        };
+        predictions.push(prediction);
+      }
+    }
+    const deduped = Array.from(
+      new Map(predictions.map((p) => [p.operationType, p])).values()
+    ).sort((a, b) => b.probability - a.probability);
+    logger.debug("[PrefetchingEngine] Predictions", {
+      predictions: deduped.slice(0, 3).map((p) => ({
+        type: p.operationType,
+        probability: (p.probability * 100).toFixed(1) + "%"
+      }))
+    });
+    return deduped;
+  }
+  /**
+   * Add prefetched batch
+   */
+  addPrefetchedBatch(operationType, compressed, originalSize) {
+    if (!this.prefetchCache.has(operationType)) {
+      this.prefetchCache.set(operationType, []);
+    }
+    const cache = this.prefetchCache.get(operationType);
+    if (cache.length >= this.maxCachePerType) {
+      const oldest = cache.shift();
+      if (oldest.hitCount === 0) {
+        this.stats.totalMisses++;
+      } else {
+        this.stats.totalOverwrites++;
+      }
+    }
+    const batch = {
+      id: `prefetch-${operationType}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+      operationType,
+      compressed,
+      compressedSize: compressed.length,
+      originalSize,
+      compressionRatio: 1 - compressed.length / originalSize,
+      compressed_at: Date.now(),
+      created_at: Date.now(),
+      ttl: this.prefetchTTL,
+      expiresAt: Date.now() + this.prefetchTTL,
+      hitCount: 0,
+      missCount: 0
+    };
+    cache.push(batch);
+    this.stats.totalPrefetched++;
+    this.stats.bandwidthSaved += originalSize - compressed.length;
+    logger.debug("[PrefetchingEngine] Prefetched batch added", {
+      type: operationType,
+      id: batch.id,
+      ratio: (batch.compressionRatio * 100).toFixed(1) + "%"
+    });
+    return batch;
+  }
+  /**
+   * Try to use prefetched batch
+   */
+  getPrefetchedBatch(operationType) {
+    const cache = this.prefetchCache.get(operationType);
+    if (!cache || cache.length === 0) {
+      return null;
+    }
+    const now = Date.now();
+    for (let i = 0; i < cache.length; i++) {
+      const batch = cache[i];
+      if (batch.expiresAt > now) {
+        batch.hitCount++;
+        this.stats.totalHits++;
+        this.updatePredictionAccuracy(true);
+        logger.debug("[PrefetchingEngine] Prefetch hit", {
+          type: operationType,
+          id: batch.id
+        });
+        return batch;
+      } else {
+        cache.splice(i, 1);
+        i--;
+        batch.missCount++;
+        this.stats.totalMisses++;
+        this.updatePredictionAccuracy(false);
+      }
+    }
+    return null;
+  }
+  /**
+   * Update prediction accuracy metric
+   */
+  updatePredictionAccuracy(hit) {
+    const total = this.stats.totalHits + this.stats.totalMisses;
+    if (total === 0) return;
+    this.stats.predictionAccuracy = this.stats.totalHits / total;
+  }
+  /**
+   * Clean expired prefetches
+   */
+  cleanExpiredPrefetches() {
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [type, cache] of this.prefetchCache.entries()) {
+      for (let i = cache.length - 1; i >= 0; i--) {
+        if (cache[i].expiresAt < now) {
+          const batch = cache.splice(i, 1)[0];
+          if (batch.hitCount === 0) {
+            this.stats.totalMisses++;
+          }
+          cleanedCount++;
+        }
+      }
+      if (cache.length === 0) {
+        this.prefetchCache.delete(type);
+      }
+    }
+    if (cleanedCount > 0) {
+      logger.debug("[PrefetchingEngine] Cleaned expired prefetches", {
+        count: cleanedCount
+      });
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    const total = this.stats.totalHits + this.stats.totalMisses;
+    this.stats.hitRatio = total > 0 ? this.stats.totalHits / total : 0;
+    return { ...this.stats };
+  }
+  /**
+   * Clear all caches
+   */
+  clear() {
+    this.operationHistory = [];
+    this.patterns.clear();
+    this.prefetchCache.clear();
+    this.stats = {
+      totalPrefetched: 0,
+      totalHits: 0,
+      totalMisses: 0,
+      totalOverwrites: 0,
+      hitRatio: 0,
+      bandwidthSaved: 0,
+      patternsDetected: 0,
+      predictionAccuracy: 0
+    };
+    logger.debug("[PrefetchingEngine] Cleared all caches");
+  }
+};
+var prefetchingEngineInstance = null;
+function getPrefetchingEngine() {
+  if (!prefetchingEngineInstance) {
+    prefetchingEngineInstance = new PrefetchingEngine();
+  }
+  return prefetchingEngineInstance;
+}
+function resetPrefetchingEngine() {
+  prefetchingEngineInstance = null;
+}
+
+// src/optimization/BatchTimingOptimizer.ts
+var logger2 = getLogger();
+var BatchTimingOptimizer = class {
+  networkHistory = [];
+  activityHistory = [];
+  stats = {
+    totalBatches: 0,
+    immediateDeliveries: 0,
+    deferredBatches: 0,
+    averageWaitTimeMs: 0,
+    averageDeliveryTimeMs: 0,
+    networkWindowsUsed: 0,
+    congestionAvoided: 0,
+    userFocusedOptimizations: 0
+  };
+  lastActivityTime = Date.now();
+  isUserActive = true;
+  congestionDetectionWindow = 60 * 1e3;
+  optimalBatchSize = 50 * 1024;
+  constructor() {
+    logger2.debug("[BatchTimingOptimizer] Initialized", {
+      congestionWindow: this.congestionDetectionWindow,
+      optimalBatchSize: this.optimalBatchSize
+    });
+  }
+  /**
+   * Record network measurement
+   */
+  recordNetworkMeasurement(latencyMs, bandwidthMbps) {
+    const quality = this.assessNetworkQuality(latencyMs, bandwidthMbps);
+    this.networkHistory.push({
+      latencyMs,
+      bandwidthMbps,
+      timestamp: Date.now(),
+      quality
+    });
+    if (this.networkHistory.length > 100) {
+      this.networkHistory.shift();
+    }
+    this.stats.networkWindowsUsed++;
+    logger2.debug("[BatchTimingOptimizer] Network measured", {
+      latency: latencyMs + "ms",
+      bandwidth: bandwidthMbps.toFixed(1) + " Mbps",
+      quality
+    });
+  }
+  /**
+   * Assess network quality
+   */
+  assessNetworkQuality(latencyMs, bandwidthMbps) {
+    if (latencyMs < 20 && bandwidthMbps > 10) return "excellent";
+    if (latencyMs < 50 && bandwidthMbps > 5) return "good";
+    if (latencyMs < 100 && bandwidthMbps > 2) return "fair";
+    return "poor";
+  }
+  /**
+   * Detect congestion in network
+   */
+  detectCongestion() {
+    const recentMeasurements = this.networkHistory.filter(
+      (m) => Date.now() - m.timestamp < this.congestionDetectionWindow
+    );
+    if (recentMeasurements.length < 3) {
+      return 0;
+    }
+    const poorCount = recentMeasurements.filter(
+      (m) => m.quality === "poor"
+    ).length;
+    return poorCount / recentMeasurements.length;
+  }
+  /**
+   * Find next optimal network window
+   */
+  findOptimalWindow() {
+    const now = Date.now();
+    const recentMeasurements = this.networkHistory.slice(-20);
+    if (recentMeasurements.length === 0) {
+      return {
+        startTime: now,
+        endTime: now + 1e3,
+        expectedDurationMs: 1e3,
+        latencyMs: 50,
+        bandwidthMbps: 5,
+        quality: "good",
+        isStable: true,
+        congestionLevel: 0,
+        recommendedBatchSize: this.optimalBatchSize
+      };
+    }
+    const avgLatency = recentMeasurements.reduce((sum, m) => sum + m.latencyMs, 0) / recentMeasurements.length;
+    const avgBandwidth = recentMeasurements.reduce((sum, m) => sum + m.bandwidthMbps, 0) / recentMeasurements.length;
+    const latencyVariance = Math.sqrt(
+      recentMeasurements.reduce(
+        (sum, m) => sum + Math.pow(m.latencyMs - avgLatency, 2),
+        0
+      ) / recentMeasurements.length
+    ) / avgLatency;
+    const isStable = latencyVariance < 0.2;
+    const congestionLevel = this.detectCongestion();
+    const quality = this.assessNetworkQuality(avgLatency, avgBandwidth);
+    const recommendedBatchSize = Math.max(
+      10 * 1024,
+      Math.min(500 * 1024, avgBandwidth * 1024 * 100 / 8)
+    );
+    return {
+      startTime: now,
+      endTime: now + (isStable ? 30 * 1e3 : 10 * 1e3),
+      expectedDurationMs: isStable ? 30 * 1e3 : 10 * 1e3,
+      latencyMs: avgLatency,
+      bandwidthMbps: avgBandwidth,
+      quality,
+      isStable,
+      congestionLevel,
+      recommendedBatchSize
+    };
+  }
+  /**
+   * Get scheduling decision for a batch
+   */
+  getSchedulingDecision(batchSize, batchPriority = "normal", isUserTriggered = false) {
+    const now = Date.now();
+    const currentWindow = this.findOptimalWindow();
+    const congestionLevel = this.detectCongestion();
+    let shouldSendNow = false;
+    let recommendedDelay = 0;
+    let reason = "";
+    let priority = batchPriority;
+    if (priority === "critical") {
+      shouldSendNow = true;
+      reason = "Critical operation (bypass optimization)";
+    } else if (isUserTriggered && this.isUserActive) {
+      shouldSendNow = true;
+      reason = "User-triggered operation";
+      priority = "high";
+    } else if (currentWindow.quality === "excellent" || currentWindow.quality === "good") {
+      if (congestionLevel < 0.3) {
+        shouldSendNow = true;
+        reason = "Good network conditions";
+      } else {
+        shouldSendNow = true;
+        reason = "Good network despite some congestion";
+        recommendedDelay = 1e3 + Math.random() * 2e3;
+      }
+    } else if (currentWindow.quality === "fair") {
+      if (priority === "high") {
+        shouldSendNow = true;
+        reason = "High priority despite fair network";
+      } else {
+        shouldSendNow = false;
+        reason = "Fair network: waiting for better window";
+        recommendedDelay = 30 * 1e3 + Math.random() * 30 * 1e3;
+      }
+    } else {
+      shouldSendNow = false;
+      reason = "Poor network conditions: deferring";
+      if (priority === "high") {
+        recommendedDelay = 60 * 1e3 + Math.random() * 30 * 1e3;
+      } else {
+        recommendedDelay = 120 * 1e3 + Math.random() * 60 * 1e3;
+      }
+    }
+    const estimatedDeliveryMs = batchSize / (currentWindow.bandwidthMbps * 1024 * 1024 / 8) * 1e3 + currentWindow.latencyMs + recommendedDelay;
+    const decision = {
+      shouldSendNow,
+      nextOptimalWindowMs: now + recommendedDelay,
+      recommendedDelay,
+      reason,
+      priority,
+      estimatedDeliveryMs
+    };
+    logger2.debug("[BatchTimingOptimizer] Scheduling decision", {
+      size: (batchSize / 1024).toFixed(1) + " KB",
+      shouldSendNow,
+      delay: recommendedDelay + "ms",
+      reason
+    });
+    return decision;
+  }
+  /**
+   * Apply scheduling and update stats
+   */
+  applyScheduling(batchSize, sendNow, actualDelay) {
+    this.stats.totalBatches++;
+    if (sendNow) {
+      this.stats.immediateDeliveries++;
+    } else {
+      this.stats.deferredBatches++;
+    }
+    const totalWait = this.stats.averageWaitTimeMs * (this.stats.totalBatches - 1) + actualDelay;
+    this.stats.averageWaitTimeMs = totalWait / this.stats.totalBatches;
+    if (this.detectCongestion() > 0.3 && !sendNow) {
+      this.stats.congestionAvoided++;
+    }
+    if (this.isUserActive) {
+      this.stats.userFocusedOptimizations++;
+    }
+    this.stats.networkWindowsUsed++;
+  }
+  /**
+   * Get optimal batch size recommendation
+   */
+  getOptimalBatchSize() {
+    const window = this.findOptimalWindow();
+    return window.recommendedBatchSize;
+  }
+  /**
+   * Get current network window
+   */
+  getCurrentNetworkWindow() {
+    return this.findOptimalWindow();
+  }
+  /**
+   * Set user activity state
+   */
+  setUserActive(active) {
+    this.isUserActive = active;
+    if (active) {
+      this.lastActivityTime = Date.now();
+    }
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Clear history
+   */
+  clear() {
+    this.networkHistory = [];
+    this.activityHistory = [];
+    this.stats = {
+      totalBatches: 0,
+      immediateDeliveries: 0,
+      deferredBatches: 0,
+      averageWaitTimeMs: 0,
+      averageDeliveryTimeMs: 0,
+      networkWindowsUsed: 0,
+      congestionAvoided: 0,
+      userFocusedOptimizations: 0
+    };
+  }
+};
+var batchTimingOptimizerInstance = null;
+function getBatchTimingOptimizer() {
+  if (!batchTimingOptimizerInstance) {
+    batchTimingOptimizerInstance = new BatchTimingOptimizer();
+  }
+  return batchTimingOptimizerInstance;
+}
+function resetBatchTimingOptimizer() {
+  batchTimingOptimizerInstance = null;
+}
+
+// src/optimization/AdaptiveCompressionOptimizer.ts
+var logger3 = getLogger();
+var AdaptiveCompressionOptimizer = class {
+  currentLevel = 6;
+  networkProfile = {
+    estimatedSpeedKbps: 5e3,
+    latencyMs: 50,
+    isOnline: true,
+    isWifi: false,
+    isFast: true,
+    isSlow: false,
+    isEmpty: false
+  };
+  deviceProfile = {
+    cpuCores: 4,
+    cpuUtilization: 0.3,
+    memoryAvailableMB: 512,
+    memoryTotalMB: 1024,
+    isConstrained: false,
+    isPremium: false,
+    supportsWebWorkers: true,
+    supportsWebAssembly: true
+  };
+  compressionHistory = [];
+  stats = {
+    currentLevel: 6,
+    averageCompressionMs: 10,
+    averageRatio: 0.85,
+    levelsUsed: /* @__PURE__ */ new Set([6]),
+    adjustmentCount: 0,
+    totalBatches: 0,
+    networkCondition: "normal"
+  };
+  constructor() {
+    logger3.debug("[AdaptiveCompressionOptimizer] Initialized", {
+      level: this.currentLevel
+    });
+  }
+  /**
+   * Update network conditions
+   */
+  updateNetworkConditions(speedKbps, latencyMs, isOnline) {
+    this.networkProfile.estimatedSpeedKbps = speedKbps;
+    if (latencyMs !== void 0) {
+      this.networkProfile.latencyMs = latencyMs;
+    }
+    if (isOnline !== void 0) {
+      this.networkProfile.isOnline = isOnline;
+    }
+    this.networkProfile.isFast = speedKbps > 5e3;
+    this.networkProfile.isSlow = speedKbps < 1e3;
+    this.networkProfile.isEmpty = speedKbps < 100;
+    if (isOnline === false) {
+      this.stats.networkCondition = "offline";
+    } else if (this.networkProfile.isSlow) {
+      this.stats.networkCondition = "slow";
+    } else if (this.networkProfile.isFast) {
+      this.stats.networkCondition = "fast";
+    } else {
+      this.stats.networkCondition = "normal";
+    }
+    logger3.debug("[AdaptiveCompressionOptimizer] Network updated", {
+      speedKbps,
+      condition: this.stats.networkCondition
+    });
+  }
+  /**
+   * Update device resource usage
+   */
+  updateDeviceResources(cpuUtilization, memoryAvailableMB) {
+    this.deviceProfile.cpuUtilization = Math.max(
+      0,
+      Math.min(1, cpuUtilization)
+    );
+    this.deviceProfile.memoryAvailableMB = memoryAvailableMB;
+    this.deviceProfile.isConstrained = memoryAvailableMB < 512;
+    this.deviceProfile.isPremium = memoryAvailableMB > 2048;
+    logger3.debug("[AdaptiveCompressionOptimizer] Device resources updated", {
+      cpuUtilization: (cpuUtilization * 100).toFixed(1) + "%",
+      memoryAvailableMB
+    });
+  }
+  /**
+   * Record compression performance
+   */
+  recordCompressionPerformance(level, compressionMs, ratio) {
+    this.compressionHistory.push({
+      level,
+      ratio,
+      timeMs: compressionMs,
+      timestamp: Date.now()
+    });
+    if (this.compressionHistory.length > 100) {
+      this.compressionHistory.shift();
+    }
+    this.stats.totalBatches++;
+    this.stats.averageCompressionMs = this.compressionHistory.reduce((sum, h) => sum + h.timeMs, 0) / this.compressionHistory.length;
+    this.stats.averageRatio = this.compressionHistory.reduce((sum, h) => sum + h.ratio, 0) / this.compressionHistory.length;
+  }
+  /**
+   * Get compression recommendation based on conditions
+   */
+  getRecommendedLevel() {
+    const networkFactor = this.calculateNetworkFactor();
+    const deviceFactor = this.calculateDeviceFactor();
+    const combinedFactor = (networkFactor + deviceFactor) / 2;
+    const recommendedLevel = Math.max(
+      1,
+      Math.min(9, Math.round(combinedFactor * 9))
+    );
+    const estimatedCompressionMs = this.estimateCompressionTime(recommendedLevel);
+    const estimatedRatio = this.estimateCompressionRatio(recommendedLevel);
+    let reason = "";
+    if (networkFactor < 0.3 && deviceFactor < 0.3) {
+      reason = "Slow network + constrained device: using level 1-2 (fast)";
+    } else if (networkFactor > 0.7 && deviceFactor > 0.7) {
+      reason = "Fast network + premium device: using level 8-9 (best compression)";
+    } else if (networkFactor > 0.7) {
+      reason = "Fast network: prioritizing compression ratio";
+    } else if (deviceFactor < 0.3) {
+      reason = "Constrained device: prioritizing speed";
+    } else {
+      reason = "Normal conditions: balanced compression level";
+    }
+    const recommendation = {
+      recommendedLevel,
+      reason,
+      confidence: this.compressionHistory.length > 10 ? 0.9 : 0.5,
+      estimatedCompressionMs,
+      estimatedRatio,
+      networkFactor,
+      deviceFactor
+    };
+    logger3.debug(
+      "[AdaptiveCompressionOptimizer] Recommendation",
+      recommendation
+    );
+    return recommendation;
+  }
+  /**
+   * Calculate network factor (0-1)
+   */
+  calculateNetworkFactor() {
+    if (!this.networkProfile.isOnline) return 0;
+    const speedMbps = this.networkProfile.estimatedSpeedKbps / 1e3;
+    if (speedMbps < 0.1) return 0;
+    if (speedMbps < 1) return 0.1 + speedMbps / 1 * 0.2;
+    if (speedMbps < 5) return 0.3 + (speedMbps - 1) / 4 * 0.3;
+    if (speedMbps < 20) return 0.6 + (speedMbps - 5) / 15 * 0.3;
+    return Math.min(1, 0.9 + (speedMbps - 20) / 200);
+  }
+  /**
+   * Calculate device factor (0-1)
+   */
+  calculateDeviceFactor() {
+    let factor = 0.5;
+    if (this.deviceProfile.isPremium) {
+      factor = 0.8;
+    } else if (this.deviceProfile.isConstrained) {
+      factor = 0.2;
+    }
+    if (this.deviceProfile.cpuUtilization > 0.8) {
+      factor *= 0.7;
+    } else if (this.deviceProfile.cpuUtilization < 0.2) {
+      factor *= 1.1;
+    }
+    if (this.deviceProfile.supportsWebAssembly) {
+      factor = Math.min(1, factor + 0.1);
+    }
+    return Math.max(0, Math.min(1, factor));
+  }
+  /**
+   * Estimate compression time for a level (in ms)
+   */
+  estimateCompressionTime(level) {
+    return Math.max(1, level * 2.5);
+  }
+  /**
+   * Estimate compression ratio for a level
+   */
+  estimateCompressionRatio(level) {
+    return 0.6 + level / 9 * 0.3;
+  }
+  /**
+   * Apply recommendation and get new level
+   */
+  applyRecommendation() {
+    const recommendation = this.getRecommendedLevel();
+    const oldLevel = this.currentLevel;
+    const shouldChange = recommendation.confidence > 0.7 || Math.abs(recommendation.recommendedLevel - oldLevel) > 2;
+    if (shouldChange) {
+      this.currentLevel = recommendation.recommendedLevel;
+      this.stats.levelsUsed.add(this.currentLevel);
+      if (oldLevel !== this.currentLevel) {
+        this.stats.adjustmentCount++;
+        logger3.debug("[AdaptiveCompressionOptimizer] Level adjusted", {
+          from: oldLevel,
+          to: this.currentLevel,
+          reason: recommendation.reason
+        });
+      }
+    }
+    this.stats.currentLevel = this.currentLevel;
+    return this.currentLevel;
+  }
+  /**
+   * Get current level
+   */
+  getCurrentLevel() {
+    return this.currentLevel;
+  }
+  /**
+   * Get statistics
+   */
+  getStats() {
+    return { ...this.stats };
+  }
+  /**
+   * Get detailed analysis
+   */
+  getDetailedAnalysis() {
+    return {
+      stats: this.stats,
+      network: this.networkProfile,
+      device: this.deviceProfile,
+      recommendation: this.getRecommendedLevel(),
+      history: this.compressionHistory.slice(-20)
+    };
+  }
+};
+var adaptiveOptimizerInstance = null;
+function getAdaptiveCompressionOptimizer() {
+  if (!adaptiveOptimizerInstance) {
+    adaptiveOptimizerInstance = new AdaptiveCompressionOptimizer();
+  }
+  return adaptiveOptimizerInstance;
+}
+function resetAdaptiveCompressionOptimizer() {
+  adaptiveOptimizerInstance = null;
+}
+
+export { AdaptiveCompressionOptimizer, BatchTimingOptimizer, PrefetchingEngine, getAdaptiveCompressionOptimizer, getBatchTimingOptimizer, getPrefetchingEngine, resetAdaptiveCompressionOptimizer, resetBatchTimingOptimizer, resetPrefetchingEngine };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map