@@ -121,7 +121,10 @@ jobs:
           lfs: true
       - uses: ./.github/actions/setup-ci
       - name: Run Lighthouse tests
-        run: WIREIT_FAILURES=kill pnpm run lighthouse && node ./projects/internals/ci/cache-validate.js lighthouse && node ./projects/internals/ci/metrics.lighthouse.js
+        run: >-
+          WIREIT_FAILURES=kill mise exec -- pnpm run lighthouse
+          && mise exec -- node ./projects/internals/ci/cache-validate.js lighthouse
+          && mise exec -- node ./projects/internals/ci/metrics.lighthouse.js
       - name: Write lighthouse job summary
         if: always()
         run: node ./projects/internals/ci/lighthouse-summary.js >> "$GITHUB_STEP_SUMMARY"
 
@@ -4,7 +4,7 @@
   "release": {
     "extends": "../../release.config.js"
   },
-  "description": "The Design Language for AI/ML Factories Building at the Speed of Light. Provides a set of accessible and themeable UI elements.",
+  "description": "The UI SDK and agent-ready developer toolkit for AI factories, robotics, and autonomous vehicles. Provides a set of accessible and themeable UI components.",
   "keywords": [
     "nvidia",
     "web-components",
 
@@ -7,6 +7,7 @@ export default mergeConfig(libraryLighthouseTestConfig, {
     alias: { '@nvidia-elements/core': resolve(import.meta.dirname, './dist') }
   },
   test: {
+    maxWorkers: 4,
     include: ['src/**/*.test.lighthouse.ts'],
     outputFile: {
       junit: './coverage/lighthouse/junit.xml'
 
@@ -1,4 +1,5 @@
 import { hideExpectedTestConsoleMessage } from './console.js';
+import { LIGHTHOUSE_WORKERS } from '../runners/lighthouse-workers.js';
 
 /** @type {import('vite').UserConfig} */
 export const libraryLighthouseTestConfig = {
@@ -10,8 +11,8 @@ export const libraryLighthouseTestConfig = {
   test: {
     retry: 2,
     isolate: false,
-    maxWorkers: 1,
-    fileParallelism: false,
+    maxWorkers: LIGHTHOUSE_WORKERS,
+    fileParallelism: LIGHTHOUSE_WORKERS > 1,
     onConsoleLog: hideExpectedTestConsoleMessage,
     reporters: [
       'default',
 
@@ -2,6 +2,8 @@ import { exec } from 'node:child_process';
 import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
 import { resolve } from 'path';
 import * as lockFile from 'proper-lockfile';
+import { performance } from 'node:perf_hooks';
+import { recordPhase } from '../runners/profile.js';
 
 /**
  * creates a lockfile to force parallel playwright runners to execute one at a time, example:
@@ -22,13 +24,16 @@ if (!existsSync(lockPath)) {
   writeFileSync(lockPath, '');
 }
 
+const waitStart = performance.now();
 const timerId = setInterval(() => {
   lockFile
     .lock(lockPath, {
       stale: 300000 // 5 minutes
     })
     .then(async release => {
       clearInterval(timerId);
+      recordPhase('browser-lock-wait', waitStart, { lockName });
+      const heldStart = performance.now();
       await new Promise(r => {
         exec(cmd, (error, stdout, stderr) => {
           console.log(stdout);
@@ -45,6 +50,7 @@ const timerId = setInterval(() => {
           r();
         });
       });
+      recordPhase('browser-lock-held', heldStart, { lockName });
       return release();
     })
     .catch(_ => {});
 
@@ -0,0 +1,7 @@
+import { globSync } from 'node:fs';
+
+export const MAX_LIGHTHOUSE_WORKERS = 4;
+
+// Keep audits bounded while Wireit builds other projects. Single-file suites
+// use one browser because their tests still execute sequentially.
+export const LIGHTHOUSE_WORKERS = Math.max(1, Math.min(3, globSync('src/**/*.test.lighthouse.ts').length));
@@ -3,13 +3,15 @@ import fs from 'fs';
 import { resolve } from 'path';
 import { VitePlaywrightRunner, buildPage } from './playwright.js';
 import { withSoftwareWebGPUChromiumArgs } from './utils.js';
+import { profilePhase } from './profile.js';
+import { LIGHTHOUSE_WORKERS, MAX_LIGHTHOUSE_WORKERS } from './lighthouse-workers.js';
 
 const output = process.env.CI ? ['json'] : ['json', 'html'];
 const RUNNER_ID = 'lighthouse';
 const LIGHTHOUSE_FLAGS = { logLevel: 'error', output };
 const CHROMIUM_ARGS = withSoftwareWebGPUChromiumArgs([
   '--headless',
-  '--remote-debugging-port=9222',
+  '--remote-debugging-port=0',
   '--disable-dev-shm-usage',
   '--disable-extensions',
   '--disable-background-networking',
@@ -38,27 +40,78 @@ const LIGHTHOUSE_CONFIG = {
 
 export class LighthouseRunner {
   #runner;
+  #pool = [];
+  #chromiumArgs;
 
   constructor({ chromiumArgs = CHROMIUM_ARGS } = {}) {
-    this.#runner = new VitePlaywrightRunner({ runnerID: RUNNER_ID, chromiumArgs });
+    this.#chromiumArgs = chromiumArgs;
+    this.#runner = new VitePlaywrightRunner({
+      runnerID: RUNNER_ID,
+      instanceID: process.env.VITEST_POOL_ID ?? '1',
+      chromiumArgs
+    });
   }
 
-  async open() {
-    await this.#runner.open();
+  async open({ workers = LIGHTHOUSE_WORKERS } = {}) {
+    if (!Number.isInteger(workers) || workers < 1 || workers > MAX_LIGHTHOUSE_WORKERS) {
+      throw new Error(`Lighthouse requires between 1 and ${MAX_LIGHTHOUSE_WORKERS} workers`);
+    }
+    // Global setup owns the browsers. Each Vitest worker reads only its own ports.
+    // The project-wide browser lock bounds machine-wide audit concurrency.
+    this.#pool = Array.from(
+      { length: workers },
+      (_, index) =>
+        new VitePlaywrightRunner({
+          runnerID: RUNNER_ID,
+          instanceID: String(index + 1),
+          chromiumArgs: this.#chromiumArgs
+        })
+    );
+    try {
+      for (const runner of this.#pool) {
+        await profilePhase('browser-server-setup', () => runner.open());
+      }
+    } catch (error) {
+      try {
+        await this.close();
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], 'Lighthouse setup and cleanup failed');
+      }
+      throw error;
+    }
   }
 
   async close() {
-    await this.#runner.close();
+    const results = await Promise.allSettled(
+      this.#pool.map(runner => profilePhase('report-collection-cleanup', () => runner.close()))
+    );
+    this.#pool = [];
+    const failures = results.filter(result => result.status === 'rejected').map(result => result.reason);
+    if (failures.length) throw new AggregateError(failures, 'Failed to close Lighthouse browsers');
   }
 
   async getReport(name, content) {
     console.log('lighthouse-runner: building test page...');
-    await buildPage(name, RUNNER_ID, t => t.replace('</body>', `${content}</body>`));
+    await profilePhase(
+      'fixture-build',
+      () => buildPage(name, RUNNER_ID, t => t.replace('</body>', `${content}</body>`)),
+      { name }
+    );
     console.log('lighthouse-runner: running tests...');
-    const runnerResult = await lighthouse(
-      `http://localhost:${this.#runner.port}/${name}/index.html`,
-      LIGHTHOUSE_FLAGS,
-      LIGHTHOUSE_CONFIG
+    const runnerResult = await profilePhase(
+      'lighthouse-execution',
+      () =>
+        lighthouse(
+          `http://localhost:${this.#runner.port}/${name}/index.html`,
+          { ...LIGHTHOUSE_FLAGS, port: this.#runner.debuggingPort },
+          LIGHTHOUSE_CONFIG
+        ),
+      {
+        name,
+        worker: process.env.VITEST_POOL_ID ?? '1',
+        port: this.#runner.port,
+        debuggingPort: this.#runner.debuggingPort
+      }
     );
 
     const networkRequests = runnerResult.lhr.audits['network-requests']?.details?.items;
@@ -83,7 +136,11 @@ export class LighthouseRunner {
     }
 
     console.log('lighthouse-runner: writing test report...');
-    fs.writeFileSync(`${dist}/report.json`, JSON.stringify(report, null, 2));
+    await profilePhase(
+      'report-write',
+      async () => fs.writeFileSync(`${dist}/report.json`, JSON.stringify(report, null, 2)),
+      { name }
+    );
     console.log(`lighthouse-runner: test report written to ${dist}/report.json`);
     return report;
   }
 
@@ -19,10 +19,12 @@ export class VitePlaywrightRunner {
   #server;
   /** @type {import('playwright').Browser} */
   #browser;
+  #browserServer;
   /** @type {import('playwright').LaunchOptions} */
   #chromiumArgs;
   /** @type {string} */
   #runnerID;
+  #instanceID;
 
   get page() {
     return this.#page;
@@ -45,7 +47,13 @@ export class VitePlaywrightRunner {
   }
 
   get #portFile() {
-    return `.${this.#runnerID}/port`;
+    return `.${this.#runnerID}/port${this.#instanceID ? `-${this.#instanceID}` : ''}`;
+  }
+
+  get debuggingPort() {
+    const port = Number(fs.readFileSync(`${this.#portFile}-debugging`, 'utf8').trim());
+    if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error('Invalid Chromium debugging port');
+    return port;
   }
 
   get #serverPort() {
@@ -64,6 +72,7 @@ export class VitePlaywrightRunner {
 
   constructor(config = {}) {
     this.#runnerID = config.runnerID ?? 'playwright';
+    this.#instanceID = config.instanceID;
     this.#chromiumArgs = config.chromiumArgs ?? [
       '--headless',
       '--disable-dev-shm-usage',
@@ -97,13 +106,25 @@ export class VitePlaywrightRunner {
       }
 
       console.log('playwright-runner: launching browser');
-      this.#browser = await chromium.launch({ args: this.#chromiumArgs }).catch(error => {
-        console.error('playwright-runner: error launching browser', error);
-        throw error;
-      });
+      // Chromium reserves the debugging port itself, avoiding a free-port race.
+      if (this.#chromiumArgs.includes('--remote-debugging-port=0')) {
+        this.#browserServer = await chromium.launchServer({
+          args: this.#chromiumArgs
+        });
+        this.#browser = await chromium.connect(this.#browserServer.wsEndpoint());
+        const args = this.#browserServer.process().spawnargs;
+        const userDataDir = args.find(arg => arg.startsWith('--user-data-dir='))?.slice('--user-data-dir='.length);
+        if (!userDataDir) throw new Error('Chromium did not expose its isolated profile directory');
+        const port = fs.readFileSync(path.join(userDataDir, 'DevToolsActivePort'), 'utf8').split('\n')[0];
+        fs.writeFileSync(`${this.#portFile}-debugging`, port);
+      } else {
+        this.#browser = await chromium.launch({ args: this.#chromiumArgs });
+      }
       console.log('playwright-runner: creating context');
       this.#page = await (
-        await this.#browser.newContext({ viewport: { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT } })
+        await this.#browser.newContext({
+          viewport: { width: VIEWPORT_WIDTH, height: VIEWPORT_HEIGHT }
+        })
       ).newPage();
       this.#page.on('crash', data => console.error('playwright-runner: browser crashed', data));
       console.log('playwright-runner: creating server');
@@ -117,21 +138,43 @@ export class VitePlaywrightRunner {
   }
 
   async close() {
-    const report = collectReports(this.#root);
-
-    fs.writeFileSync(`${this.#dist}/report.json`, JSON.stringify(report, null, 2));
-    await this.#page.close();
-    await this.#browser.close();
-    await this.#server.close();
+    const failures = [];
+    try {
+      if (fs.existsSync(this.#dist)) {
+        const report = collectReports(this.#root);
+        fs.writeFileSync(`${this.#dist}/report.json`, JSON.stringify(report, null, 2));
+      }
+    } catch (error) {
+      failures.push(error);
+    }
+    for (const close of [
+      () => this.#page?.close(),
+      () => this.#browser?.close(),
+      () => this.#browserServer?.close(),
+      () => this.#server?.close()
+    ]) {
+      try {
+        await close();
+      } catch (error) {
+        failures.push(error);
+      }
+    }
+    this.#page = undefined;
+    this.#browser = undefined;
+    this.#browserServer = undefined;
+    this.#server = undefined;
+    if (failures.length) throw new AggregateError(failures, 'Failed to close Playwright runner');
   }
 }
 
 /** Collects individual runner reports without re-reading the aggregate report. */
 export function collectReports(root) {
-  return globSync(path.resolve(root, 'dist/*/report.json')).reduce((reports, reportPath) => {
-    const report = JSON.parse(fs.readFileSync(reportPath));
-    return { ...reports, [report.name]: report };
-  }, {});
+  return globSync(path.resolve(root, 'dist/*/report.json'))
+    .sort()
+    .reduce((reports, reportPath) => {
+      const report = JSON.parse(fs.readFileSync(reportPath));
+      return { ...reports, [report.name]: report };
+    }, {});
 }
 
 /**
 
@@ -0,0 +1,29 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+
+/** Records optional runner timings outside cached test outputs. */
+export function recordPhase(phase, start, details = {}) {
+  const directory = process.env.LIGHTHOUSE_PROFILE_DIR;
+  if (!directory) return;
+  mkdirSync(directory, { recursive: true });
+  appendFileSync(
+    path.join(directory, `${process.pid}.jsonl`),
+    `${JSON.stringify({
+      project: process.cwd(),
+      phase,
+      startTime: performance.timeOrigin + start,
+      durationMs: performance.now() - start,
+      ...details
+    })}\n`
+  );
+}
+
+export async function profilePhase(phase, operation, details) {
+  const start = performance.now();
+  try {
+    return await operation();
+  } finally {
+    recordPhase(phase, start, details);
+  }
+}