@tachui/core 0.7.0-alpha1

package/dist/validation/performance-optimizer.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-optimizer.cjs","sources":["../../src/validation/performance-optimizer.ts"],"sourcesContent":["/**\n * Performance Optimization System - Phase 1C\n * \n * Advanced performance optimizations to reduce validation overhead\n * to <5% impact in development mode with smart caching and batching.\n */\n\nimport { ProductionModeManager } from './production-bypass'\nimport { validationDebugger } from './debug-tools'\n\n/**\n * Performance optimization configuration\n */\nexport interface PerformanceOptimizerConfig {\n  enabled: boolean\n  targetOverhead: number // percentage (5 = 5%)\n  batchSize: number\n  cacheStrategy: 'aggressive' | 'moderate' | 'conservative'\n  asyncValidation: boolean\n  throttleMs: number\n  skipFrames: number // Skip validation every N frames\n}\n\n/**\n * Validation operation metrics\n */\nexport interface ValidationMetrics {\n  operationCount: number\n  totalTime: number\n  averageTime: number\n  maxTime: number\n  cacheHitRate: number\n  skipRate: number\n}\n\n/**\n * Performance optimization engine\n */\nexport class PerformanceOptimizer {\n  private static instance: PerformanceOptimizer\n  private config: PerformanceOptimizerConfig\n  private metrics = new Map<string, ValidationMetrics>()\n  private operationQueue: Array<() => void> = []\n  private frameCounter = 0\n  private lastBatchTime = 0\n  private throttleTimers = new Map<string, number>()\n  \n  // Advanced caching\n  private resultCache = new Map<string, { result: any; timestamp: number; hits: number }>()\n  \n  // Performance monitoring\n  private performanceObserver?: PerformanceObserver\n  private frameTimeTarget = 16.67 // 60fps target\n\n  constructor(config: Partial<PerformanceOptimizerConfig> = {}) {\n    this.config = {\n      enabled: process.env.NODE_ENV !== 'production',\n      targetOverhead: 5, // 5% overhead target\n      batchSize: 10,\n      cacheStrategy: 'moderate',\n      asyncValidation: true,\n      throttleMs: 16, // One frame\n      skipFrames: 0, // Don't skip by default\n      ...config\n    }\n\n    this.initializePerformanceMonitoring()\n  }\n\n  static getInstance(config?: Partial<PerformanceOptimizerConfig>): PerformanceOptimizer {\n    if (!this.instance) {\n      this.instance = new PerformanceOptimizer(config)\n    }\n    return this.instance\n  }\n\n  /**\n   * Optimize validation function with caching and batching\n   */\n  optimizeValidation<T>(\n    key: string,\n    validationFn: () => T,\n    options: {\n      cache?: boolean\n      batch?: boolean\n      throttle?: boolean\n      priority?: 'high' | 'medium' | 'low'\n    } = {}\n  ): T | Promise<T> {\n    // Skip optimization in production\n    if (ProductionModeManager.shouldBypassValidation()) {\n      return validationFn()\n    }\n\n    const {\n      cache = true,\n      batch = false,\n      throttle = false,\n      priority = 'medium'\n    } = options\n\n    // Check cache first\n    if (cache) {\n      const cached = this.getCachedResult(key)\n      if (cached !== undefined) {\n        this.updateMetrics(key, 0, true, false) // Cache hit\n        return cached\n      }\n    }\n\n    // Apply frame skipping if configured\n    if (this.shouldSkipFrame()) {\n      this.updateMetrics(key, 0, false, true) // Skipped\n      return this.getFallbackResult()\n    }\n\n    // Apply throttling\n    if (throttle && this.isThrottled(key)) {\n      return this.getFallbackResult()\n    }\n\n    const startTime = performance.now()\n\n    try {\n      let result: T\n\n      if (batch && priority !== 'high') {\n        // Add to batch queue for low priority operations\n        return this.addToBatch(key, validationFn, cache) as Promise<T>\n      } else {\n        // Execute immediately\n        result = validationFn()\n      }\n\n      const endTime = performance.now()\n      const duration = endTime - startTime\n\n      // Cache result if enabled\n      if (cache) {\n        this.cacheResult(key, result)\n      }\n\n      // Update metrics\n      this.updateMetrics(key, duration, false, false)\n\n      // Check performance impact\n      this.checkPerformanceImpact(duration)\n\n      return result\n\n    } catch (error) {\n      const endTime = performance.now()\n      this.updateMetrics(key, endTime - startTime, false, false)\n      throw error\n    }\n  }\n\n  /**\n   * Smart caching with TTL and popularity-based eviction\n   */\n  private getCachedResult(key: string): any {\n    const cached = this.resultCache.get(key)\n    if (!cached) return undefined\n\n    // Check TTL based on cache strategy\n    const ttl = this.getCacheTTL()\n    if (Date.now() - cached.timestamp > ttl) {\n      this.resultCache.delete(key)\n      return undefined\n    }\n\n    // Update hit count\n    cached.hits++\n    return cached.result\n  }\n\n  /**\n   * Cache result with intelligent eviction\n   */\n  private cacheResult(key: string, result: any): void {\n    const maxCacheSize = this.getMaxCacheSize()\n    \n    // Evict least popular entries if cache is full\n    if (this.resultCache.size >= maxCacheSize) {\n      this.evictLeastPopular()\n    }\n\n    this.resultCache.set(key, {\n      result,\n      timestamp: Date.now(),\n      hits: 1\n    })\n  }\n\n  /**\n   * Evict least popular cache entries\n   */\n  private evictLeastPopular(): void {\n    const entries = Array.from(this.resultCache.entries())\n    \n    // Sort by hits (ascending) and timestamp (ascending)\n    entries.sort((a, b) => {\n      if (a[1].hits !== b[1].hits) {\n        return a[1].hits - b[1].hits\n      }\n      return a[1].timestamp - b[1].timestamp\n    })\n\n    // Remove bottom 25%\n    const removeCount = Math.floor(entries.length * 0.25)\n    for (let i = 0; i < removeCount; i++) {\n      this.resultCache.delete(entries[i][0])\n    }\n  }\n\n  /**\n   * Get cache TTL based on strategy\n   */\n  private getCacheTTL(): number {\n    switch (this.config.cacheStrategy) {\n      case 'aggressive': return 300000 // 5 minutes\n      case 'moderate': return 60000   // 1 minute\n      case 'conservative': return 10000 // 10 seconds\n      default: return 60000\n    }\n  }\n\n  /**\n   * Get max cache size based on strategy\n   */\n  private getMaxCacheSize(): number {\n    switch (this.config.cacheStrategy) {\n      case 'aggressive': return 1000\n      case 'moderate': return 500\n      case 'conservative': return 100\n      default: return 500\n    }\n  }\n\n  /**\n   * Check if operation should skip this frame\n   */\n  private shouldSkipFrame(): boolean {\n    if (this.config.skipFrames === 0) return false\n    \n    this.frameCounter++\n    return this.frameCounter % (this.config.skipFrames + 1) !== 0\n  }\n\n  /**\n   * Check if operation is throttled\n   */\n  private isThrottled(key: string): boolean {\n    const lastTime = this.throttleTimers.get(key) || 0\n    const now = Date.now()\n    \n    if (now - lastTime < this.config.throttleMs) {\n      return true\n    }\n    \n    this.throttleTimers.set(key, now)\n    return false\n  }\n\n  /**\n   * Add operation to batch queue\n   */\n  private addToBatch<T>(key: string, fn: () => T, cache: boolean): Promise<T> {\n    return new Promise((resolve, reject) => {\n      this.operationQueue.push(() => {\n        try {\n          const result = fn()\n          if (cache) {\n            this.cacheResult(key, result)\n          }\n          resolve(result)\n        } catch (error) {\n          reject(error)\n        }\n      })\n\n      // Process batch if it's full or enough time has passed\n      this.processBatchIfReady()\n    })\n  }\n\n  /**\n   * Process batch queue if conditions are met\n   */\n  private processBatchIfReady(): void {\n    const now = Date.now()\n    const shouldProcess = \n      this.operationQueue.length >= this.config.batchSize ||\n      (this.operationQueue.length > 0 && now - this.lastBatchTime > this.config.throttleMs)\n\n    if (shouldProcess) {\n      this.processBatch()\n    }\n  }\n\n  /**\n   * Process batch queue\n   */\n  private processBatch(): void {\n    if (this.operationQueue.length === 0) return\n\n    const batch = this.operationQueue.splice(0, this.config.batchSize)\n    this.lastBatchTime = Date.now()\n\n    if (this.config.asyncValidation) {\n      // Process asynchronously to not block the main thread\n      setTimeout(() => {\n        batch.forEach(operation => operation())\n      }, 0)\n    } else {\n      // Process synchronously\n      batch.forEach(operation => operation())\n    }\n  }\n\n  /**\n   * Update operation metrics\n   */\n  private updateMetrics(key: string, duration: number, cacheHit: boolean, skipped: boolean): void {\n    let metrics = this.metrics.get(key)\n    if (!metrics) {\n      metrics = {\n        operationCount: 0,\n        totalTime: 0,\n        averageTime: 0,\n        maxTime: 0,\n        cacheHitRate: 0,\n        skipRate: 0\n      }\n      this.metrics.set(key, metrics)\n    }\n\n    metrics.operationCount++\n    \n    if (!cacheHit && !skipped) {\n      metrics.totalTime += duration\n      metrics.averageTime = metrics.totalTime / metrics.operationCount\n      metrics.maxTime = Math.max(metrics.maxTime, duration)\n    }\n\n    // Update rates\n    const totalOperations = metrics.operationCount\n    const cacheHits = Math.floor(metrics.cacheHitRate * totalOperations) + (cacheHit ? 1 : 0)\n    const skips = Math.floor(metrics.skipRate * totalOperations) + (skipped ? 1 : 0)\n    \n    metrics.cacheHitRate = cacheHits / totalOperations\n    metrics.skipRate = skips / totalOperations\n  }\n\n  /**\n   * Check if performance impact exceeds target\n   */\n  private checkPerformanceImpact(duration: number): void {\n    const frameTime = this.frameTimeTarget\n    const impactPercentage = (duration / frameTime) * 100\n\n    if (impactPercentage > this.config.targetOverhead) {\n      // Automatically adjust optimization settings\n      this.autoOptimize(impactPercentage)\n      \n      validationDebugger.logEvent(\n        'performance-warning',\n        `Validation overhead: ${impactPercentage.toFixed(1)}% (target: ${this.config.targetOverhead}%)`,\n        { duration, target: this.config.targetOverhead, actual: impactPercentage }\n      )\n    }\n  }\n\n  /**\n   * Automatically adjust optimization settings\n   */\n  private autoOptimize(currentImpact: number): void {\n    const factor = currentImpact / this.config.targetOverhead\n\n    if (factor > 2) {\n      // Very high impact - aggressive optimization\n      this.config.cacheStrategy = 'aggressive'\n      this.config.skipFrames = Math.max(1, this.config.skipFrames)\n      this.config.throttleMs = Math.max(this.config.throttleMs, 32)\n      this.config.batchSize = Math.min(this.config.batchSize, 5)\n    } else if (factor > 1.5) {\n      // High impact - moderate optimization\n      this.config.cacheStrategy = 'aggressive'\n      this.config.throttleMs = Math.max(this.config.throttleMs, 16)\n    }\n  }\n\n  /**\n   * Get fallback result for skipped/throttled operations\n   */\n  private getFallbackResult(): any {\n    // Return a safe default that won't cause errors\n    // In practice, this would be context-specific\n    return true\n  }\n\n  /**\n   * Initialize performance monitoring\n   */\n  private initializePerformanceMonitoring(): void {\n    if (typeof PerformanceObserver !== 'undefined') {\n      try {\n        this.performanceObserver = new PerformanceObserver((list) => {\n          const entries = list.getEntries()\n          entries.forEach((entry) => {\n            if (entry.name.includes('tachui-validation')) {\n              this.analyzePerformanceEntry(entry)\n            }\n          })\n        })\n        \n        this.performanceObserver.observe({ entryTypes: ['measure', 'navigation', 'paint'] })\n      } catch (_error) {\n        // PerformanceObserver not supported\n      }\n    }\n  }\n\n  /**\n   * Analyze performance entry\n   */\n  private analyzePerformanceEntry(entry: PerformanceEntry): void {\n    if (entry.duration > this.frameTimeTarget) {\n      console.warn(`⚠️ Slow validation operation: ${entry.name} took ${entry.duration.toFixed(2)}ms`)\n    }\n  }\n\n  /**\n   * Get performance statistics\n   */\n  getPerformanceStats() {\n    const totalOperations = Array.from(this.metrics.values())\n      .reduce((sum, metrics) => sum + metrics.operationCount, 0)\n    \n    const totalTime = Array.from(this.metrics.values())\n      .reduce((sum, metrics) => sum + metrics.totalTime, 0)\n    \n    const averageTime = totalOperations > 0 ? totalTime / totalOperations : 0\n    \n    const cacheHitRate = Array.from(this.metrics.values())\n      .reduce((sum, metrics) => sum + metrics.cacheHitRate, 0) / this.metrics.size || 0\n    \n    const skipRate = Array.from(this.metrics.values())\n      .reduce((sum, metrics) => sum + metrics.skipRate, 0) / this.metrics.size || 0\n\n    return {\n      config: this.config,\n      totalOperations,\n      totalTime,\n      averageTime,\n      cacheHitRate,\n      skipRate,\n      cacheSize: this.resultCache.size,\n      queueSize: this.operationQueue.length,\n      frameImpact: (averageTime / this.frameTimeTarget) * 100,\n      targetMet: (averageTime / this.frameTimeTarget) * 100 <= this.config.targetOverhead,\n      operations: Object.fromEntries(this.metrics)\n    }\n  }\n\n  /**\n   * Clear all caches and reset metrics\n   */\n  reset(): void {\n    this.resultCache.clear()\n    this.metrics.clear()\n    this.operationQueue = []\n    this.throttleTimers.clear()\n    this.frameCounter = 0\n    this.lastBatchTime = 0\n  }\n\n  /**\n   * Configure optimizer\n   */\n  configure(config: Partial<PerformanceOptimizerConfig>): void {\n    this.config = { ...this.config, ...config }\n  }\n\n  /**\n   * Force process all batched operations\n   */\n  flush(): void {\n    while (this.operationQueue.length > 0) {\n      this.processBatch()\n    }\n  }\n\n  /**\n   * Get cache statistics\n   */\n  getCacheStats() {\n    const entries = Array.from(this.resultCache.values())\n    const totalHits = entries.reduce((sum, entry) => sum + entry.hits, 0)\n    const averageAge = entries.length > 0 \n      ? entries.reduce((sum, entry) => sum + (Date.now() - entry.timestamp), 0) / entries.length\n      : 0\n\n    return {\n      size: this.resultCache.size,\n      maxSize: this.getMaxCacheSize(),\n      totalHits,\n      averageAge,\n      strategy: this.config.cacheStrategy,\n      ttl: this.getCacheTTL()\n    }\n  }\n}\n\n// Global optimizer instance\nexport const performanceOptimizer = PerformanceOptimizer.getInstance()\n\n// Performance optimization utilities\nexport const PerformanceOptimizationUtils = {\n  /**\n   * Configure performance optimizer\n   */\n  configure: (config: Partial<PerformanceOptimizerConfig>) => \n    performanceOptimizer.configure(config),\n\n  /**\n   * Get performance statistics\n   */\n  getStats: () => performanceOptimizer.getPerformanceStats(),\n\n  /**\n   * Get cache statistics\n   */\n  getCacheStats: () => performanceOptimizer.getCacheStats(),\n\n  /**\n   * Reset optimizer\n   */\n  reset: () => performanceOptimizer.reset(),\n\n  /**\n   * Flush batched operations\n   */\n  flush: () => performanceOptimizer.flush(),\n\n  /**\n   * Optimize validation function\n   */\n  optimize: <T>(\n    key: string,\n    fn: () => T,\n    options?: {\n      cache?: boolean\n      batch?: boolean\n      throttle?: boolean\n      priority?: 'high' | 'medium' | 'low'\n    }\n  ) => performanceOptimizer.optimizeValidation(key, fn, options),\n\n  /**\n   * Test performance optimization\n   */\n  test: () => {\n    console.group('⚡ Performance Optimization Test')\n    \n    try {\n      const startTime = performance.now()\n      \n      // Test optimization with different scenarios\n      const results = []\n      \n      // Test caching\n      for (let i = 0; i < 100; i++) {\n        const result = performanceOptimizer.optimizeValidation(\n          'test-cache',\n          () => Math.random(),\n          { cache: true }\n        )\n        results.push(result)\n      }\n      \n      const endTime = performance.now()\n      const duration = endTime - startTime\n      const stats = performanceOptimizer.getPerformanceStats()\n      \n      console.info('✅ Optimization system active:', stats.config.enabled)\n      console.info('✅ Test duration:', `${duration.toFixed(2)}ms`)\n      console.info('✅ Cache hit rate:', `${(stats.cacheHitRate * 100).toFixed(1)}%`)\n      console.info('✅ Frame impact:', `${stats.frameImpact.toFixed(1)}% (target: ${stats.config.targetOverhead}%)`)\n      console.info('✅ Target met:', stats.targetMet)\n      console.info('✅ Performance optimization is working correctly')\n      \n    } catch (error) {\n      console.error('❌ Performance optimization test failed:', error)\n    }\n    \n    console.groupEnd()\n  }\n}"],"names":["_PerformanceOptimizer","config","__publicField","key","validationFn","options","ProductionModeManager","cache","batch","throttle","priority","cached","startTime","result","duration","error","endTime","ttl","maxCacheSize","entries","a","b","removeCount","lastTime","now","fn","resolve","reject","operation","cacheHit","skipped","metrics","totalOperations","cacheHits","skips","frameTime","impactPercentage","validationDebugger","currentImpact","factor","list","entry","sum","totalTime","averageTime","cacheHitRate","skipRate","totalHits","averageAge","PerformanceOptimizer","performanceOptimizer","PerformanceOptimizationUtils","results","i","stats"],"mappings":"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"}

package/dist/validation/performance-optimizer.d.ts

@@ -0,0 +1,218 @@
+/**
+ * Performance Optimization System - Phase 1C
+ *
+ * Advanced performance optimizations to reduce validation overhead
+ * to <5% impact in development mode with smart caching and batching.
+ */
+/**
+ * Performance optimization configuration
+ */
+export interface PerformanceOptimizerConfig {
+    enabled: boolean;
+    targetOverhead: number;
+    batchSize: number;
+    cacheStrategy: 'aggressive' | 'moderate' | 'conservative';
+    asyncValidation: boolean;
+    throttleMs: number;
+    skipFrames: number;
+}
+/**
+ * Validation operation metrics
+ */
+export interface ValidationMetrics {
+    operationCount: number;
+    totalTime: number;
+    averageTime: number;
+    maxTime: number;
+    cacheHitRate: number;
+    skipRate: number;
+}
+/**
+ * Performance optimization engine
+ */
+export declare class PerformanceOptimizer {
+    private static instance;
+    private config;
+    private metrics;
+    private operationQueue;
+    private frameCounter;
+    private lastBatchTime;
+    private throttleTimers;
+    private resultCache;
+    private performanceObserver?;
+    private frameTimeTarget;
+    constructor(config?: Partial<PerformanceOptimizerConfig>);
+    static getInstance(config?: Partial<PerformanceOptimizerConfig>): PerformanceOptimizer;
+    /**
+     * Optimize validation function with caching and batching
+     */
+    optimizeValidation<T>(key: string, validationFn: () => T, options?: {
+        cache?: boolean;
+        batch?: boolean;
+        throttle?: boolean;
+        priority?: 'high' | 'medium' | 'low';
+    }): T | Promise<T>;
+    /**
+     * Smart caching with TTL and popularity-based eviction
+     */
+    private getCachedResult;
+    /**
+     * Cache result with intelligent eviction
+     */
+    private cacheResult;
+    /**
+     * Evict least popular cache entries
+     */
+    private evictLeastPopular;
+    /**
+     * Get cache TTL based on strategy
+     */
+    private getCacheTTL;
+    /**
+     * Get max cache size based on strategy
+     */
+    private getMaxCacheSize;
+    /**
+     * Check if operation should skip this frame
+     */
+    private shouldSkipFrame;
+    /**
+     * Check if operation is throttled
+     */
+    private isThrottled;
+    /**
+     * Add operation to batch queue
+     */
+    private addToBatch;
+    /**
+     * Process batch queue if conditions are met
+     */
+    private processBatchIfReady;
+    /**
+     * Process batch queue
+     */
+    private processBatch;
+    /**
+     * Update operation metrics
+     */
+    private updateMetrics;
+    /**
+     * Check if performance impact exceeds target
+     */
+    private checkPerformanceImpact;
+    /**
+     * Automatically adjust optimization settings
+     */
+    private autoOptimize;
+    /**
+     * Get fallback result for skipped/throttled operations
+     */
+    private getFallbackResult;
+    /**
+     * Initialize performance monitoring
+     */
+    private initializePerformanceMonitoring;
+    /**
+     * Analyze performance entry
+     */
+    private analyzePerformanceEntry;
+    /**
+     * Get performance statistics
+     */
+    getPerformanceStats(): {
+        config: PerformanceOptimizerConfig;
+        totalOperations: number;
+        totalTime: number;
+        averageTime: number;
+        cacheHitRate: number;
+        skipRate: number;
+        cacheSize: number;
+        queueSize: number;
+        frameImpact: number;
+        targetMet: boolean;
+        operations: {
+            [k: string]: ValidationMetrics;
+        };
+    };
+    /**
+     * Clear all caches and reset metrics
+     */
+    reset(): void;
+    /**
+     * Configure optimizer
+     */
+    configure(config: Partial<PerformanceOptimizerConfig>): void;
+    /**
+     * Force process all batched operations
+     */
+    flush(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        totalHits: number;
+        averageAge: number;
+        strategy: "aggressive" | "moderate" | "conservative";
+        ttl: number;
+    };
+}
+export declare const performanceOptimizer: PerformanceOptimizer;
+export declare const PerformanceOptimizationUtils: {
+    /**
+     * Configure performance optimizer
+     */
+    configure: (config: Partial<PerformanceOptimizerConfig>) => void;
+    /**
+     * Get performance statistics
+     */
+    getStats: () => {
+        config: PerformanceOptimizerConfig;
+        totalOperations: number;
+        totalTime: number;
+        averageTime: number;
+        cacheHitRate: number;
+        skipRate: number;
+        cacheSize: number;
+        queueSize: number;
+        frameImpact: number;
+        targetMet: boolean;
+        operations: {
+            [k: string]: ValidationMetrics;
+        };
+    };
+    /**
+     * Get cache statistics
+     */
+    getCacheStats: () => {
+        size: number;
+        maxSize: number;
+        totalHits: number;
+        averageAge: number;
+        strategy: "aggressive" | "moderate" | "conservative";
+        ttl: number;
+    };
+    /**
+     * Reset optimizer
+     */
+    reset: () => void;
+    /**
+     * Flush batched operations
+     */
+    flush: () => void;
+    /**
+     * Optimize validation function
+     */
+    optimize: <T>(key: string, fn: () => T, options?: {
+        cache?: boolean;
+        batch?: boolean;
+        throttle?: boolean;
+        priority?: "high" | "medium" | "low";
+    }) => T | Promise<T>;
+    /**
+     * Test performance optimization
+     */
+    test: () => void;
+};
+//# sourceMappingURL=performance-optimizer.d.ts.map

package/dist/validation/performance-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance-optimizer.d.ts","sourceRoot":"","sources":["../../src/validation/performance-optimizer.ts"],"names":[],"mappings":"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"}

package/dist/validation/performance-optimizer.js

@@ -0,0 +1,338 @@
+import { ProductionModeManager as d } from "./production-bypass.js";
+import { validationDebugger as T } from "./debug-tools.js";
+var v = Object.defineProperty, z = (o, e, t) => e in o ? v(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t, n = (o, e, t) => z(o, typeof e != "symbol" ? e + "" : e, t);
+const g = class p {
+  // 60fps target
+  constructor(e = {}) {
+    n(this, "config"), n(this, "metrics", /* @__PURE__ */ new Map()), n(this, "operationQueue", []), n(this, "frameCounter", 0), n(this, "lastBatchTime", 0), n(this, "throttleTimers", /* @__PURE__ */ new Map()), n(this, "resultCache", /* @__PURE__ */ new Map()), n(this, "performanceObserver"), n(this, "frameTimeTarget", 16.67), this.config = {
+      enabled: process.env.NODE_ENV !== "production",
+      targetOverhead: 5,
+      // 5% overhead target
+      batchSize: 10,
+      cacheStrategy: "moderate",
+      asyncValidation: !0,
+      throttleMs: 16,
+      // One frame
+      skipFrames: 0,
+      // Don't skip by default
+      ...e
+    }, this.initializePerformanceMonitoring();
+  }
+  static getInstance(e) {
+    return this.instance || (this.instance = new p(e)), this.instance;
+  }
+  /**
+   * Optimize validation function with caching and batching
+   */
+  optimizeValidation(e, t, i = {}) {
+    if (d.shouldBypassValidation())
+      return t();
+    const {
+      cache: s = !0,
+      batch: r = !1,
+      throttle: a = !1,
+      priority: c = "medium"
+    } = i;
+    if (s) {
+      const h = this.getCachedResult(e);
+      if (h !== void 0)
+        return this.updateMetrics(e, 0, !0, !1), h;
+    }
+    if (this.shouldSkipFrame())
+      return this.updateMetrics(e, 0, !1, !0), this.getFallbackResult();
+    if (a && this.isThrottled(e))
+      return this.getFallbackResult();
+    const f = performance.now();
+    try {
+      let h;
+      if (r && c !== "high")
+        return this.addToBatch(e, t, s);
+      h = t();
+      const u = performance.now() - f;
+      return s && this.cacheResult(e, h), this.updateMetrics(e, u, !1, !1), this.checkPerformanceImpact(u), h;
+    } catch (h) {
+      const l = performance.now();
+      throw this.updateMetrics(e, l - f, !1, !1), h;
+    }
+  }
+  /**
+   * Smart caching with TTL and popularity-based eviction
+   */
+  getCachedResult(e) {
+    const t = this.resultCache.get(e);
+    if (!t) return;
+    const i = this.getCacheTTL();
+    if (Date.now() - t.timestamp > i) {
+      this.resultCache.delete(e);
+      return;
+    }
+    return t.hits++, t.result;
+  }
+  /**
+   * Cache result with intelligent eviction
+   */
+  cacheResult(e, t) {
+    const i = this.getMaxCacheSize();
+    this.resultCache.size >= i && this.evictLeastPopular(), this.resultCache.set(e, {
+      result: t,
+      timestamp: Date.now(),
+      hits: 1
+    });
+  }
+  /**
+   * Evict least popular cache entries
+   */
+  evictLeastPopular() {
+    const e = Array.from(this.resultCache.entries());
+    e.sort((i, s) => i[1].hits !== s[1].hits ? i[1].hits - s[1].hits : i[1].timestamp - s[1].timestamp);
+    const t = Math.floor(e.length * 0.25);
+    for (let i = 0; i < t; i++)
+      this.resultCache.delete(e[i][0]);
+  }
+  /**
+   * Get cache TTL based on strategy
+   */
+  getCacheTTL() {
+    switch (this.config.cacheStrategy) {
+      case "aggressive":
+        return 3e5;
+      // 5 minutes
+      case "moderate":
+        return 6e4;
+      // 1 minute
+      case "conservative":
+        return 1e4;
+      // 10 seconds
+      default:
+        return 6e4;
+    }
+  }
+  /**
+   * Get max cache size based on strategy
+   */
+  getMaxCacheSize() {
+    switch (this.config.cacheStrategy) {
+      case "aggressive":
+        return 1e3;
+      case "moderate":
+        return 500;
+      case "conservative":
+        return 100;
+      default:
+        return 500;
+    }
+  }
+  /**
+   * Check if operation should skip this frame
+   */
+  shouldSkipFrame() {
+    return this.config.skipFrames === 0 ? !1 : (this.frameCounter++, this.frameCounter % (this.config.skipFrames + 1) !== 0);
+  }
+  /**
+   * Check if operation is throttled
+   */
+  isThrottled(e) {
+    const t = this.throttleTimers.get(e) || 0, i = Date.now();
+    return i - t < this.config.throttleMs ? !0 : (this.throttleTimers.set(e, i), !1);
+  }
+  /**
+   * Add operation to batch queue
+   */
+  addToBatch(e, t, i) {
+    return new Promise((s, r) => {
+      this.operationQueue.push(() => {
+        try {
+          const a = t();
+          i && this.cacheResult(e, a), s(a);
+        } catch (a) {
+          r(a);
+        }
+      }), this.processBatchIfReady();
+    });
+  }
+  /**
+   * Process batch queue if conditions are met
+   */
+  processBatchIfReady() {
+    const e = Date.now();
+    (this.operationQueue.length >= this.config.batchSize || this.operationQueue.length > 0 && e - this.lastBatchTime > this.config.throttleMs) && this.processBatch();
+  }
+  /**
+   * Process batch queue
+   */
+  processBatch() {
+    if (this.operationQueue.length === 0) return;
+    const e = this.operationQueue.splice(0, this.config.batchSize);
+    this.lastBatchTime = Date.now(), this.config.asyncValidation ? setTimeout(() => {
+      e.forEach((t) => t());
+    }, 0) : e.forEach((t) => t());
+  }
+  /**
+   * Update operation metrics
+   */
+  updateMetrics(e, t, i, s) {
+    let r = this.metrics.get(e);
+    r || (r = {
+      operationCount: 0,
+      totalTime: 0,
+      averageTime: 0,
+      maxTime: 0,
+      cacheHitRate: 0,
+      skipRate: 0
+    }, this.metrics.set(e, r)), r.operationCount++, !i && !s && (r.totalTime += t, r.averageTime = r.totalTime / r.operationCount, r.maxTime = Math.max(r.maxTime, t));
+    const a = r.operationCount, c = Math.floor(r.cacheHitRate * a) + (i ? 1 : 0), f = Math.floor(r.skipRate * a) + (s ? 1 : 0);
+    r.cacheHitRate = c / a, r.skipRate = f / a;
+  }
+  /**
+   * Check if performance impact exceeds target
+   */
+  checkPerformanceImpact(e) {
+    const t = this.frameTimeTarget, i = e / t * 100;
+    i > this.config.targetOverhead && (this.autoOptimize(i), T.logEvent(
+      "performance-warning",
+      `Validation overhead: ${i.toFixed(1)}% (target: ${this.config.targetOverhead}%)`,
+      { duration: e, target: this.config.targetOverhead, actual: i }
+    ));
+  }
+  /**
+   * Automatically adjust optimization settings
+   */
+  autoOptimize(e) {
+    const t = e / this.config.targetOverhead;
+    t > 2 ? (this.config.cacheStrategy = "aggressive", this.config.skipFrames = Math.max(1, this.config.skipFrames), this.config.throttleMs = Math.max(this.config.throttleMs, 32), this.config.batchSize = Math.min(this.config.batchSize, 5)) : t > 1.5 && (this.config.cacheStrategy = "aggressive", this.config.throttleMs = Math.max(this.config.throttleMs, 16));
+  }
+  /**
+   * Get fallback result for skipped/throttled operations
+   */
+  getFallbackResult() {
+    return !0;
+  }
+  /**
+   * Initialize performance monitoring
+   */
+  initializePerformanceMonitoring() {
+    if (typeof PerformanceObserver < "u")
+      try {
+        this.performanceObserver = new PerformanceObserver((e) => {
+          e.getEntries().forEach((i) => {
+            i.name.includes("tachui-validation") && this.analyzePerformanceEntry(i);
+          });
+        }), this.performanceObserver.observe({ entryTypes: ["measure", "navigation", "paint"] });
+      } catch {
+      }
+  }
+  /**
+   * Analyze performance entry
+   */
+  analyzePerformanceEntry(e) {
+    e.duration > this.frameTimeTarget && console.warn(`⚠️ Slow validation operation: ${e.name} took ${e.duration.toFixed(2)}ms`);
+  }
+  /**
+   * Get performance statistics
+   */
+  getPerformanceStats() {
+    const e = Array.from(this.metrics.values()).reduce((a, c) => a + c.operationCount, 0), t = Array.from(this.metrics.values()).reduce((a, c) => a + c.totalTime, 0), i = e > 0 ? t / e : 0, s = Array.from(this.metrics.values()).reduce((a, c) => a + c.cacheHitRate, 0) / this.metrics.size || 0, r = Array.from(this.metrics.values()).reduce((a, c) => a + c.skipRate, 0) / this.metrics.size || 0;
+    return {
+      config: this.config,
+      totalOperations: e,
+      totalTime: t,
+      averageTime: i,
+      cacheHitRate: s,
+      skipRate: r,
+      cacheSize: this.resultCache.size,
+      queueSize: this.operationQueue.length,
+      frameImpact: i / this.frameTimeTarget * 100,
+      targetMet: i / this.frameTimeTarget * 100 <= this.config.targetOverhead,
+      operations: Object.fromEntries(this.metrics)
+    };
+  }
+  /**
+   * Clear all caches and reset metrics
+   */
+  reset() {
+    this.resultCache.clear(), this.metrics.clear(), this.operationQueue = [], this.throttleTimers.clear(), this.frameCounter = 0, this.lastBatchTime = 0;
+  }
+  /**
+   * Configure optimizer
+   */
+  configure(e) {
+    this.config = { ...this.config, ...e };
+  }
+  /**
+   * Force process all batched operations
+   */
+  flush() {
+    for (; this.operationQueue.length > 0; )
+      this.processBatch();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    const e = Array.from(this.resultCache.values()), t = e.reduce((s, r) => s + r.hits, 0), i = e.length > 0 ? e.reduce((s, r) => s + (Date.now() - r.timestamp), 0) / e.length : 0;
+    return {
+      size: this.resultCache.size,
+      maxSize: this.getMaxCacheSize(),
+      totalHits: t,
+      averageAge: i,
+      strategy: this.config.cacheStrategy,
+      ttl: this.getCacheTTL()
+    };
+  }
+};
+n(g, "instance");
+let C = g;
+const m = C.getInstance(), P = {
+  /**
+   * Configure performance optimizer
+   */
+  configure: (o) => m.configure(o),
+  /**
+   * Get performance statistics
+   */
+  getStats: () => m.getPerformanceStats(),
+  /**
+   * Get cache statistics
+   */
+  getCacheStats: () => m.getCacheStats(),
+  /**
+   * Reset optimizer
+   */
+  reset: () => m.reset(),
+  /**
+   * Flush batched operations
+   */
+  flush: () => m.flush(),
+  /**
+   * Optimize validation function
+   */
+  optimize: (o, e, t) => m.optimizeValidation(o, e, t),
+  /**
+   * Test performance optimization
+   */
+  test: () => {
+    console.group("⚡ Performance Optimization Test");
+    try {
+      const o = performance.now(), e = [];
+      for (let r = 0; r < 100; r++) {
+        const a = m.optimizeValidation(
+          "test-cache",
+          () => Math.random(),
+          { cache: !0 }
+        );
+        e.push(a);
+      }
+      const i = performance.now() - o, s = m.getPerformanceStats();
+      console.info("✅ Optimization system active:", s.config.enabled), console.info("✅ Test duration:", `${i.toFixed(2)}ms`), console.info("✅ Cache hit rate:", `${(s.cacheHitRate * 100).toFixed(1)}%`), console.info("✅ Frame impact:", `${s.frameImpact.toFixed(1)}% (target: ${s.config.targetOverhead}%)`), console.info("✅ Target met:", s.targetMet), console.info("✅ Performance optimization is working correctly");
+    } catch (o) {
+      console.error("❌ Performance optimization test failed:", o);
+    }
+    console.groupEnd();
+  }
+};
+export {
+  P as PerformanceOptimizationUtils,
+  C as PerformanceOptimizer,
+  m as performanceOptimizer
+};
+//# sourceMappingURL=performance-optimizer.js.map