perf(visual): run visual-diff LLM calls concurrently instead of serially

[JonasJesus42]

Problem

In runVisualRegression (src/checks/visual-regression.ts), the finalize loop called await visualSemanticDiff(...) inline, one page at a time:

for (const p of prepared) {
  ...
  } else if (llmTargets.has(p)) {
    const diffs = await visualSemanticDiff({ ... }); // serial
  }
}

Each visualSemanticDiff is a multimodal LLM request carrying 2-3 large screenshots and takes several seconds. The LLM client already exposes a concurrency semaphore (MAX_CONCURRENT_LLM_CALLS = 3), but awaiting each call before starting the next meant only one ever ran at a time — the allowed parallelism was wasted. On a run with several non-cached pages this serialization was a large chunk of the visual-diff phase wall-clock.

Fix

Fire the LLM calls concurrently up front with Promise.all, store the outcomes in a Map<PreparedPair, ...>, then read them in the (still-sequential) finalize loop:

• Result ordering, cache writes (setCacheEntry), counters (llmCallsUsed/pagesFromCache), and issue ordering all stay deterministic — only the network calls overlap.
• Real parallelism (and thus peak transient memory from the base64 image payloads) remains bounded by the existing semaphore, so this does not reintroduce the OOM pressure the earlier PRs (fix(run): reuse discovery browser instead of leaking it (#167) #173–perf(run): gate Playwright tracing behind PARITY_TRACE=1 #176) addressed.

Visual-diff phase wall-clock drops by up to ~3× on runs with several uncached pages.

Verification

• bun run check (tsc) passes.
• bunx vitest run — full suite: 995 tests passing (incl. tests/checks/visual-regression.test.ts 18 tests and tests/llm/visual-semantic-diff.test.ts), which cover the LLM path, cache path, ordering, and counters.

Performance follow-up to the memory-pressure series (#173, #174, #175, #176).

🤖 Generated with Claude Code

---

Summary by cubic

Run visual-diff LLM calls concurrently using Promise.all to reduce wall-clock time by up to ~3× on uncached pages, while keeping finalize order, cache writes, and counters deterministic.

• Performance
  • Kick off eligible visualSemanticDiff calls in parallel and store outcomes in a Map for sequential finalize.
  • Concurrency stays bounded by the existing semaphore (MAX_CONCURRENT_LLM_CALLS), avoiding OOM and preserving deterministic result and issue ordering.

^{Written for commit 4f5994e. Summary will update on new commits.}