@m00nsolutions/playwright-reporter 1.0.0

package/index.mjs

@@ -0,0 +1,2386 @@
+// M00n Reporter v2 - Simplified Playwright reporter for M00n Report dashboard
+//
+// Key improvements over v1:
+// 1. Hybrid model - real-time step streaming + atomic final persistence
+// 2. Lightweight step events for UI (fire-and-forget)
+// 3. Complete test data at end (reliable, with retry)
+// 4. Simple sequential step indexing (no complex matching)
+// 5. Exponential backoff retries for reliability
+// 6. Binary multipart uploads for attachments (no base64 overhead!)
+// 7. Project API key - the API key identifies the project (no need for projectId)
+//
+// Usage in playwright.config.js:
+//   reporter: [
+//     ['./m00nreporter.mjs', {
+//       serverUrl: 'http://localhost:4001',  // Required: ingest service URL
+//       apiKey: 'm00n_xxxxxxxxxxxx...',      // Required: project API key (identifies both org and project)
+//       launch: 'My test run',               // Optional: run title
+//       tags: ['smoke', 'regression'],       // Optional: tags array
+//       attributes: {                        // Optional: custom key-value metadata
+//         ciJobUrl: 'https://...',
+//         browserVersion: '120',
+//         platform: 'Linux',
+//       },
+//       realtime: true,                      // Optional: stream steps in real-time (default: true)
+//       binaryAttachments: true,             // Optional: use multipart uploads (default: true)
+//       debug: false,                        // Optional: debug logs
+//       verbose: false,                      // Optional: performance/timing logs for bottleneck analysis
+//       logFile: './m00n-perf.log',          // Optional: save performance metrics to file
+//     }]
+//   ]
+
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { fileURLToPath } from 'url';
+
+// ============================================================================
+// CONSTANTS
+// ============================================================================
+
+// Files larger than this threshold will be streamed directly to server
+// to avoid memory issues in reporter process
+const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10MB
+
+// Maximum concurrent attachment uploads across ALL tests
+// Prevents server/MinIO overload with high parallelism (30+ workers)
+const MAX_GLOBAL_UPLOAD_CONCURRENCY = 10;
+
+// Timeout for individual attachment uploads (ms)
+const UPLOAD_TIMEOUT = 60000; // 60 seconds
+
+// Timeout for streaming large file uploads (ms)
+const STREAM_UPLOAD_TIMEOUT = 300000; // 5 minutes
+
+// Timeout for waiting on pending uploads at run end (ms)
+const END_UPLOAD_WAIT_TIMEOUT = 180000; // 3 minutes
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+/**
+ * Strip ANSI escape codes from a string.
+ * Terminal color codes appear as garbage characters in browser UI.
+ */
+function stripAnsi(str) {
+  if (!str || typeof str !== 'string') return str;
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '');
+}
+
+// ============================================================================
+// UPLOAD SEMAPHORE - Global concurrency control for attachment uploads
+// ============================================================================
+// Prevents server/MinIO overload when many tests complete simultaneously
+// With 36 concurrent tests × 4 attachments = 144 potential parallel uploads
+// This limits to MAX_GLOBAL_UPLOAD_CONCURRENCY at a time
+
+class UploadSemaphore {
+  constructor(maxConcurrent = MAX_GLOBAL_UPLOAD_CONCURRENCY) {
+    this.max = maxConcurrent;
+    this.running = 0;
+    this.queue = [];
+  }
+  
+  // Acquire a slot (waits if at capacity)
+  async acquire() {
+    if (this.running >= this.max) {
+      await new Promise(resolve => this.queue.push(resolve));
+    }
+    this.running++;
+  }
+  
+  // Release a slot
+  release() {
+    this.running--;
+    if (this.queue.length > 0) {
+      const next = this.queue.shift();
+      next();
+    }
+  }
+  
+  // Execute a function with acquired semaphore
+  async run(fn) {
+    await this.acquire();
+    try {
+      return await fn();
+    } finally {
+      this.release();
+    }
+  }
+  
+  // Get current stats for debugging
+  getStats() {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+      max: this.max,
+    };
+  }
+}
+
+// ============================================================================
+// FILE LOGGER - Write performance metrics to a log file
+// ============================================================================
+
+class FileLogger {
+  constructor(logFilePath, enabled = false) {
+    this.enabled = enabled;
+    this.logFilePath = logFilePath;
+    this.buffer = [];
+    this.flushTimer = null;
+    this.startTime = Date.now();
+    this.writeStream = null;
+    
+    if (this.enabled && this.logFilePath) {
+      try {
+        // Ensure directory exists
+        const dir = path.dirname(this.logFilePath);
+        if (dir && dir !== '.') {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        
+        // Open write stream in append mode
+        this.writeStream = fs.createWriteStream(this.logFilePath, { flags: 'a' });
+        
+        // Write session header
+        const header = `\n${'='.repeat(80)}\n` +
+          `M00nReporter Performance Log - ${new Date().toISOString()}\n` +
+          `${'='.repeat(80)}\n`;
+        this.writeStream.write(header);
+      } catch (err) {
+        console.warn(`[M00nReporter] Failed to open log file: ${err.message}`);
+        this.enabled = false;
+      }
+    }
+  }
+  
+  // Write a log line with timestamp
+  log(category, message, data = null) {
+    if (!this.enabled || !this.writeStream) return;
+    
+    const elapsed = ((Date.now() - this.startTime) / 1000).toFixed(3);
+    const timestamp = new Date().toISOString();
+    
+    let line = `[${timestamp}] [+${elapsed}s] [${category}] ${message}`;
+    if (data !== null) {
+      if (typeof data === 'object') {
+        line += ` ${JSON.stringify(data)}`;
+      } else {
+        line += ` ${data}`;
+      }
+    }
+    
+    this.buffer.push(line);
+    
+    // Flush periodically (every 500ms) to avoid too many writes
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), 500);
+    }
+  }
+  
+  // Flush buffer to file
+  flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    
+    if (!this.enabled || !this.writeStream || this.buffer.length === 0) return;
+    
+    const lines = this.buffer.join('\n') + '\n';
+    this.buffer = [];
+    
+    try {
+      this.writeStream.write(lines);
+    } catch (err) {
+      // Silently ignore write errors
+    }
+  }
+  
+  // Write a structured JSON event (for machine parsing)
+  event(eventType, data) {
+    if (!this.enabled || !this.writeStream) return;
+    
+    const event = {
+      ts: Date.now(),
+      elapsed: Date.now() - this.startTime,
+      type: eventType,
+      ...data,
+    };
+    
+    this.buffer.push(`[EVENT] ${JSON.stringify(event)}`);
+    
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => this.flush(), 500);
+    }
+  }
+  
+  // Write final report section
+  writeReport(title, content) {
+    if (!this.enabled || !this.writeStream) return;
+    
+    this.flush(); // Flush pending logs first
+    
+    const section = `\n${'─'.repeat(60)}\n${title}\n${'─'.repeat(60)}\n${content}\n`;
+    
+    try {
+      this.writeStream.write(section);
+    } catch (err) {
+      // Silently ignore write errors
+    }
+  }
+  
+  // Close the log file
+  close() {
+    this.flush();
+    
+    if (this.writeStream) {
+      try {
+        this.writeStream.write(`\n${'='.repeat(80)}\nSession ended: ${new Date().toISOString()}\n${'='.repeat(80)}\n\n`);
+        this.writeStream.end();
+      } catch (err) {
+        // Silently ignore close errors
+      }
+      this.writeStream = null;
+    }
+  }
+}
+
+// ============================================================================
+// PERFORMANCE TRACKER - Timing and metrics for bottleneck analysis
+// ============================================================================
+
+class PerformanceTracker {
+  constructor(enabled = false) {
+    this.enabled = enabled;
+    this.startTime = Date.now();
+    
+    // Timing buckets for different operations
+    this.timings = {
+      httpPost: [],           // HTTP POST request latencies
+      httpMultipart: [],      // Multipart upload latencies
+      httpStream: [],         // Streaming upload latencies
+      attachmentRead: [],     // File read latencies
+      testComplete: [],       // Full test completion cycle
+      runStart: null,         // Run start latency
+      runEnd: null,           // Run end latency
+    };
+    
+    // Concurrency tracking
+    this.concurrency = {
+      peakActiveTests: 0,
+      peakPendingRequests: 0,
+      peakQueuedSteps: 0,
+      currentActiveTests: 0,
+      currentPendingRequests: 0,
+    };
+    
+    // Throughput metrics
+    this.throughput = {
+      totalBytesUploaded: 0,
+      totalRequests: 0,
+      totalRetries: 0,
+      batchesFlushed: 0,
+      stepsPerBatch: [],
+    };
+    
+    // Memory snapshots
+    this.memorySnapshots = [];
+  }
+  
+  // Start timing an operation, returns a function to call when done
+  time(category) {
+    if (!this.enabled) return () => {};
+    const start = performance.now();
+    this.concurrency.currentPendingRequests++;
+    this.concurrency.peakPendingRequests = Math.max(
+      this.concurrency.peakPendingRequests,
+      this.concurrency.currentPendingRequests
+    );
+    
+    return (bytesTransferred = 0) => {
+      const duration = performance.now() - start;
+      this.concurrency.currentPendingRequests--;
+      
+      if (this.timings[category]) {
+        this.timings[category].push(duration);
+      }
+      
+      if (bytesTransferred > 0) {
+        this.throughput.totalBytesUploaded += bytesTransferred;
+      }
+      this.throughput.totalRequests++;
+      
+      return duration;
+    };
+  }
+  
+  // Track a retry attempt
+  recordRetry() {
+    if (!this.enabled) return;
+    this.throughput.totalRetries++;
+  }
+  
+  // Track active test count
+  testStarted() {
+    if (!this.enabled) return;
+    this.concurrency.currentActiveTests++;
+    this.concurrency.peakActiveTests = Math.max(
+      this.concurrency.peakActiveTests,
+      this.concurrency.currentActiveTests
+    );
+  }
+  
+  testEnded() {
+    if (!this.enabled) return;
+    this.concurrency.currentActiveTests--;
+  }
+  
+  // Track step batching efficiency
+  recordBatchFlush(stepCount) {
+    if (!this.enabled) return;
+    this.throughput.batchesFlushed++;
+    this.throughput.stepsPerBatch.push(stepCount);
+  }
+  
+  // Update peak queue depth
+  updateQueueDepth(depth) {
+    if (!this.enabled) return;
+    this.concurrency.peakQueuedSteps = Math.max(
+      this.concurrency.peakQueuedSteps,
+      depth
+    );
+  }
+  
+  // Take a memory snapshot
+  snapshotMemory(label) {
+    if (!this.enabled) return;
+    const mem = process.memoryUsage();
+    this.memorySnapshots.push({
+      label,
+      timestamp: Date.now() - this.startTime,
+      heapUsed: Math.round(mem.heapUsed / 1024 / 1024),  // MB
+      heapTotal: Math.round(mem.heapTotal / 1024 / 1024),
+      rss: Math.round(mem.rss / 1024 / 1024),
+      external: Math.round(mem.external / 1024 / 1024),
+    });
+  }
+  
+  // Calculate statistics for a timing array
+  calcStats(timings) {
+    if (timings.length === 0) return null;
+    const sorted = [...timings].sort((a, b) => a - b);
+    const sum = sorted.reduce((a, b) => a + b, 0);
+    return {
+      count: sorted.length,
+      min: Math.round(sorted[0]),
+      max: Math.round(sorted[sorted.length - 1]),
+      avg: Math.round(sum / sorted.length),
+      p50: Math.round(sorted[Math.floor(sorted.length * 0.5)]),
+      p90: Math.round(sorted[Math.floor(sorted.length * 0.9)]),
+      p99: Math.round(sorted[Math.floor(sorted.length * 0.99)]),
+    };
+  }
+  
+  // Generate performance report
+  generateReport() {
+    if (!this.enabled) return null;
+    
+    const totalDuration = (Date.now() - this.startTime) / 1000;
+    const requestsPerSecond = this.throughput.totalRequests / totalDuration;
+    const bytesPerSecond = this.throughput.totalBytesUploaded / totalDuration;
+    
+    return {
+      duration: `${totalDuration.toFixed(1)}s`,
+      
+      latencies: {
+        httpPost: this.calcStats(this.timings.httpPost),
+        httpMultipart: this.calcStats(this.timings.httpMultipart),
+        httpStream: this.calcStats(this.timings.httpStream),
+        attachmentRead: this.calcStats(this.timings.attachmentRead),
+        testComplete: this.calcStats(this.timings.testComplete),
+        runStart: this.timings.runStart ? `${Math.round(this.timings.runStart)}ms` : null,
+        runEnd: this.timings.runEnd ? `${Math.round(this.timings.runEnd)}ms` : null,
+      },
+      
+      concurrency: {
+        peakActiveTests: this.concurrency.peakActiveTests,
+        peakPendingRequests: this.concurrency.peakPendingRequests,
+        peakQueuedSteps: this.concurrency.peakQueuedSteps,
+      },
+      
+      throughput: {
+        totalRequests: this.throughput.totalRequests,
+        totalRetries: this.throughput.totalRetries,
+        retryRate: this.throughput.totalRequests > 0 
+          ? `${((this.throughput.totalRetries / this.throughput.totalRequests) * 100).toFixed(1)}%`
+          : '0%',
+        requestsPerSecond: requestsPerSecond.toFixed(1),
+        bytesUploaded: this.formatBytes(this.throughput.totalBytesUploaded),
+        uploadSpeed: `${this.formatBytes(bytesPerSecond)}/s`,
+        batchesFlushed: this.throughput.batchesFlushed,
+        avgStepsPerBatch: this.throughput.stepsPerBatch.length > 0
+          ? (this.throughput.stepsPerBatch.reduce((a, b) => a + b, 0) / this.throughput.stepsPerBatch.length).toFixed(1)
+          : 0,
+      },
+      
+      memory: this.memorySnapshots,
+    };
+  }
+  
+  formatBytes(bytes) {
+    if (bytes < 1024) return `${bytes}B`;
+    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+    return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
+  }
+  
+  // Format a latency stats object for display
+  formatLatencyStats(stats, label) {
+    if (!stats) return null;
+    return `${label}: n=${stats.count} min=${stats.min}ms avg=${stats.avg}ms p90=${stats.p90}ms p99=${stats.p99}ms max=${stats.max}ms`;
+  }
+}
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+function nowIso(d = new Date()) {
+  return d.toISOString();
+}
+
+function parseTags(tags) {
+  if (!tags) return [];
+  if (Array.isArray(tags)) {
+    return tags.filter(t => typeof t === 'string' && t.trim()).map(t => t.trim());
+  }
+  if (typeof tags === 'string') {
+    return tags.split(',').map(t => t.trim()).filter(Boolean);
+  }
+  return [];
+}
+
+function extractAnnotations(test) {
+  const result = {};
+  const caseIdAnn = test?.annotations?.find(a => a?.type === 'caseId')?.description;
+  if (caseIdAnn) result.caseId = String(caseIdAnn);
+  
+  const tagsAnn = test?.annotations?.find(a => a?.type === 'tags')?.description;
+  if (tagsAnn) result.tags = Array.isArray(tagsAnn) ? tagsAnn : [tagsAnn];
+  
+  return result;
+}
+
+function getFilePath(test) {
+  return test?.location?.file || test?.titlePath?.()?.[0] || null;
+}
+
+// Generate deterministic test key from title path
+function getTestKey(test) {
+  return test.titlePath().filter(Boolean).join(' › ');
+}
+
+// Generate unique collector key that includes retry attempt
+// This prevents race conditions between first run and retry collectors
+function getCollectorKey(test, retry = 0) {
+  return `${getTestKey(test)}##retry:${retry}`;
+}
+
+// ============================================================================
+// HTTP CLIENT - Simple fetch with retry
+// ============================================================================
+
+class HttpClient {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout || 30000;
+    this.maxRetries = options.maxRetries || 3;
+    this.logger = options.logger || console.log;
+    this.perfTracker = options.perfTracker || null;
+    this.verbose = options.verbose || false;
+    this.fileLogger = options.fileLogger || null;
+  }
+
+  async post(path, body, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const timeout = options.timeout || this.timeout;
+    const maxRetries = options.noRetry ? 1 : this.maxRetries;
+    
+    // Start timing
+    const endTiming = this.perfTracker?.time('httpPost') || (() => 0);
+    let bodySize = 0;
+    
+    try {
+      bodySize = JSON.stringify(body).length;
+    } catch (e) {
+      // If JSON serialization fails, return error gracefully
+      return { error: 'json_serialization_failed', serviceUnavailable: true };
+    }
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
+      try {
+        const headers = { 'Content-Type': 'application/json' };
+        if (this.apiKey) headers['X-API-Key'] = this.apiKey;
+        
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(body),
+          signal: controller.signal,
+          keepalive: true,
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (response.ok) {
+          const duration = endTiming(bodySize);
+          if (this.verbose) {
+            this.logger('perf', `POST ${path} completed in ${Math.round(duration)}ms (${bodySize} bytes)`);
+          }
+          // Log to file
+          this.fileLogger?.event('HTTP_POST', {
+            path,
+            duration: Math.round(duration),
+            bytes: bodySize,
+            status: response.status,
+            attempt,
+          });
+          return await response.json().catch(() => ({ ok: true }));
+        }
+        
+        // Check for permanent errors (don't retry)
+        const errorData = await response.json().catch(() => ({}));
+        if (['PROJECT_NOT_FOUND', 'API_KEY_REQUIRED', 'INVALID_API_KEY'].includes(errorData.code)) {
+          endTiming(0);
+          return { error: errorData.code, permanent: true };
+        }
+        
+        // Transient error - retry if we have attempts left
+        if (attempt < maxRetries) {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `POST ${path} retry ${attempt}/${maxRetries} after HTTP ${response.status}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            attempt,
+            reason: `HTTP ${response.status}`,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          attempt,
+          error: errorData.error || `HTTP ${response.status}`,
+        });
+        return { error: errorData.error || `HTTP ${response.status}`, serviceUnavailable: true };
+        
+      } catch (err) {
+        clearTimeout(timeoutId);
+        
+        if (attempt < maxRetries && err.name !== 'AbortError') {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `POST ${path} retry ${attempt}/${maxRetries} after error: ${err.message}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            attempt,
+            reason: err.message,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          attempt,
+          error: err.message || 'network_error',
+        });
+        // Mark as service unavailable so caller knows the service is down
+        return { error: err.message || 'network_error', serviceUnavailable: true };
+      }
+    }
+    
+    // Fallback return (should not reach here, but ensures no undefined return)
+    return { error: 'max_retries_exceeded', serviceUnavailable: true };
+  }
+
+  // Fire-and-forget with keepalive (for process exit scenarios)
+  // Designed to NEVER throw - all errors are silently caught
+  fire(path, body) {
+    try {
+      const url = `${this.baseUrl}${path}`;
+      const headers = { 'Content-Type': 'application/json' };
+      if (this.apiKey) headers['X-API-Key'] = this.apiKey;
+      
+      // Safely serialize body
+      let bodyJson;
+      try {
+        bodyJson = JSON.stringify(body);
+      } catch (e) {
+        return; // Skip if serialization fails
+      }
+      
+      // Use beacon-style request that survives process exit
+      fetch(url, {
+        method: 'POST',
+        headers,
+        body: bodyJson,
+        keepalive: true,
+      }).catch(() => {
+        // Silently ignore all errors - this is fire-and-forget
+      });
+    } catch (e) {
+      // Silently ignore all errors
+    }
+  }
+
+  // Upload files via multipart/form-data (no base64 overhead!)
+  async postMultipart(path, fields, files, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const timeout = options.timeout || this.timeout;
+    const maxRetries = options.noRetry ? 1 : this.maxRetries;
+    
+    // Calculate total size for logging
+    const totalSize = files.reduce((sum, f) => sum + (f.buffer?.length || 0), 0);
+    const fileCount = files.length;
+    
+    // Start timing
+    const endTiming = this.perfTracker?.time('httpMultipart') || (() => 0);
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
+      try {
+        // Build multipart boundary
+        const boundary = `----M00nReporter${crypto.randomUUID().replace(/-/g, '')}`;
+        const parts = [];
+        
+        // Add text fields
+        for (const [name, value] of Object.entries(fields)) {
+          parts.push(
+            `--${boundary}\r\n`,
+            `Content-Disposition: form-data; name="${name}"\r\n\r\n`,
+            `${value}\r\n`
+          );
+        }
+        
+        // Add file fields
+        for (const file of files) {
+          parts.push(
+            `--${boundary}\r\n`,
+            `Content-Disposition: form-data; name="file"; filename="${file.name}"\r\n`,
+            `Content-Type: ${file.contentType}\r\n\r\n`
+          );
+          parts.push(file.buffer);
+          parts.push('\r\n');
+        }
+        
+        parts.push(`--${boundary}--\r\n`);
+        
+        // Concatenate all parts into a single buffer
+        const bodyParts = parts.map(p => Buffer.isBuffer(p) ? p : Buffer.from(p));
+        const body = Buffer.concat(bodyParts);
+        
+        const headers = {
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length.toString(),
+        };
+        if (this.apiKey) headers['X-API-Key'] = this.apiKey;
+        
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body,
+          signal: controller.signal,
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (response.ok) {
+          const duration = endTiming(totalSize);
+          if (this.verbose) {
+            const speed = totalSize > 0 ? ((totalSize / 1024) / (duration / 1000)).toFixed(1) : 0;
+            this.logger('perf', `MULTIPART ${path} completed in ${Math.round(duration)}ms (${fileCount} files, ${Math.round(totalSize/1024)}KB, ${speed}KB/s)`);
+          }
+          // Log to file
+          this.fileLogger?.event('HTTP_MULTIPART', {
+            path,
+            duration: Math.round(duration),
+            bytes: totalSize,
+            fileCount,
+            status: response.status,
+            attempt,
+          });
+          return await response.json().catch(() => ({ ok: true }));
+        }
+        
+        const errorData = await response.json().catch(() => ({}));
+        if (attempt < maxRetries) {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `MULTIPART ${path} retry ${attempt}/${maxRetries} after HTTP ${response.status}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            type: 'multipart',
+            attempt,
+            reason: `HTTP ${response.status}`,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          type: 'multipart',
+          attempt,
+          error: errorData.error || `HTTP ${response.status}`,
+        });
+        return { error: errorData.error || `HTTP ${response.status}` };
+        
+      } catch (err) {
+        clearTimeout(timeoutId);
+        
+        if (attempt < maxRetries && err.name !== 'AbortError') {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `MULTIPART ${path} retry ${attempt}/${maxRetries} after error: ${err.message}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            type: 'multipart',
+            attempt,
+            reason: err.message,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          type: 'multipart',
+          attempt,
+          error: err.message || 'network_error',
+        });
+        return { error: err.message || 'network_error' };
+      }
+    }
+  }
+
+  // Stream a file directly to the server (for large files, avoids memory buffering)
+  // Uses the /api/ingest/v2/attachment/stream endpoint
+  async postStreamFile(path, fields, filePath, filename, contentType, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const timeout = options.timeout || 300000; // 5 min timeout for large files
+    const maxRetries = options.noRetry ? 1 : this.maxRetries;
+    
+    // Start timing
+    const endTiming = this.perfTracker?.time('httpStream') || (() => 0);
+    let fileSize = 0;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      
+      try {
+        // Get file stats for Content-Length
+        const stats = await fs.promises.stat(filePath);
+        fileSize = stats.size;
+        
+        // Build multipart body with streaming
+        const boundary = `----M00nReporter${crypto.randomUUID().replace(/-/g, '')}`;
+        
+        // Build header parts (before file content)
+        const headerParts = [];
+        for (const [name, value] of Object.entries(fields)) {
+          headerParts.push(
+            `--${boundary}\r\n`,
+            `Content-Disposition: form-data; name="${name}"\r\n\r\n`,
+            `${value}\r\n`
+          );
+        }
+        headerParts.push(
+          `--${boundary}\r\n`,
+          `Content-Disposition: form-data; name="file"; filename="${filename}"\r\n`,
+          `Content-Type: ${contentType}\r\n\r\n`
+        );
+        const headerBuffer = Buffer.from(headerParts.join(''));
+        
+        // Build footer parts (after file content)
+        const footerBuffer = Buffer.from(`\r\n--${boundary}--\r\n`);
+        
+        // Calculate total content length
+        const totalLength = headerBuffer.length + fileSize + footerBuffer.length;
+        
+        // Create a combined stream: header + file + footer
+        const { Readable } = await import('stream');
+        
+        const combinedStream = new Readable({
+          read() {}
+        });
+        
+        // Push header
+        combinedStream.push(headerBuffer);
+        
+        // Stream file content
+        const fileStream = fs.createReadStream(filePath);
+        fileStream.on('data', (chunk) => combinedStream.push(chunk));
+        fileStream.on('end', () => {
+          combinedStream.push(footerBuffer);
+          combinedStream.push(null); // End the stream
+        });
+        fileStream.on('error', (err) => combinedStream.destroy(err));
+        
+        const headers = {
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': totalLength.toString(),
+        };
+        if (this.apiKey) headers['X-API-Key'] = this.apiKey;
+        
+        // Use fetch with duplex: 'half' for streaming body
+        const response = await fetch(url, {
+          method: 'POST',
+          headers,
+          body: Readable.toWeb(combinedStream),
+          signal: controller.signal,
+          duplex: 'half', // Required for streaming request body
+        });
+        
+        clearTimeout(timeoutId);
+        
+        if (response.ok) {
+          const duration = endTiming(fileSize);
+          if (this.verbose) {
+            const speed = fileSize > 0 ? ((fileSize / 1024 / 1024) / (duration / 1000)).toFixed(1) : 0;
+            this.logger('perf', `STREAM ${path} completed in ${Math.round(duration)}ms (${(fileSize/1024/1024).toFixed(1)}MB, ${speed}MB/s)`);
+          }
+          // Log to file
+          this.fileLogger?.event('HTTP_STREAM', {
+            path,
+            duration: Math.round(duration),
+            bytes: fileSize,
+            filename,
+            status: response.status,
+            attempt,
+          });
+          return await response.json().catch(() => ({ ok: true }));
+        }
+        
+        const errorData = await response.json().catch(() => ({}));
+        if (attempt < maxRetries) {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `STREAM ${path} retry ${attempt}/${maxRetries} after HTTP ${response.status}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            type: 'stream',
+            attempt,
+            reason: `HTTP ${response.status}`,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          type: 'stream',
+          attempt,
+          error: errorData.error || `HTTP ${response.status}`,
+        });
+        return { error: errorData.error || `HTTP ${response.status}` };
+        
+      } catch (err) {
+        clearTimeout(timeoutId);
+        
+        if (attempt < maxRetries && err.name !== 'AbortError') {
+          this.perfTracker?.recordRetry();
+          if (this.verbose) {
+            this.logger('perf', `STREAM ${path} retry ${attempt}/${maxRetries} after error: ${err.message}`);
+          }
+          this.fileLogger?.event('HTTP_RETRY', {
+            path,
+            type: 'stream',
+            attempt,
+            reason: err.message,
+          });
+          const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+          await new Promise(r => setTimeout(r, delay));
+          continue;
+        }
+        
+        endTiming(0);
+        this.fileLogger?.event('HTTP_ERROR', {
+          path,
+          type: 'stream',
+          attempt,
+          error: err.message || 'network_error',
+        });
+        return { error: err.message || 'network_error' };
+      }
+    }
+  }
+
+  // Batch multiple items and send periodically (for step streaming)
+  createBatcher(path, options = {}) {
+    const flushInterval = options.flushInterval || 100;
+    const maxBatchSize = options.maxBatchSize || 50;
+    const perfTracker = this.perfTracker;
+    const fileLogger = this.fileLogger;
+    const verbose = this.verbose;
+    const logger = this.logger;
+    
+    let buffer = [];
+    let flushTimer = null;
+    let totalFlushed = 0;
+    
+    const flush = () => {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      if (buffer.length === 0) return;
+      
+      const items = buffer;
+      buffer = [];
+      totalFlushed += items.length;
+      
+      // Track batch size for efficiency analysis
+      perfTracker?.recordBatchFlush(items.length);
+      if (verbose) {
+        logger('perf', `BATCH flush: ${items.length} steps`);
+      }
+      
+      // Log to file
+      fileLogger?.event('BATCH_FLUSH', {
+        path,
+        stepCount: items.length,
+        totalFlushed,
+      });
+      
+      // Fire-and-forget batch
+      this.fire(path, { items });
+    };
+    
+    return {
+      add: (item) => {
+        buffer.push(item);
+        // Track queue depth for backpressure analysis
+        perfTracker?.updateQueueDepth(buffer.length);
+        
+        if (buffer.length >= maxBatchSize) {
+          flush();
+        } else if (!flushTimer) {
+          flushTimer = setTimeout(flush, flushInterval);
+        }
+      },
+      flush,
+      getPending: () => buffer.length,
+    };
+  }
+}
+
+// ============================================================================
+// TEST COLLECTOR - Collects test data during execution
+// ============================================================================
+
+class TestCollector {
+  constructor(options = {}) {
+    this.testKey = null;
+    // CLIENT-GENERATED UUID - no more waiting for server!
+    // This eliminates the round-trip bottleneck for testId
+    this.testId = options.testId || crypto.randomUUID();
+    this.runId = null;
+    this.filePath = null;
+    this.titlePath = [];
+    this.annotations = {};
+    this.retry = 0;
+    this.startedAt = null;
+    this.steps = [];
+    this.stepIndex = 0;
+    this.activeSteps = new Map(); // stepObject -> stepData (for nesting)
+    this.attachments = [];
+    
+    // Real-time streaming callback
+    this.onStepEvent = options.onStepEvent || null;
+  }
+
+  // Start collecting a step
+  startStep(step) {
+    const stepData = {
+      index: this.stepIndex++,
+      title: step.title,
+      category: step.category || null,
+      status: 'running',
+      startTime: step.startTime ? step.startTime.getTime() : Date.now(),
+      duration: null,
+      error: null,
+      nestingLevel: this.activeSteps.size, // Nesting = number of currently active steps
+    };
+    
+    this.activeSteps.set(step, stepData);
+    this.steps.push(stepData);
+    
+    // Emit real-time event IMMEDIATELY - no waiting for server response!
+    // testId is now client-generated UUID, available instantly
+    if (this.onStepEvent) {
+      this.onStepEvent({
+        action: 'start',
+        runId: this.runId,
+        testId: this.testId,  // Client-generated UUID - always available
+        stepIndex: stepData.index,
+        title: stepData.title,
+        category: stepData.category,
+        status: 'running',
+        nestingLevel: stepData.nestingLevel,
+        startTime: stepData.startTime,
+      });
+    }
+    
+    return stepData;
+  }
+
+  // End collecting a step
+  endStep(step, error = null) {
+    const stepData = this.activeSteps.get(step);
+    if (!stepData) {
+      // Step not found - might be internal Playwright step
+      // Add it as a completed step
+      const newStep = {
+        index: this.stepIndex++,
+        title: step.title,
+        category: step.category || null,
+        status: error ? 'failed' : 'passed',
+        startTime: step.startTime ? step.startTime.getTime() : Date.now(),
+        duration: step.duration || 0,
+        error: error ? { message: stripAnsi(String(error.message || error)), stack: stripAnsi(error.stack) } : null,
+        nestingLevel: 0,
+      };
+      this.steps.push(newStep);
+      
+      // Emit real-time event IMMEDIATELY - testId is client-generated UUID
+      if (this.onStepEvent) {
+        this.onStepEvent({
+          action: 'end',
+          runId: this.runId,
+          testId: this.testId,  // Client-generated UUID - always available
+          stepIndex: newStep.index,
+          title: newStep.title,
+          category: newStep.category,
+          status: newStep.status,
+          duration: newStep.duration,
+          nestingLevel: newStep.nestingLevel,
+          error: newStep.error,
+        });
+      }
+      
+      return newStep;
+    }
+    
+    // Update existing step
+    stepData.status = error ? 'failed' : 'passed';
+    stepData.duration = step.duration || (Date.now() - stepData.startTime);
+    stepData.error = error ? { message: stripAnsi(String(error.message || error)), stack: stripAnsi(error.stack) } : null;
+    
+    this.activeSteps.delete(step);
+    
+    // Emit real-time event IMMEDIATELY - testId is client-generated UUID
+    if (this.onStepEvent) {
+      this.onStepEvent({
+        action: 'end',
+        runId: this.runId,
+        testId: this.testId,  // Client-generated UUID - always available
+        stepIndex: stepData.index,
+        title: stepData.title,
+        category: stepData.category,
+        status: stepData.status,
+        duration: stepData.duration,
+        nestingLevel: stepData.nestingLevel,
+        error: stepData.error,
+      });
+    }
+    
+    return stepData;
+  }
+
+   // Mark any still-running steps as skipped/passed (called at test end)
+  finalizeSteps() {
+    // First, finalize steps still in activeSteps (startStep called, but endStep not called)
+    for (const [step, stepData] of this.activeSteps) {
+      stepData.status = 'skipped';
+      stepData.duration = Date.now() - stepData.startTime;
+    }
+    this.activeSteps.clear();
+    
+    // Also finalize any steps in the array that are still 'running'
+    // This handles edge cases where step end events were missed
+    for (const step of this.steps) {
+      if (step.status === 'running') {
+        // Mark as 'interrupted' to indicate it didn't complete normally
+        step.status = 'interrupted';
+        step.duration = step.duration ?? (Date.now() - step.startTime);
+      }
+    }
+    
+    // Sort steps by startTime to ensure correct order
+    this.steps.sort((a, b) => a.startTime - b.startTime);
+    
+    return this.steps;
+  }
+
+  // Add attachment (async to avoid blocking event loop with large files)
+  // When binaryMode=true, stores raw buffer for multipart upload (no base64!)
+  // For large files (>10MB), stores file path for streaming upload
+  async addAttachment(attachment, testId, runId, binaryMode = true) {
+    if (!attachment.body && !attachment.path) return null;
+    
+    try {
+      let name = attachment.name || 'unknown';
+      let contentType = attachment.contentType || 'application/octet-stream';
+      
+      if (attachment.body) {
+        // Inline body - always buffer (usually small)
+        const buffer = Buffer.from(attachment.body);
+        
+        if (binaryMode) {
+          const attachmentData = {
+            id: crypto.randomUUID(),
+            name,
+            contentType,
+            buffer,
+            size: buffer.length,
+            isLargeFile: false,
+          };
+          this.attachments.push(attachmentData);
+          return attachmentData;
+        } else {
+          const attachmentData = {
+            id: crypto.randomUUID(),
+            name,
+            contentType,
+            data: buffer.toString('base64'),
+            size: buffer.length,
+            compressed: false,
+          };
+          this.attachments.push(attachmentData);
+          return attachmentData;
+        }
+      } else if (attachment.path) {
+        // File path - check size to decide streaming vs buffering
+        try {
+          const stats = await fs.promises.stat(attachment.path);
+          if (stats.size > 500 * 1024 * 1024) return null; // Skip >500MB
+          
+          if (name === 'trace') name = path.basename(attachment.path);
+          
+          // Large file: store path for streaming upload (no buffering!)
+          if (stats.size > LARGE_FILE_THRESHOLD && binaryMode) {
+            const attachmentData = {
+              id: crypto.randomUUID(),
+              name,
+              contentType,
+              filePath: attachment.path, // Store path, NOT buffer!
+              size: stats.size,
+              isLargeFile: true,
+            };
+            this.attachments.push(attachmentData);
+            return attachmentData;
+          }
+          
+          // Small file: buffer it for regular upload
+          const buffer = await fs.promises.readFile(attachment.path);
+          
+          if (binaryMode) {
+            const attachmentData = {
+              id: crypto.randomUUID(),
+              name,
+              contentType,
+              buffer,
+              size: buffer.length,
+              isLargeFile: false,
+            };
+            this.attachments.push(attachmentData);
+            return attachmentData;
+          } else {
+            const attachmentData = {
+              id: crypto.randomUUID(),
+              name,
+              contentType,
+              data: buffer.toString('base64'),
+              size: buffer.length,
+              compressed: false,
+            };
+            this.attachments.push(attachmentData);
+            return attachmentData;
+          }
+        } catch (fileErr) {
+          // File doesn't exist or can't be read
+          // This can happen with 'retain-on-failure' when Playwright cleans up
+          // temporary files from non-final retry attempts
+          return null;
+        }
+      }
+      
+      return null;
+    } catch (err) {
+      return null;
+    }
+  }
+
+  // Build final test payload
+  // When binaryMode=true, excludes attachments (they're uploaded via multipart)
+  buildPayload(result, binaryMode = true) {
+    const steps = this.finalizeSteps();
+    
+    const payload = {
+      testId: this.testId,  // Client-generated UUID (primary identifier)
+      runId: this.runId,
+      filePath: this.filePath,
+      titlePath: this.titlePath,
+      annotations: this.annotations,
+      retry: this.retry,
+      startedAt: this.startedAt,
+      endedAt: nowIso(),
+      status: result.status,
+      duration: result.duration,
+      error: result.errors?.[0] ? {
+        message: stripAnsi(result.errors[0].message || String(result.errors[0])),
+        stack: stripAnsi(result.errors[0].stack),
+        name: result.errors[0].name,
+      } : null,
+      steps: steps.map(s => ({
+        title: s.title,
+        category: s.category,
+        status: s.status,
+        duration: s.duration,
+        error: s.error,
+        nestingLevel: s.nestingLevel,
+        index: s.index,  // Include step index for proper ordering
+      })),
+      // Only include attachments in JSON if NOT using binary mode
+      attachments: binaryMode ? [] : this.attachments,
+    };
+    
+    return payload;
+  }
+}
+
+// ============================================================================
+// REPORTER
+// ============================================================================
+
+export default class M00nReporter {
+  constructor(options = {}) {
+    this.opts = options;
+    this.debug = options.debug || false;
+    this.verbose = options.verbose || false;  // Performance/timing logs
+    this.logFile = options.logFile || null;   // Log file path
+    this.disabled = false;
+    this.realtime = options.realtime !== false; // Default: true
+    this.binaryAttachments = options.binaryAttachments !== false; // Default: true (use multipart)
+    
+    // Performance tracker for bottleneck analysis
+    this.perfTracker = new PerformanceTracker(this.verbose || !!this.logFile);
+    
+    // File logger for persisting metrics
+    this.fileLogger = new FileLogger(this.logFile, !!this.logFile);
+    
+    // Validate required options
+    if (!options.serverUrl) {
+      this.log('warn', '"serverUrl" is required. Reporter disabled.');
+      this.disabled = true;
+      return;
+    }
+    
+    if (!options.apiKey) {
+      this.log('warn', '"apiKey" is required. Reporter disabled.');
+      this.disabled = true;
+      return;
+    }
+    
+    this.runId = null;
+    this.http = new HttpClient(options.serverUrl, {
+      apiKey: options.apiKey,
+      timeout: 60000, // Increased for large file uploads
+      maxRetries: 3,
+      logger: this.log.bind(this),
+      perfTracker: this.perfTracker,
+      verbose: this.verbose,
+      fileLogger: this.fileLogger,
+    });
+    
+    // Step batcher for real-time streaming (fire-and-forget, batched)
+    // Optimized for high parallelism (30+ browsers):
+    // - Larger batch size = fewer HTTP requests
+    // - Longer interval = more batching, less overhead
+    this.stepBatcher = this.http.createBatcher('/api/ingest/v2/steps/stream', {
+      flushInterval: 200,  // Flush every 200ms (was 100ms)
+      maxBatchSize: 100,   // Or when 100 steps accumulated (was 50)
+    });
+    
+    // Per-test collectors (key: testKey string)
+    this.collectors = new Map();
+    
+    // Track ALL in-flight onTestEnd executions to ensure they complete
+    // This fixes the race condition where onEnd is called before onTestEnd finishes
+    this.activeTestEndPromises = [];
+    
+    // Track pending attachment uploads (fire-and-forget during onTestEnd)
+    // These are collected and awaited during onEnd
+    this.pendingAttachmentUploads = [];
+    
+    // Global semaphore to limit concurrent attachment uploads
+    // Prevents server/MinIO overload with high parallelism
+    this.uploadSemaphore = new UploadSemaphore(MAX_GLOBAL_UPLOAD_CONCURRENCY);
+    
+    // test/start is now fire-and-forget (no need to track promises)
+    // testId is generated client-side, so steps can be streamed immediately
+    
+    // Stats
+    this.stats = {
+      testsStarted: 0,
+      testsReported: 0,
+      stepsCounted: 0,
+      stepsStreamed: 0,
+      attachmentsCounted: 0,
+      errors: 0,
+    };
+    
+    // Collect actual error messages for summary
+    this.errorMessages = [];
+    
+    // Take initial memory snapshot
+    this.perfTracker.snapshotMemory('init');
+    
+    // Log initialization
+    if (this.logFile) {
+      this.fileLogger.log('INIT', `Reporter initialized`, {
+        serverUrl: options.serverUrl,
+        realtime: this.realtime,
+        binaryAttachments: this.binaryAttachments,
+      });
+    }
+    
+    if (this.verbose) {
+      this.log('perf', 'Performance logging enabled - tracking timing and concurrency metrics');
+    }
+    if (this.logFile) {
+      this.log('info', `Performance metrics will be saved to: ${this.logFile}`);
+    }
+  }
+  
+  // Add error with message tracking
+  addError(message) {
+    this.stats.errors++;
+    if (this.errorMessages.length < 10) { // Limit to avoid spam
+      this.errorMessages.push(message);
+    }
+  }
+  
+  // Callback for real-time step events
+  createStepEventHandler() {
+    if (!this.realtime) return null;
+    
+    return (stepEvent) => {
+      this.stepBatcher.add(stepEvent);
+      this.stats.stepsStreamed++;
+    };
+  }
+
+  printsToStdio() { return false; }
+
+  log(level, ...args) {
+    if (level === 'debug' && !this.debug) return;
+    if (level === 'perf' && !this.verbose) return;
+    const prefix = '[M00nReporter]';
+    const timestamp = this.verbose ? `[${((Date.now() - this.perfTracker.startTime) / 1000).toFixed(2)}s]` : '';
+    if (level === 'error') console.error(prefix, timestamp, ...args);
+    else if (level === 'warn') console.warn(prefix, timestamp, ...args);
+    else if (level === 'perf') console.log(prefix, '[PERF]', timestamp, ...args);
+    else console.log(prefix, timestamp, ...args);
+  }
+
+  // -------------------------------------------------------------------------
+  // LIFECYCLE HOOKS
+  // -------------------------------------------------------------------------
+
+  async onBegin(config, rootSuite) {
+    if (this.disabled) return;
+    
+    // Wrap entire onBegin in try-catch to ensure test run continues even if reporter fails
+    try {
+      // Prepare run data
+      const total = rootSuite.allTests().length;
+      const launch = this.opts.launch || `Run ${new Date().toLocaleDateString()}`;
+      const tags = parseTags(this.opts.tags);
+      const startedAt = nowIso();
+      
+      if (this.verbose) {
+        this.log('perf', `Starting run with ${total} tests`);
+      }
+      
+      const runStartTime = performance.now();
+      
+      // Run health check and run start in parallel (2s timeout for health check)
+      const healthCheckPromise = fetch(`${this.opts.serverUrl}/healthz`, {
+        method: 'GET',
+        signal: AbortSignal.timeout(2000),
+      }).then(resp => {
+        if (!resp.ok) throw new Error('Health check failed');
+        return { ok: true };
+      }).catch(err => ({ ok: false, error: err }));
+      
+      // Normalize attributes: flat key-value object
+      const attributes = this.opts.attributes && typeof this.opts.attributes === 'object' 
+        ? { ...this.opts.attributes }
+        : {};
+      
+      // Add workers count from Playwright config (useful for timeline visualization)
+      if (config.workers != null) {
+        attributes.workers = config.workers;
+      }
+      
+      // Project is determined by the API key - no need to send projectId
+      const runStartPromise = this.http.post('/api/ingest/v2/run/start', {
+        launch,
+        tags,
+        total,
+        startedAt,
+        attributes,
+      });
+      
+      const [healthResult, resp] = await Promise.all([healthCheckPromise, runStartPromise]);
+      
+      // Track run start timing
+      this.perfTracker.timings.runStart = performance.now() - runStartTime;
+      
+      // Check health result first
+      if (!healthResult.ok) {
+        this.log('warn', `Server unavailable (${this.opts.serverUrl}). Reporter disabled - tests will continue without reporting.`);
+        this.disabled = true;
+        return;
+      }
+      
+      if (resp.error) {
+        if (resp.permanent) {
+          this.log('warn', `${resp.error}. Reporter disabled - tests will continue without reporting.`);
+        } else {
+          this.log('warn', `Failed to start run: ${resp.error}. Reporter disabled - tests will continue without reporting.`);
+        }
+        this.disabled = true;
+        return;
+      }
+      
+      this.runId = resp.runId;
+      this.perfTracker.snapshotMemory('run_started');
+      
+      // Log to file
+      this.fileLogger?.event('RUN_START', {
+        runId: this.runId,
+        total,
+        duration: Math.round(this.perfTracker.timings.runStart),
+      });
+      
+      if (this.verbose) {
+        this.log('perf', `Run started in ${Math.round(this.perfTracker.timings.runStart)}ms: ${this.runId}`);
+      } else {
+        this.log('info', `Run started: ${this.runId}`);
+      }
+    } catch (err) {
+      // Catch any unexpected errors during initialization
+      this.log('warn', `Reporter initialization failed: ${err.message}. Tests will continue without reporting.`);
+      this.disabled = true;
+    }
+  }
+
+  async onTestBegin(test, result) {
+    if (this.disabled || !this.runId) return;
+    
+    // Wrap in try-catch to ensure test processing never crashes the test run
+    try {
+      const testKey = getTestKey(test);
+      const retry = result.retry || 0;
+      // Use unique collector key that includes retry to avoid race conditions
+      const collectorKey = getCollectorKey(test, retry);
+      
+      // Generate testId (UUID) CLIENT-SIDE - no more waiting for server!
+      const testId = crypto.randomUUID();
+      
+      // Track test concurrency
+      try {
+        this.perfTracker.testStarted();
+      } catch (e) {
+        // Ignore perf tracking errors
+      }
+      
+      // Log to file
+      try {
+        this.fileLogger?.event('TEST_BEGIN', {
+          testId,
+          testKey: testKey.substring(0, 100),
+          retry,
+          activeTests: this.perfTracker.concurrency.currentActiveTests,
+        });
+      } catch (e) {
+        // Ignore logging errors
+      }
+      
+      if (this.verbose) {
+        this.log('perf', `Test BEGIN [${this.perfTracker.concurrency.currentActiveTests} active]: ${testKey.substring(0, 60)}...`);
+      }
+      
+      // Create collector for this test with real-time step streaming
+      // testId is available IMMEDIATELY for step streaming
+      const collector = new TestCollector({
+        testId,  // Client-generated UUID
+        onStepEvent: this.createStepEventHandler(),
+      });
+      collector.testKey = testKey;
+      collector.collectorKey = collectorKey; // Store for cleanup
+      collector.runId = this.runId;
+      collector.filePath = getFilePath(test);
+      collector.titlePath = test.titlePath();
+      collector.annotations = extractAnnotations(test);
+      collector.retry = result.retry || 0;
+      collector.startedAt = nowIso(result.startTime || new Date());
+      collector._perfStartTime = performance.now();  // Track test duration for perf
+      
+      this.collectors.set(collectorKey, collector);
+      
+      // FIRE-AND-FORGET test/start - no waiting for response!
+      // The server will create the test row, but we don't need to wait
+      // Steps can be streamed immediately using the client-generated testId
+      this.http.fire('/api/ingest/v2/test/start', {
+        runId: this.runId,
+        testId,  // Client-generated UUID
+        titlePath: collector.titlePath,
+        filePath: collector.filePath,
+        retry: collector.retry,
+        startedAt: collector.startedAt,
+      });
+      
+      this.stats.testsStarted++;
+    } catch (err) {
+      // Catch ALL errors to ensure test run continues
+      this.addError(`Test begin error: ${err.message}`);
+      // Don't rethrow - test should continue even if reporting fails
+    }
+  }
+
+  async onStepBegin(test, result, step) {
+    if (this.disabled || !this.runId) return;
+    
+    // Wrap in try-catch to ensure step processing never crashes the test run
+    try {
+      const collectorKey = getCollectorKey(test, result.retry || 0);
+      const collector = this.collectors.get(collectorKey);
+      if (!collector) return;
+      
+      collector.startStep(step);
+    } catch (err) {
+      // Silently ignore step errors - don't crash the test
+    }
+  }
+
+  async onStepEnd(test, result, step) {
+    if (this.disabled || !this.runId) return;
+    
+    // Wrap in try-catch to ensure step processing never crashes the test run
+    try {
+      const collectorKey = getCollectorKey(test, result.retry || 0);
+      const collector = this.collectors.get(collectorKey);
+      if (!collector) return;
+      
+      collector.endStep(step, step.error);
+      this.stats.stepsCounted++;
+    } catch (err) {
+      // Silently ignore step errors - don't crash the test
+    }
+  }
+
+  async onTestEnd(test, result) {
+    if (this.disabled || !this.runId) return;
+    
+    // Wrap the entire onTestEnd logic in a tracked promise
+    // This ensures onEnd waits for ALL onTestEnd executions to complete
+    // The promise is designed to NEVER reject - _doTestEnd catches all errors
+    const testEndPromise = this._doTestEnd(test, result).catch(err => {
+      // Extra safety net - if _doTestEnd somehow throws, catch it here
+      try {
+        this.addError(`Unexpected onTestEnd error: ${err.message}`);
+      } catch (e) {
+        // Ignore errors in error handling
+      }
+    });
+    this.activeTestEndPromises.push(testEndPromise);
+    
+    // Still await it here for Playwright's benefit
+    await testEndPromise;
+  }
+  
+  // Internal method that does the actual test end work
+  // This method is designed to NEVER throw - all errors are caught and logged
+  // to ensure test runs complete even if the reporting service is unavailable
+  async _doTestEnd(test, result) {
+    const collectorKey = getCollectorKey(test, result.retry || 0);
+    const collector = this.collectors.get(collectorKey);
+    if (!collector) {
+      // Not an error - might happen if reporter was disabled mid-run
+      if (!this.disabled) {
+        this.addError(`No collector for test: ${collectorKey}`);
+      }
+      return;
+    }
+    
+    const testEndStart = performance.now();
+    
+    // Log attachment info for debugging
+    if (this.debug) {
+      const attachmentCount = result.attachments?.length || 0;
+      const attachmentNames = result.attachments?.map(a => a.name).join(', ') || 'none';
+      this.log('debug', `Test ${collectorKey} has ${attachmentCount} attachments: [${attachmentNames}]`);
+    }
+    
+    // testId is now client-generated - NO WAITING NEEDED!
+    // This eliminates the 100-4000ms bottleneck from waiting for server response
+    const testId = collector.testId;
+    
+    try {
+      // Process attachments (async to avoid blocking event loop)
+      const attachmentReadStart = performance.now();
+      const attachmentPromises = (result.attachments || []).map(
+        attachment => collector.addAttachment(attachment, collector.testId, this.runId, this.binaryAttachments)
+          .catch(err => {
+            // Don't let attachment read errors crash the test
+            if (this.debug) {
+              this.log('debug', `Failed to read attachment: ${err.message}`);
+            }
+            return null;
+          })
+      );
+      await Promise.all(attachmentPromises);
+      
+      const attachmentReadDuration = performance.now() - attachmentReadStart;
+      if (collector.attachments.length > 0) {
+        this.perfTracker.timings.attachmentRead.push(attachmentReadDuration);
+        const totalSize = collector.attachments.reduce((sum, a) => sum + (a.size || 0), 0);
+        if (this.verbose) {
+          this.log('perf', `Attachments read: ${collector.attachments.length} files, ${Math.round(totalSize/1024)}KB in ${Math.round(attachmentReadDuration)}ms`);
+        }
+      }
+      
+      this.stats.attachmentsCounted += collector.attachments.length;
+      
+      // Build payload WITHOUT attachments if using binary upload
+      const payload = collector.buildPayload(result, this.binaryAttachments);
+      
+      // Send test completion report and AWAIT it directly with extended timeout
+      const resp = await this.http.post('/api/ingest/v2/test/complete', payload, { timeout: 60000 });
+      
+      if (resp.error) {
+        this.addError(`Failed to report test ${collector.testId}: ${resp.error}`);
+        // Check if service became unavailable mid-run
+        if (resp.serviceUnavailable && !this.disabled) {
+          this.log('warn', 'Reporting service appears unavailable. Continuing tests without reporting.');
+          // Don't fully disable - keep trying in case service comes back
+          // But track that we had connectivity issues
+          this._serviceUnavailableCount = (this._serviceUnavailableCount || 0) + 1;
+          if (this._serviceUnavailableCount >= 5) {
+            this.log('warn', 'Multiple service failures detected. Disabling reporter for remaining tests.');
+            this.disabled = true;
+          }
+        }
+      } else {
+        this.stats.testsReported++;
+        // Reset unavailable counter on success
+        this._serviceUnavailableCount = 0;
+        if (this.debug) {
+          this.log('debug', `Test ${collector.testId} reported successfully`);
+        }
+      }
+      
+      // Track test completion time BEFORE attachment upload (fast path!)
+      // This is the key optimization - test is "done" immediately
+      const testEndDuration = performance.now() - testEndStart;
+      this.perfTracker.timings.testComplete.push(testEndDuration);
+      
+      const testRunDuration = collector._perfStartTime 
+        ? Math.round(performance.now() - collector._perfStartTime) 
+        : result.duration;
+      
+      // Upload attachments in BACKGROUND - fire-and-forget with tracking
+      // Tests complete immediately, attachments upload in parallel with global concurrency limit
+      // All pending uploads are awaited in onEnd before run finishes
+      // Skip if we know service is unavailable
+      if (this.binaryAttachments && collector.attachments.length > 0 && !this.disabled) {
+        const attachmentCount = collector.attachments.length;
+        const attachmentSize = collector.attachments.reduce((sum, a) => sum + (a.size || 0), 0);
+        
+        // Create upload promise with error handling (don't let it crash)
+        const uploadPromise = this.uploadAttachmentsWithBackpressure(
+          collector.runId,
+          collector.testId,
+          collector.attachments
+        ).catch(err => {
+          this.addError(`Background upload failed for test ${testId}: ${err.message}`);
+          this.fileLogger?.event('ATTACHMENT_UPLOAD_ERROR', {
+            testId,
+            error: err.message,
+            attachmentCount,
+          });
+          return { uploaded: 0, failed: attachmentCount };
+        });
+        
+        // Track promise (will be awaited in onEnd)
+        this.pendingAttachmentUploads.push(uploadPromise);
+        
+        if (this.verbose) {
+          const semStats = this.uploadSemaphore.getStats();
+          this.log('perf', `Queued ${attachmentCount} attachments (${Math.round(attachmentSize/1024)}KB) for background upload (queue: ${semStats.queued}, active: ${semStats.running})`);
+        }
+      }
+      
+      // Log to file
+      this.fileLogger?.event('TEST_END', {
+        testId,
+        testKey: collector.testKey.substring(0, 100),
+        status: result.status,
+        retry: collector.retry,
+        runDuration: testRunDuration,
+        reportDuration: Math.round(testEndDuration),
+        steps: collector.steps.length,
+        attachments: collector.attachments.length,
+        activeTests: this.perfTracker.concurrency.currentActiveTests - 1,
+      });
+      
+      if (this.verbose) {
+        this.log('perf', `Test END [${this.perfTracker.concurrency.currentActiveTests - 1} active]: ${collector.testKey.substring(0, 40)}... (run: ${testRunDuration}ms, report: ${Math.round(testEndDuration)}ms)`);
+      }
+    } catch (err) {
+      // Catch ALL errors to ensure test run continues
+      this.addError(`Test ${testId} processing error: ${err.message}`);
+      this.fileLogger?.event('TEST_ERROR', {
+        testId,
+        error: err.message,
+      });
+      // Don't rethrow - test should complete even if reporting fails
+    } finally {
+      // Track test concurrency
+      this.perfTracker.testEnded();
+      
+      // Cleanup collector using the unique collectorKey
+      this.collectors.delete(collectorKey);
+    }
+  }
+
+  // Upload attachments with global backpressure control (fire-and-forget friendly)
+  // Uses semaphore to limit concurrent uploads across ALL tests
+  // Returns { uploaded: N, failed: M } for tracking
+  async uploadAttachmentsWithBackpressure(runId, testId, attachments) {
+    if (!attachments || attachments.length === 0) return { uploaded: 0, failed: 0 };
+    
+    const results = { uploaded: 0, failed: 0 };
+    const uploadStart = performance.now();
+    
+    // Separate small and large files
+    const smallFiles = attachments.filter(a => a.buffer && !a.isLargeFile);
+    const largeFiles = attachments.filter(a => a.filePath && a.isLargeFile);
+    
+    // Create upload tasks for all files
+    const uploadTasks = [];
+    
+    // Small files - upload individually with semaphore for better parallelism
+    for (const file of smallFiles) {
+      uploadTasks.push(this.uploadSemaphore.run(async () => {
+        try {
+          const resp = await this.http.postMultipart(
+            '/api/ingest/v2/attachment/upload',
+            { runId, testId: String(testId) },
+            [{ name: file.name, contentType: file.contentType, buffer: file.buffer }],
+            { timeout: UPLOAD_TIMEOUT }
+          );
+          
+          if (resp.error) {
+            this.addError(`Upload failed (${file.name}): ${resp.error}`);
+            return false;
+          }
+          return true;
+        } catch (err) {
+          this.addError(`Upload error (${file.name}): ${err.message}`);
+          return false;
+        }
+      }));
+    }
+    
+    // Large files - stream upload with semaphore
+    for (const largeFile of largeFiles) {
+      uploadTasks.push(this.uploadSemaphore.run(async () => {
+        try {
+          if (this.debug) {
+            this.log('debug', `Streaming large file: ${largeFile.name} (${(largeFile.size / 1024 / 1024).toFixed(1)}MB)`);
+          }
+          
+          const resp = await this.http.postStreamFile(
+            '/api/ingest/v2/attachment/stream',
+            { runId, testId: String(testId) },
+            largeFile.filePath,
+            largeFile.name,
+            largeFile.contentType,
+            { timeout: STREAM_UPLOAD_TIMEOUT }
+          );
+          
+          if (resp.error) {
+            this.addError(`Stream upload failed (${largeFile.name}): ${resp.error}`);
+            return false;
+          }
+          return true;
+        } catch (err) {
+          this.addError(`Stream upload error (${largeFile.name}): ${err.message}`);
+          return false;
+        }
+      }));
+    }
+    
+    // Wait for all uploads to complete
+    const uploadResults = await Promise.allSettled(uploadTasks);
+    
+    // Count results
+    for (const result of uploadResults) {
+      if (result.status === 'fulfilled' && result.value === true) {
+        results.uploaded++;
+      } else {
+        results.failed++;
+      }
+    }
+    
+    const uploadDuration = performance.now() - uploadStart;
+    
+    if (this.verbose) {
+      this.log('perf', `Attachments uploaded: ${results.uploaded}/${attachments.length} in ${Math.round(uploadDuration)}ms`);
+    }
+    
+    // Log to file
+    this.fileLogger?.event('ATTACHMENTS_UPLOADED', {
+      testId,
+      total: attachments.length,
+      uploaded: results.uploaded,
+      failed: results.failed,
+      duration: Math.round(uploadDuration),
+    });
+    
+    return results;
+  }
+
+  async onEnd(result) {
+    // Always print summary at the end, even if disabled
+    const printSummaryOnExit = () => {
+      try {
+        this.printSummary();
+      } catch (e) {
+        // Ignore summary errors
+      }
+    };
+    
+    if (this.disabled || !this.runId) {
+      printSummaryOnExit();
+      return;
+    }
+    
+    const runEndStart = performance.now();
+    
+    try {
+      this.perfTracker.snapshotMemory('run_ending');
+    } catch (e) {
+      // Ignore memory snapshot errors
+    }
+    
+    if (this.verbose) {
+      this.log('perf', `Run ending - ${this.activeTestEndPromises.length} tests in flight`);
+    }
+    
+    // CRITICAL: Keep the event loop alive until we're done
+    // This prevents Node.js/Playwright from exiting prematurely
+    const keepAlive = setInterval(() => {}, 100);
+    
+    try {
+      // Wait for ALL in-flight onTestEnd executions to complete
+      // with a maximum timeout to avoid hanging forever
+      if (this.activeTestEndPromises.length > 0) {
+        if (this.verbose) {
+          this.log('perf', `Waiting for ${this.activeTestEndPromises.length} test(s) to finish reporting...`);
+        } else if (this.debug) {
+          this.log('debug', `Waiting for ${this.activeTestEndPromises.length} test(s) to finish reporting...`);
+        }
+        
+        const waitStart = performance.now();
+        
+        // Wait with timeout - max 60 seconds
+        const timeout = new Promise(resolve => setTimeout(() => resolve('timeout'), 60000));
+        try {
+          const waitResult = await Promise.race([
+            Promise.allSettled(this.activeTestEndPromises),
+            timeout
+          ]);
+          
+          if (this.verbose) {
+            this.log('perf', `Test reporting wait completed in ${Math.round(performance.now() - waitStart)}ms`);
+          }
+          
+          if (waitResult === 'timeout') {
+            this.addError('Timeout waiting for tests to finish - some data may be lost');
+          }
+        } catch (e) {
+          this.addError(`Error waiting for tests: ${e.message}`);
+        }
+      }
+      
+      // Wait for all pending attachment uploads (fire-and-forget uploads from onTestEnd)
+      // These are uploaded in background with concurrency control via semaphore
+      if (this.pendingAttachmentUploads.length > 0) {
+        try {
+          const attachmentWaitStart = performance.now();
+          const pendingCount = this.pendingAttachmentUploads.length;
+          const semStats = this.uploadSemaphore.getStats();
+          
+          if (this.verbose) {
+            this.log('perf', `Waiting for ${pendingCount} attachment upload batches (${semStats.running} active, ${semStats.queued} queued)...`);
+          }
+          
+          // Log to file
+          this.fileLogger?.event('ATTACHMENTS_WAIT_START', {
+            pendingBatches: pendingCount,
+            activeUploads: semStats.running,
+            queuedUploads: semStats.queued,
+          });
+          
+          // Wait with generous timeout for attachment uploads
+          const attachmentTimeout = new Promise(resolve => 
+            setTimeout(() => resolve('timeout'), END_UPLOAD_WAIT_TIMEOUT)
+          );
+          
+          const uploadWaitResult = await Promise.race([
+            Promise.allSettled(this.pendingAttachmentUploads),
+            attachmentTimeout
+          ]);
+          
+          const attachmentWaitDuration = Math.round(performance.now() - attachmentWaitStart);
+          
+          if (uploadWaitResult === 'timeout') {
+            this.addError(`Timeout waiting for attachment uploads after ${END_UPLOAD_WAIT_TIMEOUT/1000}s - some attachments may be missing`);
+            this.fileLogger?.event('ATTACHMENTS_WAIT_TIMEOUT', {
+              duration: attachmentWaitDuration,
+              pendingBatches: pendingCount,
+            });
+          } else {
+            // Count success/failure
+            let totalUploaded = 0;
+            let totalFailed = 0;
+            for (const res of uploadWaitResult) {
+              if (res.status === 'fulfilled' && res.value) {
+                totalUploaded += res.value.uploaded || 0;
+                totalFailed += res.value.failed || 0;
+              }
+            }
+            
+            if (this.verbose) {
+              this.log('perf', `Attachment uploads complete: ${totalUploaded} uploaded, ${totalFailed} failed in ${attachmentWaitDuration}ms`);
+            }
+            
+            this.fileLogger?.event('ATTACHMENTS_WAIT_COMPLETE', {
+              duration: attachmentWaitDuration,
+              batches: pendingCount,
+              uploaded: totalUploaded,
+              failed: totalFailed,
+            });
+          }
+        } catch (e) {
+          this.addError(`Error waiting for attachments: ${e.message}`);
+        }
+      }
+      
+      // test/start is now fire-and-forget - no need to wait for responses
+      // testId is generated client-side, so we don't need server confirmation
+      
+      // Flush any remaining streamed steps (wrapped in try-catch)
+      try {
+        const pendingSteps = this.stepBatcher.getPending();
+        if (this.verbose && pendingSteps > 0) {
+          this.log('perf', `Flushing ${pendingSteps} remaining step events`);
+        }
+        this.stepBatcher.flush();
+      } catch (e) {
+        // Ignore step flush errors
+      }
+      
+      // Check if any collectors are still active (tests that never completed)
+      // and try to report them as incomplete
+      if (this.collectors.size > 0) {
+        try {
+          this.log('warn', `${this.collectors.size} test(s) incomplete - attempting to report...`);
+          await this.reportIncompleteTests();
+        } catch (e) {
+          this.log('warn', `Failed to report incomplete tests: ${e.message}`);
+        }
+      }
+      
+      // Give a small delay for any final network I/O to complete
+      await new Promise(r => setTimeout(r, 200));
+      
+      // Send run end with retry (don't let this block test completion)
+      try {
+        const resp = await this.http.post('/api/ingest/v2/run/end', {
+          runId: this.runId,
+          status: result.status,
+          endedAt: nowIso(),
+        });
+        
+        if (resp.error) {
+          this.log('warn', `Failed to end run: ${resp.error}`);
+        }
+      } catch (e) {
+        this.log('warn', `Error ending run: ${e.message}`);
+      }
+      
+      // Track run end timing
+      try {
+        this.perfTracker.timings.runEnd = performance.now() - runEndStart;
+        this.perfTracker.snapshotMemory('run_ended');
+        
+        // Log to file
+        this.fileLogger?.event('RUN_END', {
+          runId: this.runId,
+          status: result.status,
+          duration: Math.round(this.perfTracker.timings.runEnd),
+          testsStarted: this.stats.testsStarted,
+          testsReported: this.stats.testsReported,
+          errors: this.stats.errors,
+        });
+        
+        if (this.verbose) {
+          this.log('perf', `Run end completed in ${Math.round(this.perfTracker.timings.runEnd)}ms`);
+        }
+      } catch (e) {
+        // Ignore tracking errors
+      }
+      
+      printSummaryOnExit();
+      
+      // Write final performance report to file
+      try {
+        this.writePerformanceReportToFile();
+      } catch (e) {
+        // Ignore perf report errors
+      }
+      
+      // Close file logger
+      try {
+        this.fileLogger?.close();
+      } catch (e) {
+        // Ignore logger close errors
+      }
+      
+    } catch (err) {
+      // Catch any unexpected errors in onEnd to ensure we don't crash the test run
+      this.log('warn', `Error in reporter onEnd: ${err.message}`);
+      printSummaryOnExit();
+    } finally {
+      // Stop keeping the event loop alive
+      clearInterval(keepAlive);
+    }
+  }
+  
+  // Report any tests that didn't complete normally
+  async reportIncompleteTests() {
+    const promises = [];
+    
+    for (const [testKey, collector] of this.collectors) {
+      // testId is always available (client-generated UUID)
+      this.log('warn', `Reporting incomplete test ${collector.testId}: ${testKey}`);
+      
+      const payload = {
+        testId: collector.testId,  // Client-generated UUID
+        runId: collector.runId,
+        titlePath: collector.titlePath,
+        filePath: collector.filePath,
+        retry: collector.retry,
+        startedAt: collector.startedAt,
+        endedAt: nowIso(),
+        status: 'interrupted', // Mark as interrupted since it didn't complete normally
+        duration: Date.now() - new Date(collector.startedAt).getTime(),
+        error: { message: 'Test was interrupted - reporter did not receive completion data' },
+        steps: collector.steps.map(s => ({
+          title: s.title,
+          category: s.category,
+          status: s.status === 'running' ? 'interrupted' : s.status,
+          duration: s.duration,
+          error: s.error,
+          nestingLevel: s.nestingLevel,
+          index: s.index,
+        })),
+        attachments: [],
+      };
+      
+      promises.push(
+        this.http.post('/api/ingest/v2/test/complete', payload)
+          .then(resp => {
+            if (!resp.error) {
+              this.stats.testsReported++;
+              this.log('info', `Incomplete test ${collector.testId} reported as interrupted`);
+            } else {
+              this.addError(`Failed to report incomplete test ${collector.testId}: ${resp.error}`);
+            }
+          })
+          .catch((err) => {
+            this.addError(`Incomplete test ${collector.testId} report failed: ${err.message}`);
+          })
+      );
+    }
+    
+    if (promises.length > 0) {
+      await Promise.allSettled(promises);
+    }
+    
+    // Clear all collectors
+    this.collectors.clear();
+  }
+
+  // Write performance report to log file
+  writePerformanceReportToFile() {
+    if (!this.fileLogger?.enabled) return;
+    
+    const perf = this.perfTracker.generateReport();
+    if (!perf) return;
+    
+    // Build report content
+    const lines = [];
+    lines.push(`Run ID: ${this.runId || 'N/A'}`);
+    lines.push(`Total Duration: ${perf.duration}`);
+    lines.push('');
+    
+    lines.push('=== Stats ===');
+    lines.push(`Tests: ${this.stats.testsReported}/${this.stats.testsStarted} reported`);
+    lines.push(`Steps: ${this.stats.stepsCounted} collected, ${this.stats.stepsStreamed} streamed`);
+    lines.push(`Attachments: ${this.stats.attachmentsCounted}`);
+    lines.push(`Errors: ${this.stats.errors}`);
+    lines.push('');
+    
+    lines.push('=== Concurrency ===');
+    lines.push(`Peak active tests: ${perf.concurrency.peakActiveTests}`);
+    lines.push(`Peak pending requests: ${perf.concurrency.peakPendingRequests}`);
+    lines.push(`Peak queued steps: ${perf.concurrency.peakQueuedSteps}`);
+    lines.push('');
+    
+    lines.push('=== Throughput ===');
+    lines.push(`Total requests: ${perf.throughput.totalRequests} (${perf.throughput.requestsPerSecond}/s)`);
+    lines.push(`Retry rate: ${perf.throughput.retryRate} (${perf.throughput.totalRetries} retries)`);
+    lines.push(`Data uploaded: ${perf.throughput.bytesUploaded} (${perf.throughput.uploadSpeed})`);
+    lines.push(`Step batches: ${perf.throughput.batchesFlushed} (avg ${perf.throughput.avgStepsPerBatch} steps/batch)`);
+    lines.push('');
+    
+    lines.push('=== Latencies (ms) ===');
+    if (perf.latencies.runStart) lines.push(`Run start: ${perf.latencies.runStart}`);
+    if (perf.latencies.runEnd) lines.push(`Run end: ${perf.latencies.runEnd}`);
+    
+    const formatStats = (stats) => {
+      if (!stats) return 'N/A';
+      return `n=${stats.count} min=${stats.min} avg=${stats.avg} p50=${stats.p50} p90=${stats.p90} p99=${stats.p99} max=${stats.max}`;
+    };
+    
+    if (perf.latencies.httpPost) lines.push(`HTTP POST: ${formatStats(perf.latencies.httpPost)}`);
+    if (perf.latencies.httpMultipart) lines.push(`Multipart: ${formatStats(perf.latencies.httpMultipart)}`);
+    if (perf.latencies.httpStream) lines.push(`Stream: ${formatStats(perf.latencies.httpStream)}`);
+    if (perf.latencies.attachmentRead) lines.push(`Attachment read: ${formatStats(perf.latencies.attachmentRead)}`);
+    if (perf.latencies.testComplete) lines.push(`Test complete: ${formatStats(perf.latencies.testComplete)}`);
+    lines.push('');
+    
+    lines.push('=== Memory (MB) ===');
+    for (const snap of perf.memory) {
+      lines.push(`[${(snap.timestamp/1000).toFixed(1)}s] ${snap.label}: heap=${snap.heapUsed}/${snap.heapTotal} rss=${snap.rss} external=${snap.external}`);
+    }
+    lines.push('');
+    
+    // Error messages
+    if (this.errorMessages.length > 0) {
+      lines.push('=== Errors ===');
+      for (const msg of this.errorMessages) {
+        lines.push(`  - ${msg}`);
+      }
+      lines.push('');
+    }
+    
+    // Write JSON summary for machine parsing
+    lines.push('=== JSON Summary ===');
+    lines.push(JSON.stringify({
+      runId: this.runId,
+      stats: this.stats,
+      concurrency: perf.concurrency,
+      throughput: perf.throughput,
+      latencies: {
+        runStart: this.perfTracker.timings.runStart,
+        runEnd: this.perfTracker.timings.runEnd,
+        httpPost: perf.latencies.httpPost,
+        httpMultipart: perf.latencies.httpMultipart,
+        httpStream: perf.latencies.httpStream,
+        attachmentRead: perf.latencies.attachmentRead,
+        testComplete: perf.latencies.testComplete,
+      },
+      memory: perf.memory,
+    }, null, 2));
+    
+    this.fileLogger.writeReport('PERFORMANCE SUMMARY', lines.join('\n'));
+  }
+
+  printSummary() {
+    console.log('\n' + '═'.repeat(60));
+    console.log('[M00nReporter] Run Summary');
+    console.log('─'.repeat(60));
+    console.log(`  Run ID:       ${this.runId || 'N/A'}`);
+    console.log(`  Tests:        ${this.stats.testsReported}/${this.stats.testsStarted} reported`);
+    console.log(`  Steps:        ${this.stats.stepsCounted} collected`);
+    if (this.realtime) {
+      console.log(`  Streamed:     ${this.stats.stepsStreamed} step events`);
+    }
+    console.log(`  Attachments:  ${this.stats.attachmentsCounted}`);
+    if (this.stats.errors > 0) {
+      console.log(`  Errors:       ${this.stats.errors}`);
+      console.log('─'.repeat(60));
+      console.log('  Error Details:');
+      for (const msg of this.errorMessages) {
+        console.log(`    • ${msg}`);
+      }
+      if (this.stats.errors > this.errorMessages.length) {
+        console.log(`    ... and ${this.stats.errors - this.errorMessages.length} more`);
+      }
+    }
+    
+    // Print performance report when verbose mode is enabled
+    if (this.verbose) {
+      const perf = this.perfTracker.generateReport();
+      if (perf) {
+        console.log('─'.repeat(60));
+        console.log('[M00nReporter] Performance Report');
+        console.log('─'.repeat(60));
+        console.log(`  Total Duration: ${perf.duration}`);
+        
+        // Concurrency
+        console.log('\n  Concurrency:');
+        console.log(`    Peak active tests:    ${perf.concurrency.peakActiveTests}`);
+        console.log(`    Peak pending requests: ${perf.concurrency.peakPendingRequests}`);
+        console.log(`    Peak queued steps:    ${perf.concurrency.peakQueuedSteps}`);
+        
+        // Throughput
+        console.log('\n  Throughput:');
+        console.log(`    Total requests:   ${perf.throughput.totalRequests} (${perf.throughput.requestsPerSecond}/s)`);
+        console.log(`    Retry rate:       ${perf.throughput.retryRate} (${perf.throughput.totalRetries} retries)`);
+        console.log(`    Data uploaded:    ${perf.throughput.bytesUploaded} (${perf.throughput.uploadSpeed})`);
+        console.log(`    Step batches:     ${perf.throughput.batchesFlushed} (avg ${perf.throughput.avgStepsPerBatch} steps/batch)`);
+        
+        // Latencies
+        console.log('\n  Latencies (ms):');
+        if (perf.latencies.runStart) {
+          console.log(`    Run start:        ${perf.latencies.runStart}`);
+        }
+        if (perf.latencies.runEnd) {
+          console.log(`    Run end:          ${perf.latencies.runEnd}`);
+        }
+        
+        const formatStats = (stats) => {
+          if (!stats) return 'N/A';
+          return `n=${stats.count} min=${stats.min} avg=${stats.avg} p90=${stats.p90} p99=${stats.p99} max=${stats.max}`;
+        };
+        
+        if (perf.latencies.httpPost) {
+          console.log(`    HTTP POST:        ${formatStats(perf.latencies.httpPost)}`);
+        }
+        if (perf.latencies.httpMultipart) {
+          console.log(`    Multipart:        ${formatStats(perf.latencies.httpMultipart)}`);
+        }
+        if (perf.latencies.httpStream) {
+          console.log(`    Stream upload:    ${formatStats(perf.latencies.httpStream)}`);
+        }
+        if (perf.latencies.attachmentRead) {
+          console.log(`    Attachment read:  ${formatStats(perf.latencies.attachmentRead)}`);
+        }
+        if (perf.latencies.testComplete) {
+          console.log(`    Test complete:    ${formatStats(perf.latencies.testComplete)}`);
+        }
+        
+        // Memory
+        if (perf.memory.length > 0) {
+          console.log('\n  Memory (MB):');
+          for (const snap of perf.memory) {
+            console.log(`    [${(snap.timestamp/1000).toFixed(1)}s] ${snap.label}: heap=${snap.heapUsed}/${snap.heapTotal} rss=${snap.rss}`);
+          }
+        }
+        
+        // Bottleneck analysis hints
+        console.log('\n  Bottleneck Analysis:');
+        const hints = [];
+        
+        if (perf.latencies.httpPost && perf.latencies.httpPost.p99 > 1000) {
+          hints.push(`⚠ HTTP POST p99=${perf.latencies.httpPost.p99}ms - server may be overloaded`);
+        }
+        if (perf.throughput.totalRetries > perf.throughput.totalRequests * 0.1) {
+          hints.push(`⚠ High retry rate (${perf.throughput.retryRate}) - network or server issues`);
+        }
+        if (perf.concurrency.peakActiveTests > 30) {
+          hints.push(`⚠ High test concurrency (${perf.concurrency.peakActiveTests}) - consider reducing workers`);
+        }
+        if (perf.concurrency.peakQueuedSteps > 500) {
+          hints.push(`⚠ Large step queue (${perf.concurrency.peakQueuedSteps}) - step streaming may be backed up`);
+        }
+        if (perf.latencies.testComplete && perf.latencies.testComplete.p90 > 2000) {
+          hints.push(`⚠ Test completion p90=${perf.latencies.testComplete.p90}ms - attachments may be slow`);
+        }
+        
+        const memSnapshots = perf.memory;
+        if (memSnapshots.length >= 2) {
+          const first = memSnapshots[0];
+          const last = memSnapshots[memSnapshots.length - 1];
+          const heapGrowth = last.heapUsed - first.heapUsed;
+          if (heapGrowth > 100) {
+            hints.push(`⚠ Memory grew by ${heapGrowth}MB - possible memory leak or large attachments`);
+          }
+        }
+        
+        if (hints.length === 0) {
+          console.log('    ✓ No obvious bottlenecks detected');
+        } else {
+          for (const hint of hints) {
+            console.log(`    ${hint}`);
+          }
+        }
+      }
+    }
+    
+    // Show log file path if logging to file
+    if (this.logFile) {
+      console.log('─'.repeat(60));
+      console.log(`  Log file: ${this.logFile}`);
+    }
+    
+    console.log('═'.repeat(60) + '\n');
+  }
+}