@matware/e2e-runner 1.3.0 → 1.5.0

package/src/runner.js

@@ -9,18 +9,53 @@ import fs from 'fs';
 import path from 'path';
 import http from 'http';
 import https from 'https';
-import { connectToPool } from './pool.js';
-import { getPoolUrls, selectPool, releasePending } from './pool-manager.js';
-import { executeAction } from './actions.js';
+import { connectToPool, getCachedDriver, disconnectFromPool } from './pool.js';
+import { getPoolUrls, selectPool, releasePending, resolvePoolsForTest } from './pool-manager.js';
+import { forkAppInstance, destroyFork, isAppPoolEnabled } from './app-pool.js';
+import { executeAction, pageHasRenderableContent, looksLikeBlankCapture } from './actions.js';
 import { narrateAction } from './narrate.js';
 import { log, colors as C } from './logger.js';
 import { resolveTestData, validateActionTypes } from './module-resolver.js';
+import { compareImages } from './visual-diff.js';
 import { ensureProject, getVariables } from './db.js';
 
 function sleep(ms) {
   return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Best-effort step thumbnail for the storyline view.
+ * Captures once in memory, writes to disk AND returns base64 so callers
+ * can stream the same frame through the live preview WebSocket.
+ * Skips silently on any error so it never breaks a test run.
+ */
+const NO_AUTO_CAPTURE_TYPES = new Set(['screenshot', 'close_tab']);
+async function tryAutoCaptureStep(page, action, idx, testName, effectiveConfig, alreadyCaptured) {
+  if (!effectiveConfig.autoCaptureSteps) return null;
+  if (NO_AUTO_CAPTURE_TYPES.has(action?.type)) return null;
+  if (alreadyCaptured) return null;
+  if (!page || (typeof page.isClosed === 'function' && page.isClosed())) return null;
+  // Skip auto-capture when the page can't produce a meaningful image —
+  // about:blank or fully empty DOM — to stop blank step-*.jpg flooding.
+  if (!(await pageHasRenderableContent(page))) return null;
+  try {
+    const safeName = String(testName).replace(/[^a-zA-Z0-9_\-. ]/g, '_');
+    const filename = `step-${safeName}-${String(idx).padStart(3, '0')}-${Date.now()}.jpg`;
+    const filepath = path.join(effectiveConfig.screenshotsDir, filename);
+    const buf = await page.screenshot({
+      type: 'jpeg',
+      quality: effectiveConfig.autoCaptureQuality ?? 60,
+      fullPage: false,
+      encoding: 'binary',
+    });
+    if (looksLikeBlankCapture(buf, 'jpeg')) return null;
+    fs.writeFileSync(filepath, buf);
+    return { path: filepath, base64: buf.toString('base64') };
+  } catch {
+    return null;
+  }
+}
+
 /** Simple glob matching with * wildcards for exclude patterns. */
 function matchesExclude(filename, excludePatterns) {
   if (!excludePatterns?.length) return false;
@@ -115,7 +150,7 @@ function getByPath(obj, dotPath) {
 }
 
 /** Fetches an auth token by POSTing credentials to a login endpoint. */
-function fetchAuthToken(endpoint, credentials, tokenPath) {
+export function fetchAuthToken(endpoint, credentials, tokenPath) {
   return new Promise((resolve, reject) => {
     const url = new URL(endpoint);
     const transport = url.protocol === 'https:' ? https : http;
@@ -123,7 +158,7 @@ function fetchAuthToken(endpoint, credentials, tokenPath) {
 
     const req = transport.request(url, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+      headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body), 'Accept': '*/*', 'User-Agent': '@matware/e2e-runner' },
       timeout: 15000,
     }, (res) => {
       let data = '';
@@ -155,6 +190,14 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
   let browser = null;
   let context = null;
   let page = null;
+  let cdpSession = null;
+  let appFork = null;
+
+  // ── Multi-tab registry ────────────────────────────────────────────────────
+  // Maps label → page. The "default" label is the initial page.
+  // activePage tracks the current tab; page always points to it.
+  const tabRegistry = new Map();
+  let activeTabLabel = 'default';
 
   const result = {
     name: test.name,
@@ -169,8 +212,35 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
   const pendingBodies = [];
 
   try {
-    const chosenPool = await selectPool(getPoolUrls(config));
+    // Fork an isolated app instance if app pool is enabled
+    let effectiveConfig = config;
+    if (isAppPoolEnabled(config)) {
+      appFork = await forkAppInstance(config, test.name);
+      // Override baseUrl to point to this test's isolated app instance
+      // Use dockerBaseUrl when Chrome runs inside Docker (default setup)
+      effectiveConfig = { ...config, baseUrl: appFork.dockerBaseUrl };
+      result.appFork = { forkId: appFork.forkId, baseUrl: appFork.baseUrl, port: appFork.port, forkTimeMs: appFork.forkTimeMs };
+    }
+
+    const driverOpts = { poolDriver: config.poolDriver || 'auto', maxSessions: config.maxSessions || 10 };
+
+    // CLI override (--driver / --fallback-driver) wins over per-test fields.
+    const requestedDriver = config.cliDriverOverride || test.driver || null;
+    const requestedFallback = config.cliFallbackDriverOverride || test.fallbackDriver || null;
+
+    let candidatePoolUrls = getPoolUrls(config);
+    let driverChoice = null;
+    if (requestedDriver) {
+      const resolved = await resolvePoolsForTest(candidatePoolUrls, requestedDriver, requestedFallback, driverOpts);
+      candidatePoolUrls = resolved.urls;
+      driverChoice = { requested: requestedDriver, used: resolved.driver, usedFallback: resolved.usedFallback };
+      log('🎯', `${C.dim}${test.name}: driver=${resolved.driver}${resolved.usedFallback ? ' (fallback)' : ''}${C.reset}`);
+    }
+
+    const chosenPool = await selectPool(candidatePoolUrls, 2000, 60000, driverOpts);
     result.poolUrl = chosenPool;
+    result.poolDriver = getCachedDriver(chosenPool);
+    if (driverChoice) result.driverChoice = driverChoice;
     const poolLabel = chosenPool.replace('ws://', '').replace('wss://', '');
     const isMultiPool = getPoolUrls(config).length > 1;
     if (isMultiPool) {
@@ -182,6 +252,46 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
     context = await browser.createBrowserContext();
     page = await context.newPage();
     await page.setViewport(config.viewport);
+    tabRegistry.set('default', page);
+
+    // CDP screencast — streams browser frames as JPEG to the dashboard
+    // Only attempt on browserless pools; generic CDP pools (Lightpanda) break on createCDPSession
+    const poolDriver = getCachedDriver(chosenPool);
+    if (config.screencast && poolDriver !== 'cdp') {
+      try {
+        const raceTimeout = (promise, ms) => Promise.race([
+          promise,
+          new Promise((_, reject) => { const t = setTimeout(() => reject(new Error('CDP timeout')), ms); t.unref(); }),
+        ]);
+        cdpSession = await raceTimeout(page.createCDPSession(), 5000);
+        let frameCount = 0;
+        const everyNth = config.screencastEveryNthFrame || 1;
+        cdpSession.on('Page.screencastFrame', (frame) => {
+          frameCount++;
+          cdpSession.send('Page.screencastFrameAck', { sessionId: frame.sessionId }).catch(() => {});
+          if (everyNth > 1 && frameCount % everyNth !== 0) return;
+          progressFn({
+            event: 'test:frame',
+            name: test.name,
+            data: frame.data,
+            metadata: frame.metadata,
+          });
+        });
+        await raceTimeout(cdpSession.send('Page.startScreencast', {
+          format: 'jpeg',
+          quality: config.screencastQuality || 60,
+          maxWidth: config.screencastMaxWidth || 800,
+          maxHeight: config.screencastMaxHeight || 600,
+          everyNthFrame: 1,
+        }), 5000);
+        log('📹', `${C.dim}screencast started for ${test.name} (driver=${poolDriver})${C.reset}`);
+      } catch (err) {
+        log('⚠️', `${C.amber}screencast failed for ${test.name}: ${err.message} (driver=${poolDriver})${C.reset}`);
+        cdpSession = null;
+      }
+    } else if (config.screencast && poolDriver === 'cdp') {
+      log('⚠️', `${C.amber}screencast disabled: pool driver is generic CDP (Lightpanda?), not supported${C.reset}`);
+    }
 
     page.on('console', (msg) => {
       result.consoleLogs.push({ type: msg.type(), text: msg.text() });
@@ -225,9 +335,9 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
     });
 
     // Auto-inject auth token into localStorage (runs BEFORE beforeEach hooks)
-    if (config.authToken) {
-      const storageKey = config.authStorageKey || 'accessToken';
-      await page.goto(config.baseUrl, { waitUntil: 'domcontentloaded', timeout: 15000 });
+    if (effectiveConfig.authToken) {
+      const storageKey = effectiveConfig.authStorageKey || 'accessToken';
+      await page.goto(effectiveConfig.baseUrl, { waitUntil: 'domcontentloaded', timeout: 15000 });
       await page.evaluate((key, token) => {
         localStorage.setItem(key, token);
       }, storageKey, config.authToken);
@@ -243,14 +353,14 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
 
     // Run beforeEach hook
     if (hooks.beforeEach?.length) {
-      await executeHookActions(page, hooks.beforeEach, config);
+      await executeHookActions(page, hooks.beforeEach, effectiveConfig);
     }
 
     // Auto-capture baseline screenshot if test has "expect" (BEFORE actions)
     if (test.expect && page) {
       try {
         const safeName = test.name.replace(/[^a-zA-Z0-9_\-. ]/g, '_');
-        const baselinePath = path.join(config.screenshotsDir, `baseline-${safeName}-${Date.now()}.png`);
+        const baselinePath = path.join(effectiveConfig.screenshotsDir, `baseline-${safeName}-${Date.now()}.png`);
         await page.screenshot({ path: baselinePath, fullPage: true });
         result.baselineScreenshot = baselinePath;
       } catch { /* page may not be ready */ }
@@ -258,8 +368,8 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
 
     for (let i = 0; i < test.actions.length; i++) {
       const action = test.actions[i];
-      const maxActionRetries = action.retries ?? config.actionRetries ?? 0;
-      const actionRetryDelay = config.actionRetryDelay ?? 500;
+      const maxActionRetries = action.retries ?? effectiveConfig.actionRetries ?? 0;
+      const actionRetryDelay = effectiveConfig.actionRetryDelay ?? 500;
       let lastError = null;
 
       for (let attempt = 0; attempt <= maxActionRetries; attempt++) {
@@ -273,20 +383,129 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
               throw new Error(`assert_no_network_errors failed: ${result.networkErrors.length} error(s): ${summary}`);
             }
             actionResult = null;
+
+          // ── Multi-tab actions (intercepted here, not in actions.js) ──────
+          } else if (action.type === 'open_tab') {
+            const label = action.text || `tab-${tabRegistry.size}`;
+            const newPage = await context.newPage();
+            await newPage.setViewport(config.viewport);
+            tabRegistry.set(label, newPage);
+            activeTabLabel = label;
+            page = newPage;
+            // Navigate inside the new tab
+            actionResult = await executeAction(page, action, effectiveConfig);
+
+          } else if (action.type === 'switch_tab') {
+            // value: label, title regex, URL substring, or numeric index
+            const target = action.value;
+            let found = false;
+
+            // 1. By label (exact match)
+            if (tabRegistry.has(target)) {
+              page = tabRegistry.get(target);
+              activeTabLabel = target;
+              found = true;
+            }
+
+            // 2. By numeric index
+            if (!found && /^\d+$/.test(target)) {
+              const idx = parseInt(target);
+              const labels = [...tabRegistry.keys()];
+              if (idx >= 0 && idx < labels.length) {
+                activeTabLabel = labels[idx];
+                page = tabRegistry.get(activeTabLabel);
+                found = true;
+              }
+            }
+
+            // 3. By title or URL match (substring or regex)
+            if (!found) {
+              for (const [label, p] of tabRegistry) {
+                try {
+                  const title = await p.title();
+                  const url = p.url();
+                  const regex = new RegExp(target, 'i');
+                  if (regex.test(title) || regex.test(url) || url.includes(target)) {
+                    page = p;
+                    activeTabLabel = label;
+                    found = true;
+                    break;
+                  }
+                } catch { /* page may be closed */ }
+              }
+            }
+
+            if (!found) {
+              throw new Error(`switch_tab failed: no tab matching "${target}" (labels: ${[...tabRegistry.keys()].join(', ')})`);
+            }
+            // Bring tab to front
+            await page.bringToFront();
+            actionResult = null;
+
+          } else if (action.type === 'close_tab') {
+            const targetLabel = action.value || activeTabLabel;
+            if (targetLabel === 'default' && tabRegistry.size > 1) {
+              throw new Error('close_tab: cannot close the default tab while other tabs are open');
+            }
+            const targetPage = tabRegistry.get(targetLabel);
+            if (!targetPage) {
+              throw new Error(`close_tab failed: no tab with label "${targetLabel}"`);
+            }
+            tabRegistry.delete(targetLabel);
+            if (!targetPage.isClosed()) {
+              await targetPage.close();
+            }
+            // Switch to the last remaining tab
+            if (activeTabLabel === targetLabel) {
+              const remaining = [...tabRegistry.keys()];
+              activeTabLabel = remaining[remaining.length - 1] || 'default';
+              page = tabRegistry.get(activeTabLabel);
+              if (page) await page.bringToFront();
+            }
+            actionResult = null;
+
+          } else if (action.type === 'assert_tab_count') {
+            action.__tabCount = tabRegistry.size;
+            actionResult = await executeAction(page, action, effectiveConfig);
+
+          } else if (action.type === 'wait_for_tab') {
+            // Wait for a new tab/popup to be opened (e.g. by window.open, target=_blank)
+            const label = action.text || `tab-${tabRegistry.size}`;
+            const waitTimeout = action.timeout || config.defaultTimeout || 10000;
+            const newTarget = await new Promise((resolve, reject) => {
+              const timer = setTimeout(() => reject(new Error(`wait_for_tab: no new tab appeared after ${waitTimeout}ms`)), waitTimeout);
+              context.once('targetcreated', (target) => {
+                clearTimeout(timer);
+                resolve(target);
+              });
+            });
+            const newPage = await newTarget.page();
+            if (newPage) {
+              await newPage.setViewport(config.viewport);
+              tabRegistry.set(label, newPage);
+              activeTabLabel = label;
+              page = newPage;
+            }
+            actionResult = null;
+
           } else {
-            actionResult = await executeAction(page, action, config);
+            actionResult = await executeAction(page, action, effectiveConfig);
           }
           const actionDuration = Date.now() - actionStart;
+          const autoShot = await tryAutoCaptureStep(page, action, i, test.name, effectiveConfig, !!actionResult?.screenshot);
           const actionEntry = {
             ...action,
             success: true,
             duration: actionDuration,
             result: actionResult,
           };
+          if (autoShot) actionEntry.autoScreenshot = autoShot.path;
           if (attempt > 0) actionEntry.actionRetries = attempt;
           actionEntry.narrative = narrateAction(action, actionEntry);
           result.actions.push(actionEntry);
-          progressFn({ event: 'test:action', name: test.name, action, actionIndex: i, totalActions: test.actions.length, success: true, duration: actionDuration, narrative: actionEntry.narrative, screenshotPath: actionResult?.screenshot || null });
+          progressFn({ event: 'test:action', name: test.name, action, actionIndex: i, totalActions: test.actions.length, success: true, duration: actionDuration, narrative: actionEntry.narrative, screenshotPath: actionResult?.screenshot || null, autoScreenshot: autoShot?.path || null });
+          // Stream the auto-capture as a live frame so the storyline player has something to show even when CDP screencast is silent
+          if (autoShot?.base64) progressFn({ event: 'test:frame', name: test.name, data: autoShot.base64, source: 'step' });
           lastError = null;
           break;
         } catch (error) {
@@ -297,16 +516,19 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
             continue;
           }
           const actionDuration = Date.now() - actionStart;
+          const autoShot = await tryAutoCaptureStep(page, action, i, test.name, effectiveConfig, false);
           const failedEntry = {
             ...action,
             success: false,
             duration: actionDuration,
             error: error.message,
           };
+          if (autoShot) failedEntry.autoScreenshot = autoShot.path;
           if (maxActionRetries > 0) failedEntry.actionRetries = attempt;
           failedEntry.narrative = narrateAction(action, failedEntry);
           result.actions.push(failedEntry);
-          progressFn({ event: 'test:action', name: test.name, action, actionIndex: i, totalActions: test.actions.length, success: false, duration: actionDuration, narrative: failedEntry.narrative, error: error.message });
+          progressFn({ event: 'test:action', name: test.name, action, actionIndex: i, totalActions: test.actions.length, success: false, duration: actionDuration, narrative: failedEntry.narrative, error: error.message, autoScreenshot: autoShot?.path || null });
+          if (autoShot?.base64) progressFn({ event: 'test:frame', name: test.name, data: autoShot.base64, source: 'step' });
           throw error;
         }
       }
@@ -323,15 +545,40 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
       result.expect = test.expect;
       try {
         const safeName = test.name.replace(/[^a-zA-Z0-9_\-. ]/g, '_');
-        const verifyPath = path.join(config.screenshotsDir, `verify-${safeName}-${Date.now()}.png`);
+        const verifyPath = path.join(effectiveConfig.screenshotsDir, `verify-${safeName}-${Date.now()}.png`);
         await page.screenshot({ path: verifyPath, fullPage: true });
         result.verificationScreenshot = verifyPath;
+
+        // Auto visual comparison: compare baseline vs verification screenshot
+        if (result.baselineScreenshot && result.verificationScreenshot) {
+          try {
+            const diffPath = path.join(effectiveConfig.screenshotsDir, `diff-${safeName}-${Date.now()}.png`);
+            const threshold = effectiveConfig.verificationThreshold ?? 0.02;
+            const visualResult = compareImages(result.baselineScreenshot, result.verificationScreenshot, {
+              threshold: 0.1,
+              diffOutputPath: diffPath,
+              maskRegions: test.expect?.maskRegions || [],
+            });
+            result.visualDiff = {
+              diffPercentage: visualResult.diffPercentage,
+              differentPixels: visualResult.differentPixels,
+              totalPixels: visualResult.totalPixels,
+              matchPercentage: visualResult.matchPercentage,
+              diffImagePath: visualResult.diffImagePath,
+              threshold,
+              passed: visualResult.diffPercentage <= threshold,
+            };
+            if (result.visualDiff.diffImagePath) {
+              result.diffScreenshot = result.visualDiff.diffImagePath;
+            }
+          } catch { /* visual diff is best-effort, never blocks the test */ }
+        }
       } catch { /* page may be dead */ }
     }
 
     // Run afterEach hook (success path)
     if (hooks.afterEach?.length) {
-      await executeHookActions(page, hooks.afterEach, config);
+      await executeHookActions(page, hooks.afterEach, effectiveConfig);
     }
   } catch (error) {
     result.success = false;
@@ -339,18 +586,31 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
 
     // Run afterEach hook (failure path)
     if (page && hooks.afterEach?.length) {
-      try { await executeHookActions(page, hooks.afterEach, config); } catch { /* */ }
+      try { await executeHookActions(page, hooks.afterEach, effectiveConfig); } catch { /* */ }
     }
 
     if (page) {
       try {
-        const safeName = test.name.replace(/[^a-zA-Z0-9_\-. ]/g, '_');
-        const errorScreenshot = path.join(config.screenshotsDir, `error-${safeName}-${Date.now()}.png`);
-        await page.screenshot({ path: errorScreenshot, fullPage: true });
-        result.errorScreenshot = errorScreenshot;
+        // Only capture when the page actually has something to show.
+        // about:blank / empty-DOM failures produced 5KB blank PNGs that
+        // accumulated in screenshotsDir with no debug value.
+        if (await pageHasRenderableContent(page)) {
+          const errBuf = await page.screenshot({ fullPage: true });
+          if (!looksLikeBlankCapture(errBuf, 'png')) {
+            const safeName = test.name.replace(/[^a-zA-Z0-9_\-. ]/g, '_');
+            const errorScreenshot = path.join(config.screenshotsDir, `error-${safeName}-${Date.now()}.png`);
+            fs.writeFileSync(errorScreenshot, errBuf);
+            result.errorScreenshot = errorScreenshot;
+          }
+        }
       } catch { /* page may be dead */ }
     }
   } finally {
+    // Stop screencast before disconnecting
+    if (cdpSession) {
+      try { await cdpSession.send('Page.stopScreencast'); } catch { /* */ }
+      try { await cdpSession.detach(); } catch { /* */ }
+    }
     // Flush pending response body reads before disconnecting
     if (pendingBodies.length > 0) {
       try { await Promise.allSettled(pendingBodies); } catch { /* */ }
@@ -363,12 +623,68 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
       try { await context.close(); } catch { /* */ }
     }
     if (browser) {
-      try { browser.disconnect(); } catch { /* */ }
+      try { await disconnectFromPool(browser, result.poolUrl); } catch { /* */ }
     }
     // Release local pending counter so selectPool() knows this slot is free
     if (result.poolUrl) {
       releasePending(result.poolUrl);
     }
+    // Destroy the app fork after the test completes
+    if (appFork) {
+      try { await destroyFork(appFork.forkId); } catch { /* best effort */ }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Majority voting — runs a test N times in parallel and uses majority vote for pass/fail.
+ * If majority passes but not unanimously, marks as flaky.
+ */
+async function runTestWithVoting(test, config, hooks, votingCount, testTimeout, progressFn) {
+  const votes = [];
+  const promises = [];
+
+  for (let v = 0; v < votingCount; v++) {
+    const timeoutPromise = new Promise((_, reject) => {
+      const timer = setTimeout(() => reject(new Error(`Test timed out after ${testTimeout}ms`)), testTimeout);
+      timer.unref();
+    });
+    promises.push(
+      Promise.race([runTest(test, config, hooks, progressFn), timeoutPromise])
+        .catch(error => ({
+          name: test.name,
+          startTime: new Date().toISOString(),
+          endTime: new Date().toISOString(),
+          actions: [],
+          success: false,
+          error: error.message,
+          consoleLogs: [],
+          networkErrors: [],
+          networkLogs: [],
+        }))
+    );
+  }
+
+  const results = await Promise.all(promises);
+  const passCount = results.filter(r => r.success).length;
+  const majorityPassed = passCount > votingCount / 2;
+
+  // Pick the representative result: a passing one if majority passed, failing one otherwise
+  const representative = majorityPassed
+    ? results.find(r => r.success) || results[0]
+    : results.find(r => !r.success) || results[0];
+
+  const result = { ...representative };
+  result.success = majorityPassed;
+  result.voting = { total: votingCount, passed: passCount, failed: votingCount - passCount };
+  result.attempt = 1;
+  result.maxAttempts = 1;
+
+  // Non-unanimous pass = flaky
+  if (majorityPassed && passCount < votingCount) {
+    result.flaky = true;
   }
 
   return result;
@@ -377,6 +693,7 @@ export async function runTest(test, config, hooks = {}, progressFn = () => {}) {
 /** Runs tests in parallel with limited concurrency, retries, timeouts, and hooks */
 export async function runTestsParallel(tests, config, suiteHooks = {}) {
   const hooks = mergeHooks(config.hooks, suiteHooks);
+  const driverOpts = { poolDriver: config.poolDriver || 'auto', maxSessions: config.maxSessions || 10 };
 
   // Run beforeAll hook
   if (hooks.beforeAll?.length) {
@@ -389,7 +706,7 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
     log('🪝', `${C.dim}Running beforeAll hook...${C.reset}`);
     let browser = null;
     try {
-      const hookPool = await selectPool(getPoolUrls(config));
+      const hookPool = await selectPool(getPoolUrls(config), 2000, 60000, driverOpts);
       browser = await connectToPool(hookPool, config.connectRetries, config.connectRetryDelay);
       const page = await browser.newPage();
       await page.setViewport(config.viewport);
@@ -399,7 +716,7 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
       log('❌', `${C.red}beforeAll hook failed: ${error.message}${C.reset}`);
       throw error;
     } finally {
-      if (browser) try { browser.disconnect(); } catch { /* */ }
+      if (browser) try { await disconnectFromPool(browser, hookPool); } catch { /* */ }
     }
   }
 
@@ -414,8 +731,27 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
       );
       log('✅', `${C.dim}Auth token acquired (${config.authToken.length} chars)${C.reset}`);
     } catch (error) {
-      log('❌', `${C.red}Auth auto-login failed: ${error.message}${C.reset}`);
-      throw error;
+      // Docker-internal hostname (nginx, api, etc.) → retry with localhost from host machine
+      if (error.message && error.message.includes('ENOTFOUND')) {
+        const url = new URL(config.authLoginEndpoint);
+        if (!url.hostname.includes('.')) {
+          const localhostUrl = `http://localhost${url.port && url.port !== '80' ? ':' + url.port : ''}${url.pathname}${url.search}`;
+          log('🔄', `${C.dim}Docker hostname "${url.hostname}" not reachable from host, retrying with ${localhostUrl}...${C.reset}`);
+          try {
+            config.authToken = await fetchAuthToken(localhostUrl, config.authCredentials, config.authTokenPath || 'token');
+            log('✅', `${C.dim}Auth token acquired via localhost fallback (${config.authToken.length} chars)${C.reset}`);
+          } catch (retryErr) {
+            log('❌', `${C.red}Auth auto-login failed (localhost fallback): ${retryErr.message}${C.reset}`);
+            throw retryErr;
+          }
+        } else {
+          log('❌', `${C.red}Auth auto-login failed: ${error.message}${C.reset}`);
+          throw error;
+        }
+      } else {
+        log('❌', `${C.red}Auth auto-login failed: ${error.message}${C.reset}`);
+        throw error;
+      }
     }
   }
 
@@ -446,40 +782,49 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
       log('▶▶▶', `${C.cyan}${test.name}${C.reset} ${C.dim}(${activeCount} active)${C.reset}`);
       _progress({ event: 'test:start', name: test.name, serial: test.serial || false, activeCount, queueRemaining: queue.length });
 
-      const maxAttempts = (test.retries ?? config.retries ?? 0) + 1;
       const testTimeout = test.timeout ?? config.testTimeout ?? 60000;
+      const votingCount = test.voting ?? config.voting ?? 0;
+      const testHooks = test._suiteHooks ? mergeHooks(config.hooks, test._suiteHooks) : hooks;
       let result;
 
-      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        const timeoutPromise = new Promise((_, reject) => {
-          const timer = setTimeout(() => reject(new Error(`Test timed out after ${testTimeout}ms`)), testTimeout);
-          timer.unref();
-        });
-
-        try {
-          const testHooks = test._suiteHooks ? mergeHooks(config.hooks, test._suiteHooks) : hooks;
-          result = await Promise.race([runTest(test, config, testHooks, _progress), timeoutPromise]);
-        } catch (error) {
-          result = {
-            name: test.name,
-            startTime: new Date().toISOString(),
-            endTime: new Date().toISOString(),
-            actions: [],
-            success: false,
-            error: error.message,
-            consoleLogs: [],
-            networkErrors: [],
-            networkLogs: [],
-          };
-        }
+      if (votingCount > 1) {
+        // Majority voting: run N times in parallel, majority wins
+        log('🗳️', `${C.dim}${test.name}: voting ${votingCount}x in parallel${C.reset}`);
+        result = await runTestWithVoting(test, config, testHooks, votingCount, testTimeout, _progress);
+      } else {
+        // Standard sequential retry
+        const maxAttempts = (test.retries ?? config.retries ?? 0) + 1;
+
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+          const timeoutPromise = new Promise((_, reject) => {
+            const timer = setTimeout(() => reject(new Error(`Test timed out after ${testTimeout}ms`)), testTimeout);
+            timer.unref();
+          });
+
+          try {
+            result = await Promise.race([runTest(test, config, testHooks, _progress), timeoutPromise]);
+          } catch (error) {
+            result = {
+              name: test.name,
+              startTime: new Date().toISOString(),
+              endTime: new Date().toISOString(),
+              actions: [],
+              success: false,
+              error: error.message,
+              consoleLogs: [],
+              networkErrors: [],
+              networkLogs: [],
+            };
+          }
 
-        result.attempt = attempt;
-        result.maxAttempts = maxAttempts;
+          result.attempt = attempt;
+          result.maxAttempts = maxAttempts;
 
-        if (result.success || attempt === maxAttempts) break;
-        log('🔄', `${C.yellow}${test.name}${C.reset} failed, retrying (${attempt}/${maxAttempts})...`);
-        _progress({ event: 'test:retry', name: test.name, attempt, maxAttempts });
-        await sleep(config.retryDelay || 1000);
+          if (result.success || attempt === maxAttempts) break;
+          log('🔄', `${C.yellow}${test.name}${C.reset} failed, retrying (${attempt}/${maxAttempts})...`);
+          _progress({ event: 'test:retry', name: test.name, attempt, maxAttempts });
+          await sleep(config.retryDelay || 1000);
+        }
       }
 
       results.push(result);
@@ -489,11 +834,13 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
       _progress({ event: 'test:complete', name: test.name, success: result.success, duration: timeDiff(result.startTime, result.endTime), error: result.error, consoleLogs: result.consoleLogs, networkErrors: result.networkErrors, networkLogs: result.networkLogs, errorScreenshot: result.errorScreenshot, screenshots, poolUrl: result.poolUrl || null });
 
       if (result.success) {
-        const flaky = result.attempt > 1 ? ` ${C.yellow}(flaky, passed on attempt ${result.attempt}/${result.maxAttempts})${C.reset}` : '';
-        log('✅', `${C.green}${test.name}${C.reset} ${C.dim}(${timeDiff(result.startTime, result.endTime)})${C.reset}${flaky}`);
+        const votingInfo = result.voting ? ` ${C.yellow}(voting: ${result.voting.passed}/${result.voting.total} passed${result.flaky ? ', flaky' : ''})${C.reset}` : '';
+        const retryInfo = !result.voting && result.attempt > 1 ? ` ${C.yellow}(flaky, passed on attempt ${result.attempt}/${result.maxAttempts})${C.reset}` : '';
+        log('✅', `${C.green}${test.name}${C.reset} ${C.dim}(${timeDiff(result.startTime, result.endTime)})${C.reset}${votingInfo}${retryInfo}`);
       } else {
-        const attempts = result.maxAttempts > 1 ? ` (${result.maxAttempts} attempts)` : '';
-        log('❌', `${C.red}${test.name}${C.reset}: ${result.error}${attempts}`);
+        const votingInfo = result.voting ? ` (voting: ${result.voting.passed}/${result.voting.total} passed)` : '';
+        const attempts = !result.voting && result.maxAttempts > 1 ? ` (${result.maxAttempts} attempts)` : '';
+        log('❌', `${C.red}${test.name}${C.reset}: ${result.error}${votingInfo}${attempts}`);
       }
 
       const consoleIssues = result.consoleLogs?.filter(l => l.type === 'error' || l.type === 'warning').length || 0;
@@ -524,7 +871,7 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
     log('🪝', `${C.dim}Running afterAll hook...${C.reset}`);
     let browser = null;
     try {
-      const hookPool = await selectPool(getPoolUrls(config));
+      const hookPool = await selectPool(getPoolUrls(config), 2000, 60000, driverOpts);
       browser = await connectToPool(hookPool, config.connectRetries, config.connectRetryDelay);
       const page = await browser.newPage();
       await page.setViewport(config.viewport);
@@ -533,7 +880,7 @@ export async function runTestsParallel(tests, config, suiteHooks = {}) {
     } catch (error) {
       log('⚠️', `${C.yellow}afterAll hook failed: ${error.message}${C.reset}`);
     } finally {
-      if (browser) try { browser.disconnect(); } catch { /* */ }
+      if (browser) try { await disconnectFromPool(browser, hookPool); } catch { /* */ }
     }
   }