@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/reality/chaos-engineering.js

@@ -1,1084 +0,0 @@
-/**
- * Chaos Engineering Mode
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - Resilience Testing Through Controlled Failure
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine injects controlled failures during Reality Mode to test how the
- * application handles adverse conditions. No other tool does this at runtime.
- * 
- * Chaos Types:
- * - Network failures (timeout, disconnect, slow connection)
- * - API errors (500s, 503s, rate limiting)
- * - Latency injection (slow responses)
- * - Payload corruption (malformed JSON, truncated responses)
- * - Resource exhaustion (memory pressure simulation)
- * - Third-party failures (CDN, auth provider, payment gateway)
- * - Clock skew (time manipulation)
- * 
- * This catches:
- * - Missing error boundaries
- * - Poor offline handling
- * - Race conditions under load
- * - Retry storm vulnerabilities
- * - Timeout handling issues
- * - Graceful degradation failures
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CHAOS SCENARIOS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const CHAOS_SCENARIOS = {
-  // ─────────────────────────────────────────────────────────────────────────────
-  // NETWORK CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  network: {
-    disconnect: {
-      name: "Network Disconnect",
-      description: "Simulate complete network failure",
-      severity: "high",
-      duration: 5000,
-      apply: async (context) => {
-        await context.setOffline(true);
-        return { type: "disconnect", started: Date.now() };
-      },
-      cleanup: async (context) => {
-        await context.setOffline(false);
-      }
-    },
-    
-    slowConnection: {
-      name: "Slow 3G Connection",
-      description: "Simulate slow mobile network",
-      severity: "medium",
-      config: {
-        downloadThroughput: 50 * 1024,  // 50KB/s
-        uploadThroughput: 20 * 1024,    // 20KB/s
-        latency: 2000                   // 2s latency
-      },
-      apply: async (context, page) => {
-        const cdp = await page.context().newCDPSession(page);
-        await cdp.send("Network.emulateNetworkConditions", {
-          offline: false,
-          downloadThroughput: 50 * 1024,
-          uploadThroughput: 20 * 1024,
-          latency: 2000
-        });
-        return { type: "slowConnection", cdp };
-      },
-      cleanup: async (context, state) => {
-        if (state.cdp) {
-          await state.cdp.send("Network.emulateNetworkConditions", {
-            offline: false,
-            downloadThroughput: -1,
-            uploadThroughput: -1,
-            latency: 0
-          });
-        }
-      }
-    },
-
-    intermittent: {
-      name: "Intermittent Connectivity",
-      description: "Connection drops randomly",
-      severity: "high",
-      config: {
-        dropChance: 0.3,      // 30% chance to drop
-        dropDuration: 2000    // 2s drops
-      },
-      apply: async (context, page, config) => {
-        const interval = setInterval(async () => {
-          if (Math.random() < config.dropChance) {
-            await context.setOffline(true);
-            setTimeout(() => context.setOffline(false), config.dropDuration);
-          }
-        }, 1000);
-        return { type: "intermittent", interval };
-      },
-      cleanup: async (context, state) => {
-        clearInterval(state.interval);
-        await context.setOffline(false);
-      }
-    },
-
-    dnsFailure: {
-      name: "DNS Resolution Failure",
-      description: "Simulate DNS lookup failures",
-      severity: "high",
-      apply: async (context, page) => {
-        await page.route("**/*", async (route) => {
-          const url = route.request().url();
-          // Fail external domains
-          if (!url.includes("localhost") && !url.includes("127.0.0.1")) {
-            await route.abort("namenotresolved");
-          } else {
-            await route.continue();
-          }
-        });
-        return { type: "dnsFailure" };
-      },
-      cleanup: async (context, page) => {
-        await page.unroute("**/*");
-      }
-    }
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // API CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  api: {
-    serverError: {
-      name: "API Server Errors",
-      description: "All API calls return 500",
-      severity: "high",
-      config: {
-        pattern: "**/api/**",
-        status: 500,
-        body: { error: "Internal Server Error", message: "Chaos injection" }
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: config.status,
-            contentType: "application/json",
-            body: JSON.stringify(config.body)
-          });
-        });
-        return { type: "serverError", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    serviceUnavailable: {
-      name: "Service Unavailable",
-      description: "API returns 503 with retry-after",
-      severity: "high",
-      config: {
-        pattern: "**/api/**",
-        retryAfter: 30
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: 503,
-            headers: { "Retry-After": String(config.retryAfter) },
-            contentType: "application/json",
-            body: JSON.stringify({ error: "Service Unavailable" })
-          });
-        });
-        return { type: "serviceUnavailable", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    rateLimited: {
-      name: "Rate Limited",
-      description: "API returns 429 Too Many Requests",
-      severity: "medium",
-      config: {
-        pattern: "**/api/**",
-        retryAfter: 60
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: 429,
-            headers: { 
-              "Retry-After": String(config.retryAfter),
-              "X-RateLimit-Remaining": "0",
-              "X-RateLimit-Reset": String(Date.now() + config.retryAfter * 1000)
-            },
-            contentType: "application/json",
-            body: JSON.stringify({ error: "Too Many Requests" })
-          });
-        });
-        return { type: "rateLimited", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    randomErrors: {
-      name: "Random API Errors",
-      description: "30% of API calls fail randomly",
-      severity: "high",
-      config: {
-        pattern: "**/api/**",
-        failureRate: 0.3,
-        errorCodes: [500, 502, 503, 504]
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          if (Math.random() < config.failureRate) {
-            const status = config.errorCodes[
-              Math.floor(Math.random() * config.errorCodes.length)
-            ];
-            await route.fulfill({
-              status,
-              contentType: "application/json",
-              body: JSON.stringify({ error: `Chaos error ${status}` })
-            });
-          } else {
-            await route.continue();
-          }
-        });
-        return { type: "randomErrors", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    timeout: {
-      name: "API Timeout",
-      description: "API calls hang indefinitely",
-      severity: "high",
-      config: {
-        pattern: "**/api/**",
-        delay: 30000  // 30 seconds
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await new Promise(resolve => setTimeout(resolve, config.delay));
-          await route.abort("timedout");
-        });
-        return { type: "timeout", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    }
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // LATENCY CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  latency: {
-    highLatency: {
-      name: "High Latency",
-      description: "Add 3-5 second delay to all requests",
-      severity: "medium",
-      config: {
-        pattern: "**/*",
-        minDelay: 3000,
-        maxDelay: 5000
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          const delay = config.minDelay + 
-            Math.random() * (config.maxDelay - config.minDelay);
-          await new Promise(resolve => setTimeout(resolve, delay));
-          await route.continue();
-        });
-        return { type: "highLatency", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    spikyLatency: {
-      name: "Spiky Latency",
-      description: "Occasional latency spikes",
-      severity: "medium",
-      config: {
-        pattern: "**/*",
-        spikeChance: 0.2,
-        normalDelay: 100,
-        spikeDelay: 5000
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          const delay = Math.random() < config.spikeChance 
-            ? config.spikeDelay 
-            : config.normalDelay;
-          await new Promise(resolve => setTimeout(resolve, delay));
-          await route.continue();
-        });
-        return { type: "spikyLatency", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    }
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // PAYLOAD CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  payload: {
-    malformedJson: {
-      name: "Malformed JSON",
-      description: "Return invalid JSON responses",
-      severity: "high",
-      config: {
-        pattern: "**/api/**"
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: 200,
-            contentType: "application/json",
-            body: '{"broken": true, "missing_quote: "value"}'  // Invalid JSON
-          });
-        });
-        return { type: "malformedJson", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    truncatedResponse: {
-      name: "Truncated Response",
-      description: "Cut responses in half",
-      severity: "high",
-      config: {
-        pattern: "**/api/**",
-        truncatePercent: 0.5
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          const response = await route.fetch();
-          const body = await response.text();
-          const truncated = body.substring(
-            0, 
-            Math.floor(body.length * config.truncatePercent)
-          );
-          await route.fulfill({
-            status: response.status(),
-            headers: response.headers(),
-            body: truncated
-          });
-        });
-        return { type: "truncatedResponse", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    emptyResponse: {
-      name: "Empty Response",
-      description: "Return empty bodies",
-      severity: "medium",
-      config: {
-        pattern: "**/api/**"
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: 200,
-            contentType: "application/json",
-            body: ""
-          });
-        });
-        return { type: "emptyResponse", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    },
-
-    wrongContentType: {
-      name: "Wrong Content-Type",
-      description: "Return HTML instead of JSON",
-      severity: "medium",
-      config: {
-        pattern: "**/api/**"
-      },
-      apply: async (context, page, config) => {
-        await page.route(config.pattern, async (route) => {
-          await route.fulfill({
-            status: 200,
-            contentType: "text/html",
-            body: "<html><body>Unexpected HTML</body></html>"
-          });
-        });
-        return { type: "wrongContentType", pattern: config.pattern };
-      },
-      cleanup: async (context, page, state) => {
-        await page.unroute(state.pattern);
-      }
-    }
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // THIRD-PARTY CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  thirdParty: {
-    cdnFailure: {
-      name: "CDN Failure",
-      description: "CDN/static assets unavailable",
-      severity: "high",
-      config: {
-        patterns: [
-          "**/*.cloudflare.com/**",
-          "**/*.cloudfront.net/**",
-          "**/*.akamaized.net/**",
-          "**/cdn.**/**",
-          "**/static.**/**"
-        ]
-      },
-      apply: async (context, page, config) => {
-        for (const pattern of config.patterns) {
-          await page.route(pattern, route => route.abort("failed"));
-        }
-        return { type: "cdnFailure", patterns: config.patterns };
-      },
-      cleanup: async (context, page, state) => {
-        for (const pattern of state.patterns) {
-          await page.unroute(pattern);
-        }
-      }
-    },
-
-    authProviderDown: {
-      name: "Auth Provider Down",
-      description: "OAuth/Auth0/Firebase auth fails",
-      severity: "critical",
-      config: {
-        patterns: [
-          "**/*.auth0.com/**",
-          "**/accounts.google.com/**",
-          "**/login.microsoftonline.com/**",
-          "**/*.firebaseauth.com/**",
-          "**/clerk.**/**"
-        ]
-      },
-      apply: async (context, page, config) => {
-        for (const pattern of config.patterns) {
-          await page.route(pattern, async (route) => {
-            await route.fulfill({
-              status: 503,
-              body: "Auth service unavailable"
-            });
-          });
-        }
-        return { type: "authProviderDown", patterns: config.patterns };
-      },
-      cleanup: async (context, page, state) => {
-        for (const pattern of state.patterns) {
-          await page.unroute(pattern);
-        }
-      }
-    },
-
-    paymentGatewayDown: {
-      name: "Payment Gateway Down",
-      description: "Stripe/PayPal unavailable",
-      severity: "critical",
-      config: {
-        patterns: [
-          "**/api.stripe.com/**",
-          "**/js.stripe.com/**",
-          "**/api.paypal.com/**",
-          "**/checkout.stripe.com/**"
-        ]
-      },
-      apply: async (context, page, config) => {
-        for (const pattern of config.patterns) {
-          await page.route(pattern, async (route) => {
-            await route.fulfill({
-              status: 503,
-              contentType: "application/json",
-              body: JSON.stringify({ 
-                error: { message: "Payment service unavailable" }
-              })
-            });
-          });
-        }
-        return { type: "paymentGatewayDown", patterns: config.patterns };
-      },
-      cleanup: async (context, page, state) => {
-        for (const pattern of state.patterns) {
-          await page.unroute(pattern);
-        }
-      }
-    },
-
-    analyticsBlocked: {
-      name: "Analytics Blocked",
-      description: "Simulate ad blocker blocking analytics",
-      severity: "low",
-      config: {
-        patterns: [
-          "**/google-analytics.com/**",
-          "**/googletagmanager.com/**",
-          "**/segment.io/**",
-          "**/mixpanel.com/**",
-          "**/amplitude.com/**",
-          "**/hotjar.com/**"
-        ]
-      },
-      apply: async (context, page, config) => {
-        for (const pattern of config.patterns) {
-          await page.route(pattern, route => route.abort("blockedbyclient"));
-        }
-        return { type: "analyticsBlocked", patterns: config.patterns };
-      },
-      cleanup: async (context, page, state) => {
-        for (const pattern of state.patterns) {
-          await page.unroute(pattern);
-        }
-      }
-    }
-  },
-
-  // ─────────────────────────────────────────────────────────────────────────────
-  // RESOURCE CHAOS
-  // ─────────────────────────────────────────────────────────────────────────────
-  resource: {
-    memoryPressure: {
-      name: "Memory Pressure",
-      description: "Simulate low memory conditions",
-      severity: "high",
-      apply: async (context, page) => {
-        // Inject script to consume memory
-        await page.evaluate(() => {
-          window.__chaosMemory = [];
-          for (let i = 0; i < 100; i++) {
-            window.__chaosMemory.push(new Array(1000000).fill("x"));
-          }
-        });
-        return { type: "memoryPressure" };
-      },
-      cleanup: async (context, page) => {
-        await page.evaluate(() => {
-          if (window.__chaosMemory) {
-            window.__chaosMemory = null;
-          }
-        });
-      }
-    },
-
-    cpuThrottle: {
-      name: "CPU Throttling",
-      description: "Simulate slow CPU",
-      severity: "medium",
-      config: {
-        rate: 4  // 4x slowdown
-      },
-      apply: async (context, page, config) => {
-        const cdp = await page.context().newCDPSession(page);
-        await cdp.send("Emulation.setCPUThrottlingRate", { rate: config.rate });
-        return { type: "cpuThrottle", cdp };
-      },
-      cleanup: async (context, page, state) => {
-        if (state.cdp) {
-          await state.cdp.send("Emulation.setCPUThrottlingRate", { rate: 1 });
-        }
-      }
-    },
-
-    localStorage: {
-      name: "LocalStorage Full",
-      description: "Fill localStorage to quota",
-      severity: "medium",
-      apply: async (context, page) => {
-        await page.evaluate(() => {
-          try {
-            const data = "x".repeat(5 * 1024 * 1024); // 5MB
-            localStorage.setItem("__chaos_fill", data);
-          } catch {
-            // Expected - quota exceeded
-          }
-        });
-        return { type: "localStorage" };
-      },
-      cleanup: async (context, page) => {
-        await page.evaluate(() => {
-          localStorage.removeItem("__chaos_fill");
-        });
-      }
-    }
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CHAOS ENGINE CLASS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class ChaosEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.scenarios = { ...CHAOS_SCENARIOS };
-    this.activeScenarios = new Map();
-    this.results = [];
-    this.page = null;
-    this.context = null;
-  }
-
-  /**
-   * Set the Playwright page and context
-   */
-  setPage(page) {
-    this.page = page;
-    this.context = page.context();
-  }
-
-  /**
-   * Apply a chaos scenario
-   */
-  async applyScenario(category, scenarioName, customConfig = {}) {
-    if (!this.page) {
-      throw new Error("Page not set. Call setPage() first.");
-    }
-
-    const categoryScenarios = this.scenarios[category];
-    if (!categoryScenarios) {
-      throw new Error(`Unknown chaos category: ${category}`);
-    }
-
-    const scenario = categoryScenarios[scenarioName];
-    if (!scenario) {
-      throw new Error(`Unknown chaos scenario: ${category}.${scenarioName}`);
-    }
-
-    const config = { ...scenario.config, ...customConfig };
-    const id = `${category}.${scenarioName}`;
-
-    try {
-      const state = await scenario.apply(this.context, this.page, config);
-      
-      this.activeScenarios.set(id, {
-        scenario,
-        state,
-        config,
-        startTime: Date.now()
-      });
-
-      return {
-        success: true,
-        id,
-        name: scenario.name,
-        description: scenario.description
-      };
-    } catch (error) {
-      return {
-        success: false,
-        id,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Remove a chaos scenario
-   */
-  async removeScenario(id) {
-    const active = this.activeScenarios.get(id);
-    if (!active) {
-      return { success: false, error: "Scenario not active" };
-    }
-
-    try {
-      await active.scenario.cleanup(this.context, this.page, active.state);
-      this.activeScenarios.delete(id);
-      
-      return {
-        success: true,
-        id,
-        duration: Date.now() - active.startTime
-      };
-    } catch (error) {
-      return {
-        success: false,
-        id,
-        error: error.message
-      };
-    }
-  }
-
-  /**
-   * Remove all active scenarios
-   */
-  async cleanup() {
-    const results = [];
-    
-    for (const id of this.activeScenarios.keys()) {
-      const result = await this.removeScenario(id);
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  /**
-   * Run chaos test suite
-   */
-  async runChaosSuite(page, url, options = {}) {
-    this.setPage(page);
-    this.results = [];
-
-    const {
-      categories = Object.keys(this.scenarios),
-      duration = 5000,
-      captureScreenshots = true
-    } = options;
-
-    // Navigate to URL first
-    await page.goto(url, { waitUntil: "networkidle" });
-    const baselineScreenshot = captureScreenshots 
-      ? await page.screenshot() 
-      : null;
-
-    // Run each chaos scenario
-    for (const category of categories) {
-      const categoryScenarios = this.scenarios[category];
-      
-      for (const [name, scenario] of Object.entries(categoryScenarios)) {
-        const result = await this.runSingleChaosTest(
-          category, 
-          name, 
-          scenario,
-          url,
-          duration,
-          captureScreenshots
-        );
-        this.results.push(result);
-      }
-    }
-
-    return {
-      url,
-      totalTests: this.results.length,
-      passed: this.results.filter(r => r.passed).length,
-      failed: this.results.filter(r => !r.passed).length,
-      results: this.results,
-      baselineScreenshot
-    };
-  }
-
-  /**
-   * Run a single chaos test
-   */
-  async runSingleChaosTest(category, name, scenario, url, duration, captureScreenshots) {
-    const id = `${category}.${name}`;
-    const result = {
-      id,
-      name: scenario.name,
-      description: scenario.description,
-      severity: scenario.severity,
-      category,
-      passed: true,
-      errors: [],
-      warnings: [],
-      duration: 0
-    };
-
-    const startTime = Date.now();
-
-    try {
-      // Apply chaos
-      await this.applyScenario(category, name);
-
-      // Wait and collect errors
-      const consoleErrors = [];
-      const networkErrors = [];
-
-      this.page.on("console", msg => {
-        if (msg.type() === "error") {
-          consoleErrors.push(msg.text());
-        }
-      });
-
-      this.page.on("pageerror", err => {
-        consoleErrors.push(err.message);
-      });
-
-      this.page.on("requestfailed", req => {
-        networkErrors.push({
-          url: req.url(),
-          failure: req.failure()?.errorText
-        });
-      });
-
-      // Reload page under chaos
-      try {
-        await this.page.reload({ timeout: duration * 2 });
-      } catch (reloadError) {
-        result.warnings.push(`Page reload failed: ${reloadError.message}`);
-      }
-
-      // Wait for chaos duration
-      await this.page.waitForTimeout(duration);
-
-      // Take screenshot under chaos
-      if (captureScreenshots) {
-        try {
-          result.chaosScreenshot = await this.page.screenshot();
-        } catch {
-          result.warnings.push("Failed to capture chaos screenshot");
-        }
-      }
-
-      // Check for JS crashes
-      const hasJSCrash = await this.page.evaluate(() => {
-        return document.body.innerHTML.includes("error") ||
-               document.body.innerHTML.includes("crash") ||
-               document.querySelector("[class*='error']") !== null;
-      });
-
-      // Evaluate resilience
-      if (consoleErrors.length > 0) {
-        result.warnings.push(`${consoleErrors.length} console errors during chaos`);
-        result.consoleErrors = consoleErrors.slice(0, 5);
-      }
-
-      if (hasJSCrash) {
-        result.errors.push("Possible JS crash detected");
-        result.passed = false;
-      }
-
-      // Check for error boundary or graceful degradation
-      const hasErrorBoundary = await this.page.evaluate(() => {
-        return document.querySelector("[data-error-boundary]") !== null ||
-               document.querySelector("[class*='fallback']") !== null ||
-               document.body.innerText.toLowerCase().includes("something went wrong");
-      });
-
-      if (!hasErrorBoundary && consoleErrors.length > 3) {
-        result.warnings.push("No error boundary detected despite errors");
-      }
-
-      // Check for loading states
-      const hasLoadingState = await this.page.evaluate(() => {
-        return document.querySelector("[class*='loading']") !== null ||
-               document.querySelector("[class*='skeleton']") !== null ||
-               document.querySelector("[aria-busy='true']") !== null;
-      });
-
-      if (hasLoadingState) {
-        result.warnings.push("App stuck in loading state");
-      }
-
-      // Remove chaos
-      await this.removeScenario(id);
-
-      // Verify recovery
-      try {
-        await this.page.reload({ timeout: 10000 });
-        const recovered = await this.page.evaluate(() => {
-          return !document.body.innerHTML.includes("error") &&
-                 document.body.innerHTML.length > 100;
-        });
-        
-        if (!recovered) {
-          result.errors.push("App did not recover after chaos removed");
-          result.passed = false;
-        }
-      } catch {
-        result.errors.push("Page failed to reload after chaos");
-        result.passed = false;
-      }
-
-    } catch (error) {
-      result.errors.push(error.message);
-      result.passed = false;
-    }
-
-    result.duration = Date.now() - startTime;
-    
-    // Final pass/fail based on severity
-    if (result.errors.length > 0) {
-      result.passed = false;
-    } else if (result.warnings.length > 5 && scenario.severity === "high") {
-      result.passed = false;
-    }
-
-    return result;
-  }
-
-  /**
-   * Get available scenarios
-   */
-  getAvailableScenarios() {
-    const available = [];
-    
-    for (const [category, scenarios] of Object.entries(this.scenarios)) {
-      for (const [name, scenario] of Object.entries(scenarios)) {
-        available.push({
-          id: `${category}.${name}`,
-          category,
-          name: scenario.name,
-          description: scenario.description,
-          severity: scenario.severity
-        });
-      }
-    }
-    
-    return available;
-  }
-
-  /**
-   * Get active scenarios
-   */
-  getActiveScenarios() {
-    const active = [];
-    
-    for (const [id, data] of this.activeScenarios) {
-      active.push({
-        id,
-        name: data.scenario.name,
-        startTime: data.startTime,
-        duration: Date.now() - data.startTime
-      });
-    }
-    
-    return active;
-  }
-
-  /**
-   * Generate chaos test report
-   */
-  generateReport() {
-    const passed = this.results.filter(r => r.passed);
-    const failed = this.results.filter(r => !r.passed);
-    
-    const bySeverity = {
-      critical: this.results.filter(r => r.severity === "critical"),
-      high: this.results.filter(r => r.severity === "high"),
-      medium: this.results.filter(r => r.severity === "medium"),
-      low: this.results.filter(r => r.severity === "low")
-    };
-
-    const byCategory = {};
-    for (const result of this.results) {
-      if (!byCategory[result.category]) {
-        byCategory[result.category] = { passed: 0, failed: 0 };
-      }
-      byCategory[result.category][result.passed ? "passed" : "failed"]++;
-    }
-
-    return {
-      timestamp: new Date().toISOString(),
-      summary: {
-        total: this.results.length,
-        passed: passed.length,
-        failed: failed.length,
-        passRate: this.results.length > 0 
-          ? ((passed.length / this.results.length) * 100).toFixed(1) + "%"
-          : "N/A"
-      },
-      bySeverity: {
-        critical: {
-          total: bySeverity.critical.length,
-          failed: bySeverity.critical.filter(r => !r.passed).length
-        },
-        high: {
-          total: bySeverity.high.length,
-          failed: bySeverity.high.filter(r => !r.passed).length
-        },
-        medium: {
-          total: bySeverity.medium.length,
-          failed: bySeverity.medium.filter(r => !r.passed).length
-        },
-        low: {
-          total: bySeverity.low.length,
-          failed: bySeverity.low.filter(r => !r.passed).length
-        }
-      },
-      byCategory,
-      failures: failed.map(r => ({
-        id: r.id,
-        name: r.name,
-        severity: r.severity,
-        errors: r.errors,
-        warnings: r.warnings
-      })),
-      recommendations: this.generateRecommendations(failed)
-    };
-  }
-
-  /**
-   * Generate recommendations from failures
-   */
-  generateRecommendations(failures) {
-    const recommendations = [];
-
-    const hasNetworkFailures = failures.some(f => f.category === "network");
-    const hasApiFailures = failures.some(f => f.category === "api");
-    const hasPayloadFailures = failures.some(f => f.category === "payload");
-    const hasThirdPartyFailures = failures.some(f => f.category === "thirdParty");
-
-    if (hasNetworkFailures) {
-      recommendations.push({
-        category: "network",
-        priority: "high",
-        message: "Improve offline handling",
-        suggestions: [
-          "Implement service workers for offline support",
-          "Add network status indicators",
-          "Queue failed requests for retry",
-          "Cache critical data locally"
-        ]
-      });
-    }
-
-    if (hasApiFailures) {
-      recommendations.push({
-        category: "api",
-        priority: "high",
-        message: "Improve API error handling",
-        suggestions: [
-          "Add error boundaries around API-dependent components",
-          "Implement exponential backoff for retries",
-          "Show user-friendly error messages",
-          "Add circuit breakers for failing endpoints"
-        ]
-      });
-    }
-
-    if (hasPayloadFailures) {
-      recommendations.push({
-        category: "payload",
-        priority: "high",
-        message: "Improve response validation",
-        suggestions: [
-          "Validate API responses with schema libraries",
-          "Handle malformed JSON gracefully",
-          "Add fallback defaults for missing fields",
-          "Log parsing errors for debugging"
-        ]
-      });
-    }
-
-    if (hasThirdPartyFailures) {
-      recommendations.push({
-        category: "thirdParty",
-        priority: "medium",
-        message: "Improve third-party resilience",
-        suggestions: [
-          "Implement fallbacks for critical third-party services",
-          "Use async loading for non-critical services",
-          "Add health checks for dependencies",
-          "Consider self-hosted alternatives for critical paths"
-        ]
-      });
-    }
-
-    return recommendations;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  ChaosEngine,
-  CHAOS_SCENARIOS
-};