browsecraft-runner 0.3.0 → 0.4.0

package/dist/index.cjs

@@ -183,6 +183,807 @@ var TestRunner = class {
   }
 };
 
+// src/event-bus.ts
+var EventBus = class {
+  listeners = /* @__PURE__ */ new Map();
+  history = [];
+  _recordHistory = false;
+  // -----------------------------------------------------------------------
+  // Subscription
+  // -----------------------------------------------------------------------
+  /**
+   * Register a listener for an event.
+   * Returns an unsubscribe function for easy cleanup.
+   */
+  on(event, listener) {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+      if (set.size === 0) this.listeners.delete(event);
+    };
+  }
+  /**
+   * Register a one-time listener. Automatically removed after first call.
+   */
+  once(event, listener) {
+    const unsubscribe = this.on(event, ((payload) => {
+      unsubscribe();
+      listener(payload);
+    }));
+    return unsubscribe;
+  }
+  /**
+   * Remove all listeners for a specific event, or all events.
+   */
+  off(event) {
+    if (event) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.clear();
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Emission
+  // -----------------------------------------------------------------------
+  /**
+   * Emit an event synchronously to all registered listeners.
+   */
+  emit(event, payload) {
+    if (this._recordHistory) {
+      this.history.push({ event, payload, timestamp: Date.now() });
+    }
+    const set = this.listeners.get(event);
+    if (!set) return;
+    for (const listener of set) {
+      try {
+        listener(payload);
+      } catch {
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Introspection
+  // -----------------------------------------------------------------------
+  /**
+   * Get the number of listeners for a specific event, or all events.
+   */
+  listenerCount(event) {
+    if (event) {
+      return this.listeners.get(event)?.size ?? 0;
+    }
+    let total = 0;
+    for (const set of this.listeners.values()) {
+      total += set.size;
+    }
+    return total;
+  }
+  /**
+   * Get the names of all events that have listeners.
+   */
+  eventNames() {
+    return Array.from(this.listeners.keys());
+  }
+  // -----------------------------------------------------------------------
+  // History (for debugging / test assertions)
+  // -----------------------------------------------------------------------
+  /**
+   * Enable event history recording. Useful for tests and debugging.
+   */
+  enableHistory() {
+    this._recordHistory = true;
+  }
+  /**
+   * Disable event history recording and clear existing history.
+   */
+  disableHistory() {
+    this._recordHistory = false;
+    this.history = [];
+  }
+  /**
+   * Get recorded events. Only available when history is enabled.
+   */
+  getHistory() {
+    return this.history;
+  }
+  /**
+   * Get events of a specific type from history.
+   */
+  getEventsOfType(event) {
+    return this.history.filter((h) => h.event === event).map((h) => ({ payload: h.payload, timestamp: h.timestamp }));
+  }
+  /**
+   * Clear all history without disabling recording.
+   */
+  clearHistory() {
+    this.history = [];
+  }
+};
+
+// src/worker-pool.ts
+var DEFAULT_POOL_CONFIG = {
+  browsers: { chrome: 1 },
+  maxRetries: 0,
+  bail: false,
+  spawnTimeout: 3e4
+};
+var WorkerPool = class {
+  bus;
+  config;
+  workers = [];
+  bailed = false;
+  constructor(bus, config) {
+    this.bus = bus;
+    this.config = { ...DEFAULT_POOL_CONFIG, ...config };
+  }
+  // -----------------------------------------------------------------------
+  // Pool info
+  // -----------------------------------------------------------------------
+  /** Get a snapshot of all workers */
+  getWorkers() {
+    return this.workers;
+  }
+  /** Get workers for a specific browser */
+  getWorkersForBrowser(browser) {
+    return this.workers.filter((w) => w.info.browser === browser);
+  }
+  /** Get idle workers */
+  getIdleWorkers() {
+    return this.workers.filter((w) => w.state === "idle");
+  }
+  /** Total number of workers across all browsers */
+  get size() {
+    return this.workers.length;
+  }
+  /** Number of distinct browser types */
+  get browserCount() {
+    return new Set(this.workers.map((w) => w.info.browser)).size;
+  }
+  /** Get browser names in the pool */
+  get browserNames() {
+    return [...new Set(this.workers.map((w) => w.info.browser))];
+  }
+  // -----------------------------------------------------------------------
+  // Spawn
+  // -----------------------------------------------------------------------
+  /**
+   * Create all workers and spawn their browser instances.
+   * Workers are created based on the browsers config.
+   */
+  async spawn(spawner) {
+    const entries = Object.entries(this.config.browsers);
+    for (const [browser, count] of entries) {
+      for (let i = 0; i < count; i++) {
+        const info = {
+          id: `${browser}-${i}`,
+          browser,
+          index: i
+        };
+        this.workers.push({
+          info,
+          state: "starting",
+          currentItem: null,
+          completedCount: 0,
+          spawnedAt: Date.now(),
+          cleanup: null
+        });
+        this.bus.emit("worker:spawn", info);
+      }
+    }
+    const spawnPromises = this.workers.map(async (worker) => {
+      try {
+        const result = await this.withTimeout(
+          spawner(worker.info),
+          this.config.spawnTimeout,
+          `Worker ${worker.info.id} spawn timed out after ${this.config.spawnTimeout}ms`
+        );
+        worker.cleanup = result.close;
+        worker.state = "idle";
+        this.bus.emit("worker:ready", worker.info);
+      } catch (err) {
+        worker.state = "error";
+        const error = err instanceof Error ? err : new Error(String(err));
+        this.bus.emit("worker:error", { worker: worker.info, error });
+        throw error;
+      }
+    });
+    await Promise.all(spawnPromises);
+  }
+  // -----------------------------------------------------------------------
+  // Execute
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a list of work items across all available workers.
+   * Items are distributed using shortest-queue / round-robin.
+   * Returns all results.
+   */
+  async execute(items, executor) {
+    if (items.length === 0) return [];
+    const results = [];
+    const queue = [...items];
+    const activeWorkers = this.workers.filter((w) => w.state === "idle");
+    if (activeWorkers.length === 0) {
+      throw new Error("No active workers available. Did you call spawn() first?");
+    }
+    for (const item of items) {
+      this.bus.emit("item:enqueue", item);
+    }
+    const workerPromises = activeWorkers.map(
+      (worker) => this.workerLoop(worker, queue, results, executor)
+    );
+    await Promise.all(workerPromises);
+    return results;
+  }
+  /**
+   * Execute items only on workers for a specific browser.
+   * Used for sequential browser-by-browser execution.
+   */
+  async executeOnBrowser(browser, items, executor) {
+    if (items.length === 0) return [];
+    const results = [];
+    const queue = [...items];
+    const browserWorkers = this.workers.filter(
+      (w) => w.info.browser === browser && w.state === "idle"
+    );
+    if (browserWorkers.length === 0) {
+      throw new Error(`No active workers for browser: ${browser}`);
+    }
+    for (const item of items) {
+      this.bus.emit("item:enqueue", item);
+    }
+    const workerPromises = browserWorkers.map(
+      (worker) => this.workerLoop(worker, queue, results, executor)
+    );
+    await Promise.all(workerPromises);
+    return results;
+  }
+  // -----------------------------------------------------------------------
+  // Worker loop
+  // -----------------------------------------------------------------------
+  /**
+   * Each worker runs this loop: pull from queue → execute → repeat.
+   * This is the work-stealing pattern — workers pull items themselves.
+   */
+  async workerLoop(worker, queue, results, executor) {
+    while (queue.length > 0 && !this.bailed) {
+      const item = queue.shift();
+      if (!item) break;
+      worker.state = "busy";
+      worker.currentItem = item;
+      this.bus.emit("worker:busy", { worker: worker.info, item });
+      this.bus.emit("item:start", { item, worker: worker.info });
+      let finalResult;
+      try {
+        const execResult = await executor(item, worker.info);
+        finalResult = {
+          item,
+          worker: worker.info,
+          status: execResult.status,
+          duration: execResult.duration,
+          error: execResult.error
+        };
+        if (execResult.status === "failed" && this.config.maxRetries > 0) {
+          let attempt = 1;
+          while (attempt <= this.config.maxRetries && finalResult.status === "failed") {
+            this.bus.emit("item:retry", {
+              item,
+              worker: worker.info,
+              attempt,
+              maxRetries: this.config.maxRetries
+            });
+            const retryResult = await executor(item, worker.info);
+            finalResult = {
+              item,
+              worker: worker.info,
+              status: retryResult.status,
+              duration: retryResult.duration,
+              error: retryResult.error,
+              retries: attempt
+            };
+            attempt++;
+          }
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        finalResult = {
+          item,
+          worker: worker.info,
+          status: "failed",
+          duration: 0,
+          error
+        };
+      }
+      results.push(finalResult);
+      worker.completedCount++;
+      worker.currentItem = null;
+      worker.state = "idle";
+      switch (finalResult.status) {
+        case "passed":
+          this.bus.emit("item:pass", finalResult);
+          break;
+        case "failed":
+          this.bus.emit("item:fail", finalResult);
+          break;
+        case "skipped":
+          this.bus.emit("item:skip", finalResult);
+          break;
+      }
+      this.bus.emit("item:end", finalResult);
+      this.bus.emit("worker:idle", worker.info);
+      if (finalResult.status === "failed" && this.config.bail) {
+        this.bailed = true;
+        break;
+      }
+    }
+  }
+  // -----------------------------------------------------------------------
+  // Terminate
+  // -----------------------------------------------------------------------
+  /**
+   * Gracefully terminate all workers and close their browsers.
+   */
+  async terminate() {
+    const closePromises = this.workers.map(async (worker) => {
+      if (worker.cleanup) {
+        try {
+          await worker.cleanup();
+        } catch {
+        }
+      }
+      worker.state = "terminated";
+      worker.cleanup = null;
+      this.bus.emit("worker:terminate", worker.info);
+    });
+    await Promise.all(closePromises);
+  }
+  /**
+   * Reset the pool — clear all workers and state. Used between runs.
+   */
+  reset() {
+    this.workers.length = 0;
+    this.bailed = false;
+  }
+  // -----------------------------------------------------------------------
+  // Utilities
+  // -----------------------------------------------------------------------
+  withTimeout(promise, ms, message) {
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => reject(new Error(message)), ms);
+      promise.then((value) => {
+        clearTimeout(timer);
+        resolve2(value);
+      }).catch((err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+    });
+  }
+};
+
+// src/scheduler.ts
+var DEFAULT_SCHEDULER_CONFIG = {
+  strategy: "matrix"
+};
+var Scheduler = class {
+  bus;
+  pool;
+  config;
+  constructor(bus, pool, config) {
+    this.bus = bus;
+    this.pool = pool;
+    this.config = { ...DEFAULT_SCHEDULER_CONFIG, ...config };
+  }
+  // -----------------------------------------------------------------------
+  // Run
+  // -----------------------------------------------------------------------
+  /**
+   * Execute work items according to the configured strategy.
+   */
+  async run(items, executor) {
+    const startTime = Date.now();
+    const browsers = this.pool.browserNames;
+    const filteredItems = this.applyFilters(items);
+    this.bus.emit("run:start", {
+      browsers,
+      totalItems: filteredItems.length,
+      workers: this.pool.size
+    });
+    let allResults;
+    switch (this.config.strategy) {
+      case "parallel":
+        allResults = await this.runParallel(filteredItems, executor, browsers);
+        break;
+      case "sequential":
+        allResults = await this.runSequential(filteredItems, executor, browsers);
+        break;
+      case "matrix":
+        allResults = await this.runMatrix(filteredItems, executor, browsers);
+        break;
+      default:
+        throw new Error(`Unknown execution strategy: ${this.config.strategy}`);
+    }
+    const totalDuration = Date.now() - startTime;
+    const schedulerResult = this.buildResult(allResults, browsers, totalDuration);
+    this.bus.emit("run:end", {
+      duration: totalDuration,
+      results: allResults
+    });
+    return schedulerResult;
+  }
+  // -----------------------------------------------------------------------
+  // Strategies
+  // -----------------------------------------------------------------------
+  /**
+   * PARALLEL: All workers across all browsers pull from a single shared queue.
+   * Scenarios are distributed across all available workers.
+   * A scenario may run on any browser — depends on which worker picks it up.
+   */
+  async runParallel(items, executor, browsers) {
+    for (const browser of browsers) {
+      const workerCount = this.pool.getWorkersForBrowser(browser).length;
+      this.bus.emit("browser:start", {
+        browser,
+        workerCount,
+        itemCount: items.length
+      });
+    }
+    const results = await this.pool.execute(items, executor);
+    for (const browser of browsers) {
+      const browserResults = results.filter((r) => r.worker.browser === browser);
+      this.bus.emit("browser:end", {
+        browser,
+        passed: browserResults.filter((r) => r.status === "passed").length,
+        failed: browserResults.filter((r) => r.status === "failed").length,
+        skipped: browserResults.filter((r) => r.status === "skipped").length,
+        duration: browserResults.reduce((sum, r) => sum + r.duration, 0)
+      });
+    }
+    return results;
+  }
+  /**
+   * SEQUENTIAL: One browser at a time. Each browser gets the full scenario set.
+   * Useful for isolated browser runs or resource-constrained environments.
+   */
+  async runSequential(items, executor, browsers) {
+    const allResults = [];
+    for (const browser of browsers) {
+      const workerCount = this.pool.getWorkersForBrowser(browser).length;
+      this.bus.emit("browser:start", {
+        browser,
+        workerCount,
+        itemCount: items.length
+      });
+      const browserStart = Date.now();
+      const results = await this.pool.executeOnBrowser(browser, items, executor);
+      allResults.push(...results);
+      this.bus.emit("browser:end", {
+        browser,
+        passed: results.filter((r) => r.status === "passed").length,
+        failed: results.filter((r) => r.status === "failed").length,
+        skipped: results.filter((r) => r.status === "skipped").length,
+        duration: Date.now() - browserStart
+      });
+    }
+    return allResults;
+  }
+  /**
+   * MATRIX: Every scenario runs on every browser.
+   * Total executions = scenarios × browsers.
+   * Within each browser, scenarios run in parallel across that browser's workers.
+   *
+   * This is the gold standard for cross-browser testing — guarantees
+   * every scenario is validated on every browser.
+   */
+  async runMatrix(items, executor, browsers) {
+    if (browsers.length <= 1) {
+      return this.runParallel(items, executor, browsers);
+    }
+    const browserPromises = browsers.map(async (browser) => {
+      const workerCount = this.pool.getWorkersForBrowser(browser).length;
+      this.bus.emit("browser:start", {
+        browser,
+        workerCount,
+        itemCount: items.length
+      });
+      const browserItems = items.map((item) => ({ ...item }));
+      const browserStart = Date.now();
+      const results = await this.pool.executeOnBrowser(browser, browserItems, executor);
+      this.bus.emit("browser:end", {
+        browser,
+        passed: results.filter((r) => r.status === "passed").length,
+        failed: results.filter((r) => r.status === "failed").length,
+        skipped: results.filter((r) => r.status === "skipped").length,
+        duration: Date.now() - browserStart
+      });
+      return results;
+    });
+    const browserResultSets = await Promise.all(browserPromises);
+    return browserResultSets.flat();
+  }
+  // -----------------------------------------------------------------------
+  // Filtering
+  // -----------------------------------------------------------------------
+  /**
+   * Apply grep and tag filters to work items.
+   */
+  applyFilters(items) {
+    let filtered = items;
+    if (this.config.grep) {
+      const pattern = this.config.grep;
+      filtered = filtered.filter((item) => item.title.includes(pattern));
+    }
+    if (this.config.tagFilter) {
+      const tagExpr = this.config.tagFilter.toLowerCase();
+      filtered = filtered.filter((item) => {
+        if (!item.tags || item.tags.length === 0) return false;
+        const itemTags = item.tags.map((t) => t.toLowerCase());
+        return this.matchTagExpression(itemTags, tagExpr);
+      });
+    }
+    return filtered;
+  }
+  /**
+   * Simple tag expression matcher.
+   * Supports: @tag, @tag1 and @tag2, @tag1 or @tag2, not @tag
+   */
+  matchTagExpression(tags, expression) {
+    if (expression.includes(" and ")) {
+      return expression.split(" and ").every((part) => this.matchTagExpression(tags, part.trim()));
+    }
+    if (expression.includes(" or ")) {
+      return expression.split(" or ").some((part) => this.matchTagExpression(tags, part.trim()));
+    }
+    if (expression.startsWith("not ")) {
+      return !this.matchTagExpression(tags, expression.slice(4).trim());
+    }
+    const tag = expression.startsWith("@") ? expression : `@${expression}`;
+    return tags.includes(tag);
+  }
+  // -----------------------------------------------------------------------
+  // Result building
+  // -----------------------------------------------------------------------
+  /**
+   * Build the final SchedulerResult from collected results.
+   */
+  buildResult(allResults, browsers, totalDuration) {
+    const browserResults = browsers.map((browser) => {
+      const results = allResults.filter((r) => r.worker.browser === browser);
+      return {
+        browser,
+        results,
+        passed: results.filter((r) => r.status === "passed").length,
+        failed: results.filter((r) => r.status === "failed").length,
+        skipped: results.filter((r) => r.status === "skipped").length,
+        duration: results.reduce((sum, r) => sum + r.duration, 0)
+      };
+    });
+    return {
+      browsers: browserResults,
+      allResults,
+      totalPassed: allResults.filter((r) => r.status === "passed").length,
+      totalFailed: allResults.filter((r) => r.status === "failed").length,
+      totalSkipped: allResults.filter((r) => r.status === "skipped").length,
+      totalDuration,
+      strategy: this.config.strategy
+    };
+  }
+};
+
+// src/result-aggregator.ts
+var ResultAggregator = class {
+  /**
+   * Aggregate a SchedulerResult into a complete summary.
+   */
+  aggregate(result) {
+    const { allResults, browsers: browserResults, strategy, totalDuration } = result;
+    const matrix = this.buildMatrix(
+      allResults,
+      browserResults.map((b) => b.browser)
+    );
+    const browserSummaries = browserResults.map((b) => ({
+      browser: b.browser,
+      passed: b.passed,
+      failed: b.failed,
+      skipped: b.skipped,
+      duration: b.duration
+    }));
+    const uniqueScenarios = new Set(allResults.map((r) => r.item.id));
+    const flaky = matrix.filter((r) => r.flaky);
+    const inconsistent = matrix.filter((r) => r.crossBrowserInconsistent);
+    const totals = {
+      scenarios: uniqueScenarios.size,
+      passed: result.totalPassed,
+      failed: result.totalFailed,
+      skipped: result.totalSkipped,
+      flaky: flaky.length,
+      crossBrowserInconsistent: inconsistent.length
+    };
+    const allDurations = allResults.filter((r) => r.status !== "skipped").map((r) => r.duration);
+    const timing = this.computeTimingStats(allDurations);
+    const flakyTests = flaky.map((r) => r.title);
+    const inconsistentTests = inconsistent.map((r) => r.title);
+    const slowestTests = [...allResults].filter((r) => r.status !== "skipped").sort((a, b) => b.duration - a.duration).slice(0, 5).map((r) => ({
+      title: r.item.title,
+      duration: r.duration,
+      browser: r.worker.browser
+    }));
+    const failedTests = allResults.filter((r) => r.status === "failed").map((r) => ({
+      title: r.item.title,
+      error: r.error?.message,
+      browser: r.worker.browser
+    }));
+    return {
+      matrix,
+      browserSummaries,
+      totals,
+      timing,
+      strategy,
+      totalDuration,
+      browsers: browserResults.map((b) => b.browser),
+      flakyTests,
+      inconsistentTests,
+      slowestTests,
+      failedTests
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Matrix building
+  // -----------------------------------------------------------------------
+  /**
+   * Build the scenario × browser matrix.
+   */
+  buildMatrix(results, browsers) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      const existing = byId.get(result.item.id) ?? [];
+      existing.push(result);
+      byId.set(result.item.id, existing);
+    }
+    const rows = [];
+    for (const [id, itemResults] of byId) {
+      const firstResult = itemResults[0];
+      const browserMap = /* @__PURE__ */ new Map();
+      for (const browser of browsers) {
+        const browserResult = itemResults.find((r) => r.worker.browser === browser);
+        if (browserResult) {
+          browserMap.set(browser, {
+            status: browserResult.status,
+            duration: browserResult.duration,
+            error: browserResult.error,
+            retries: browserResult.retries
+          });
+        } else {
+          browserMap.set(browser, {
+            status: "not-run",
+            duration: 0
+          });
+        }
+      }
+      const statuses = new Set(
+        [...browserMap.values()].filter((c) => c.status !== "not-run").map((c) => c.status)
+      );
+      const crossBrowserInconsistent = statuses.size > 1;
+      const flaky = itemResults.some(
+        (r) => r.retries !== void 0 && r.retries > 0 && r.status === "passed"
+      );
+      rows.push({
+        id,
+        title: firstResult.item.title,
+        file: firstResult.item.file,
+        suitePath: firstResult.item.suitePath,
+        browsers: browserMap,
+        crossBrowserInconsistent,
+        flaky
+      });
+    }
+    return rows;
+  }
+  // -----------------------------------------------------------------------
+  // Timing statistics
+  // -----------------------------------------------------------------------
+  /**
+   * Compute timing statistics from an array of durations.
+   */
+  computeTimingStats(durations) {
+    if (durations.length === 0) {
+      return { min: 0, max: 0, avg: 0, median: 0, p95: 0, total: 0 };
+    }
+    const sorted = [...durations].sort((a, b) => a - b);
+    const total = sorted.reduce((sum, d) => sum + d, 0);
+    return {
+      min: sorted[0],
+      max: sorted[sorted.length - 1],
+      avg: Math.round(total / sorted.length),
+      median: sorted[Math.floor(sorted.length / 2)],
+      p95: sorted[Math.floor(sorted.length * 0.95)],
+      total
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Formatting helpers (for CLI console output)
+  // -----------------------------------------------------------------------
+  /**
+   * Format the matrix as a console-friendly table string.
+   */
+  formatMatrix(summary) {
+    const lines = [];
+    const { browsers, matrix } = summary;
+    const browserHeaders = browsers.map((b) => b.padEnd(10)).join(" ");
+    lines.push(`
+  ${"Scenario".padEnd(40)} ${browserHeaders}`);
+    lines.push(`  ${"\u2500".repeat(40)} ${"\u2500".repeat(browsers.length * 11)}`);
+    for (const row of matrix) {
+      const title = row.title.length > 38 ? `${row.title.slice(0, 35)}...` : row.title;
+      const cells = browsers.map((browser) => {
+        const cell = row.browsers.get(browser);
+        if (!cell || cell.status === "not-run") return "  -     ".padEnd(10);
+        const icon = cell.status === "passed" ? "\x1B[32m\u2713\x1B[0m" : cell.status === "failed" ? "\x1B[31m\u2717\x1B[0m" : "\x1B[33m-\x1B[0m";
+        const time = cell.duration < 1e3 ? `${cell.duration}ms` : `${(cell.duration / 1e3).toFixed(1)}s`;
+        return `${icon} ${time}`.padEnd(10);
+      });
+      const flag = row.flaky ? " \u{1F504}" : row.crossBrowserInconsistent ? " \u26A0\uFE0F" : "";
+      lines.push(`  ${title.padEnd(40)} ${cells.join(" ")}${flag}`);
+    }
+    lines.push("");
+    lines.push("  Legend: \u2713 passed  \u2717 failed  - skipped  \u{1F504} flaky  \u26A0\uFE0F  inconsistent");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Format a concise summary string for console output.
+   */
+  formatSummary(summary) {
+    const lines = [];
+    const { totals, timing, browsers, totalDuration, strategy } = summary;
+    lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    lines.push(`  Strategy: ${strategy} | Browsers: ${browsers.join(", ")}`);
+    lines.push("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    for (const bs of summary.browserSummaries) {
+      const parts = [];
+      if (bs.passed > 0) parts.push(`\x1B[32m${bs.passed} \u2713\x1B[0m`);
+      if (bs.failed > 0) parts.push(`\x1B[31m${bs.failed} \u2717\x1B[0m`);
+      if (bs.skipped > 0) parts.push(`\x1B[33m${bs.skipped} -\x1B[0m`);
+      lines.push(
+        `  ${bs.browser.padEnd(10)} ${parts.join("  ")}  (${this.formatDuration(bs.duration)})`
+      );
+    }
+    lines.push("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    const totalParts = [];
+    if (totals.passed > 0) totalParts.push(`\x1B[32m${totals.passed} passed\x1B[0m`);
+    if (totals.failed > 0) totalParts.push(`\x1B[31m${totals.failed} failed\x1B[0m`);
+    if (totals.skipped > 0) totalParts.push(`\x1B[33m${totals.skipped} skipped\x1B[0m`);
+    lines.push(`  Total:    ${totalParts.join(", ")} (${totals.scenarios} scenarios)`);
+    if (totals.flaky > 0) {
+      lines.push(`  Flaky:    \x1B[33m${totals.flaky} tests\x1B[0m`);
+    }
+    if (totals.crossBrowserInconsistent > 0) {
+      lines.push(`  \u26A0\uFE0F  Cross-browser inconsistencies: ${totals.crossBrowserInconsistent}`);
+    }
+    lines.push(
+      `  Timing:   avg ${this.formatDuration(timing.avg)} \xB7 p95 ${this.formatDuration(timing.p95)} \xB7 max ${this.formatDuration(timing.max)}`
+    );
+    lines.push(`  Duration: ${this.formatDuration(totalDuration)}`);
+    lines.push("  \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550");
+    lines.push("");
+    return lines.join("\n");
+  }
+  formatDuration(ms) {
+    if (ms < 1e3) return `${ms}ms`;
+    if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 6e4);
+    const seconds = (ms % 6e4 / 1e3).toFixed(1);
+    return `${minutes}m ${seconds}s`;
+  }
+};
+
+exports.EventBus = EventBus;
+exports.ResultAggregator = ResultAggregator;
+exports.Scheduler = Scheduler;
 exports.TestRunner = TestRunner;
+exports.WorkerPool = WorkerPool;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map