apex-auditor 0.2.9 → 0.3.3

package/dist/lighthouse-runner.js

@@ -1,11 +1,311 @@
+import { mkdtemp, rm, mkdir, readFile, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
+import { cpus, freemem, tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import lighthouse from "lighthouse";
 import { launch as launchChrome } from "chrome-launcher";
+const CACHE_VERSION = 1;
+const CACHE_DIR = ".apex-auditor";
+const CACHE_FILE = "cache.json";
+const DEFAULT_WORKER_TASK_TIMEOUT_MS = 5 * 60 * 1000;
+const WORKER_RESPONSE_TIMEOUT_GRACE_MS = 15 * 1000;
+const MAX_PARENT_TASK_ATTEMPTS = 5;
+const MAX_PARENT_BACKOFF_MS = 3000;
+let lastProgressLine;
+function logLinePreservingProgress(message) {
+    if (typeof process === "undefined" || !process.stdout || typeof process.stdout.write !== "function" || process.stdout.isTTY !== true) {
+        // eslint-disable-next-line no-console
+        console.warn(message);
+        return;
+    }
+    if (lastProgressLine !== undefined) {
+        const clear = " ".repeat(lastProgressLine.length);
+        process.stdout.write(`\r${clear}\r`);
+    }
+    process.stdout.write(`${message}\n`);
+    if (lastProgressLine !== undefined) {
+        process.stdout.write(`\r${lastProgressLine}`);
+    }
+}
+function buildFailureSummary(task, errorMessage) {
+    return {
+        url: task.url,
+        path: task.path,
+        label: task.label,
+        device: task.device,
+        scores: {},
+        metrics: {},
+        opportunities: [],
+        runtimeErrorMessage: errorMessage,
+    };
+}
+async function withTimeout(promise, timeoutMs) {
+    const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`ApexAuditor timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    return Promise.race([promise, timeoutPromise]);
+}
+function stableStringify(value) {
+    return JSON.stringify(value);
+}
+function computeParentRetryDelayMs(params) {
+    const base = 200;
+    const expFactor = Math.min(4, params.attempt);
+    const candidate = base * Math.pow(2, expFactor);
+    const jitter = Math.floor(Math.random() * 200);
+    return Math.min(MAX_PARENT_BACKOFF_MS, candidate + jitter);
+}
+function buildCacheKey(params) {
+    const onlyCategories = params.onlyCategories ?? [];
+    return stableStringify({
+        buildId: params.buildId,
+        url: params.url,
+        path: params.path,
+        label: params.label,
+        device: params.device,
+        runs: params.runs,
+        throttlingMethod: params.throttlingMethod,
+        cpuSlowdownMultiplier: params.cpuSlowdownMultiplier,
+        onlyCategories,
+    });
+}
+async function loadIncrementalCache() {
+    const cachePath = resolve(CACHE_DIR, CACHE_FILE);
+    try {
+        const raw = await readFile(cachePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return undefined;
+        }
+        const maybe = parsed;
+        if (maybe.version !== CACHE_VERSION || !maybe.entries || typeof maybe.entries !== "object") {
+            return undefined;
+        }
+        return { version: CACHE_VERSION, entries: maybe.entries };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function saveIncrementalCache(cache) {
+    await mkdir(resolve(CACHE_DIR), { recursive: true });
+    const cachePath = resolve(CACHE_DIR, CACHE_FILE);
+    await writeFile(cachePath, JSON.stringify(cache, null, 2), "utf8");
+}
+function resolveWorkerEntryUrl() {
+    const jsEntry = new URL("./lighthouse-worker.js", import.meta.url);
+    const tsEntry = new URL("./lighthouse-worker.ts", import.meta.url);
+    const isSourceRun = import.meta.url.endsWith(".ts");
+    return { entry: isSourceRun ? tsEntry : jsEntry, useTsx: isSourceRun };
+}
+function spawnWorker() {
+    const resolved = resolveWorkerEntryUrl();
+    const entryPath = fileURLToPath(resolved.entry);
+    const args = resolved.useTsx ? ["--import", "tsx", entryPath] : [entryPath];
+    return spawn(process.execPath, args, { stdio: ["pipe", "pipe", "pipe", "ipc"] });
+}
+async function runParallelInProcesses(tasks, parallelCount, auditTimeoutMs, signal, updateProgress) {
+    const effectiveParallel = Math.min(parallelCount, tasks.length);
+    const workers = [];
+    for (let i = 0; i < effectiveParallel; i += 1) {
+        if (i > 0) {
+            await delayMs(200 * i);
+        }
+        workers.push({ child: spawnWorker(), busy: false });
+    }
+    const results = new Array(tasks.length);
+    const pending = [];
+    for (let taskIndex = 0; taskIndex < tasks.length; taskIndex += 1) {
+        for (let runIndex = 0; runIndex < tasks[taskIndex].runs; runIndex += 1) {
+            pending.push({ taskIndex, runIndex, attempts: 0 });
+        }
+    }
+    const summariesByTask = tasks.map(() => []);
+    const inFlight = new Map();
+    const waiters = new Map();
+    const attachListeners = (child) => {
+        child.on("message", (raw) => {
+            const msg = raw && typeof raw === "object" ? raw : undefined;
+            if (!msg || typeof msg.id !== "string") {
+                return;
+            }
+            const waiter = waiters.get(msg.id);
+            if (!waiter) {
+                return;
+            }
+            waiters.delete(msg.id);
+            waiter.resolve(msg);
+        });
+        child.on("error", (error) => {
+            for (const [id, waiter] of waiters) {
+                waiter.reject(error);
+                waiters.delete(id);
+            }
+        });
+        child.on("exit", () => {
+            for (const [id, waiter] of waiters) {
+                waiter.reject(new Error("Worker exited"));
+                waiters.delete(id);
+            }
+        });
+        child.on("disconnect", () => {
+            for (const [id, waiter] of waiters) {
+                waiter.reject(new Error("Worker disconnected"));
+                waiters.delete(id);
+            }
+        });
+    };
+    for (const worker of workers) {
+        attachListeners(worker.child);
+    }
+    let consecutiveRetries = 0;
+    const runOnWorker = async (workerIndex, taskIndex) => {
+        const worker = workers[workerIndex];
+        if (signal?.aborted) {
+            return;
+        }
+        const next = pending.shift();
+        if (!next) {
+            return;
+        }
+        const task = tasks[next.taskIndex];
+        const id = `${workerIndex}-${next.taskIndex}-${next.runIndex}-${Date.now()}`;
+        const workerTask = {
+            url: task.url,
+            path: task.path,
+            label: task.label,
+            device: task.device,
+            logLevel: task.logLevel,
+            throttlingMethod: task.throttlingMethod,
+            cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+            timeoutMs: auditTimeoutMs,
+            onlyCategories: task.onlyCategories,
+        };
+        worker.busy = true;
+        worker.inFlightId = id;
+        worker.inFlightTaskIndex = next.taskIndex;
+        inFlight.set(id, next);
+        const responseTimeoutMs = auditTimeoutMs + WORKER_RESPONSE_TIMEOUT_GRACE_MS;
+        const response = await new Promise((resolve, reject) => {
+            const timeoutHandle = setTimeout(() => {
+                waiters.delete(id);
+                reject(new Error(`Worker response timeout after ${responseTimeoutMs}ms`));
+            }, responseTimeoutMs);
+            const abortListener = () => {
+                clearTimeout(timeoutHandle);
+                waiters.delete(id);
+                reject(new Error("Aborted"));
+            };
+            signal?.addEventListener("abort", abortListener, { once: true });
+            waiters.set(id, {
+                resolve: (msg) => {
+                    clearTimeout(timeoutHandle);
+                    signal?.removeEventListener("abort", abortListener);
+                    resolve(msg);
+                },
+                reject: (err) => {
+                    clearTimeout(timeoutHandle);
+                    signal?.removeEventListener("abort", abortListener);
+                    reject(err);
+                },
+            });
+            const request = { type: "run", id, task: workerTask };
+            try {
+                worker.child.send(request);
+            }
+            catch (error) {
+                clearTimeout(timeoutHandle);
+                waiters.delete(id);
+                reject(error instanceof Error ? error : new Error("Worker send failed"));
+            }
+        }).catch((error) => {
+            return { type: "error", id, errorMessage: error instanceof Error ? error.message : "Worker failure" };
+        });
+        const flight = inFlight.get(id);
+        inFlight.delete(id);
+        worker.busy = false;
+        worker.inFlightId = undefined;
+        worker.inFlightTaskIndex = undefined;
+        if (response.type === "error") {
+            const isTimeout = response.errorMessage.includes("timeout") || response.errorMessage.includes("Timeout") || response.errorMessage.includes("ApexAuditor timeout");
+            const prefix = isTimeout ? "Timeout" : "Worker error";
+            logLinePreservingProgress(`${prefix}: ${task.path} [${task.device}] (run ${next.runIndex + 1}/${task.runs}). Retrying... (${response.errorMessage})`);
+            const retryItem = flight
+                ? { taskIndex: flight.taskIndex, runIndex: flight.runIndex, attempts: next.attempts + 1 }
+                : { taskIndex: next.taskIndex, runIndex: next.runIndex, attempts: next.attempts + 1 };
+            if (retryItem.attempts >= MAX_PARENT_TASK_ATTEMPTS) {
+                logLinePreservingProgress(`Giving up: ${task.path} [${task.device}] (run ${next.runIndex + 1}/${task.runs}) after ${retryItem.attempts} attempts.`);
+                summariesByTask[next.taskIndex].push(buildFailureSummary(task, response.errorMessage));
+                updateProgress(task.path, task.device);
+                if (summariesByTask[next.taskIndex].length === task.runs) {
+                    results[next.taskIndex] = aggregateSummaries(summariesByTask[next.taskIndex]);
+                }
+            }
+            else {
+                pending.unshift(retryItem);
+            }
+            consecutiveRetries += 1;
+            try {
+                worker.child.kill();
+            }
+            catch {
+                return;
+            }
+            const replacement = spawnWorker();
+            await delayMs(computeParentRetryDelayMs({ attempt: retryItem.attempts }));
+            attachListeners(replacement);
+            workers[workerIndex] = { child: replacement, busy: false };
+            return;
+        }
+        consecutiveRetries = 0;
+        summariesByTask[next.taskIndex].push(response.result);
+        updateProgress(task.path, task.device);
+        if (summariesByTask[next.taskIndex].length === task.runs) {
+            results[next.taskIndex] = aggregateSummaries(summariesByTask[next.taskIndex]);
+        }
+    };
+    try {
+        while (pending.length > 0) {
+            if (signal?.aborted) {
+                throw new Error("Aborted");
+            }
+            if (consecutiveRetries >= 2) {
+                logLinePreservingProgress(`Cooling down after ${consecutiveRetries} retry attempts; pausing briefly before resuming...`);
+                await delayMs(computeParentRetryDelayMs({ attempt: consecutiveRetries }));
+                consecutiveRetries = 0;
+            }
+            const idle = workers.map((w, idx) => (w.busy ? -1 : idx)).filter((idx) => idx >= 0);
+            if (idle.length === 0) {
+                await delayMs(50);
+                continue;
+            }
+            await Promise.all(idle.map(async (workerIndex) => {
+                await runOnWorker(workerIndex, workerIndex);
+            }));
+        }
+    }
+    finally {
+        for (const worker of workers) {
+            try {
+                worker.child.kill();
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return results;
+}
 async function createChromeSession(chromePort) {
     if (typeof chromePort === "number") {
         return { port: chromePort };
     }
+    const userDataDir = await mkdtemp(join(tmpdir(), "apex-auditor-chrome-"));
     const chrome = await launchChrome({
         chromeFlags: [
             "--headless=new",
@@ -16,6 +316,7 @@ async function createChromeSession(chromePort) {
             "--disable-default-apps",
             "--no-first-run",
             "--no-default-browser-check",
+            `--user-data-dir=${userDataDir}`,
             // Additional flags for more consistent and accurate results
             "--disable-background-networking",
             "--disable-background-timer-throttling",
@@ -35,6 +336,7 @@ async function createChromeSession(chromePort) {
         close: async () => {
             try {
                 await chrome.kill();
+                await rm(userDataDir, { recursive: true, force: true });
             }
             catch {
                 return;
@@ -79,16 +381,23 @@ async function performWarmUp(config) {
         const url = buildUrl({ baseUrl: config.baseUrl, path: page.path, query: config.query });
         uniqueUrls.add(url);
     }
-    // Make parallel warm-up requests to all unique URLs
-    const warmUpPromises = Array.from(uniqueUrls).map(async (url) => {
-        try {
-            await fetchUrl(url);
-        }
-        catch {
-            // Ignore warm-up errors, the actual audit will catch real issues
+    const urls = Array.from(uniqueUrls);
+    const warmUpConcurrency = Math.max(1, Math.min(4, config.parallel ?? 4));
+    const warmUpNextIndex = { value: 0 };
+    const warmWorker = async () => {
+        while (warmUpNextIndex.value < urls.length) {
+            const index = warmUpNextIndex.value;
+            warmUpNextIndex.value += 1;
+            const url = urls[index];
+            try {
+                await fetchUrl(url);
+            }
+            catch {
+                // Ignore warm-up errors, the actual audit will catch real issues
+            }
         }
-    });
-    await Promise.all(warmUpPromises);
+    };
+    await Promise.all(new Array(warmUpConcurrency).fill(0).map(async () => warmWorker()));
     // eslint-disable-next-line no-console
     console.log(`Warm-up complete (${uniqueUrls.size} pages).`);
 }
@@ -112,9 +421,11 @@ async function fetchUrl(url) {
 /**
  * Run audits for all pages defined in the config and return a structured summary.
  */
-export async function runAuditsForConfig({ config, configPath, }) {
-    const runs = config.runs ?? 1;
-    const parallelCount = config.parallel ?? 1;
+export async function runAuditsForConfig({ config, configPath, showParallel, onlyCategories, signal, onAfterWarmUp, onProgress, }) {
+    const runs = 1;
+    if (config.runs !== undefined && config.runs !== 1) {
+        throw new Error("Multi-run mode is no longer supported. Set runs=1 and rerun the command multiple times for comparisons.");
+    }
     const firstPage = config.pages[0];
     const healthCheckUrl = buildUrl({ baseUrl: config.baseUrl, path: firstPage.path, query: config.query });
     await ensureUrlReachable(healthCheckUrl);
@@ -122,9 +433,16 @@ export async function runAuditsForConfig({ config, configPath, }) {
     if (config.warmUp) {
         await performWarmUp(config);
     }
+    if (typeof onAfterWarmUp === "function") {
+        onAfterWarmUp();
+    }
     const throttlingMethod = config.throttlingMethod ?? "simulate";
     const cpuSlowdownMultiplier = config.cpuSlowdownMultiplier ?? 4;
     const logLevel = config.logLevel ?? "error";
+    const auditTimeoutMs = config.auditTimeoutMs ?? DEFAULT_WORKER_TASK_TIMEOUT_MS;
+    const incrementalEnabled = config.incremental === true && typeof config.buildId === "string" && config.buildId.length > 0;
+    const cache = incrementalEnabled ? await loadIncrementalCache() : undefined;
+    const cacheEntries = cache?.entries ?? {};
     // Build list of all audit tasks
     const tasks = [];
     for (const page of config.pages) {
@@ -139,44 +457,171 @@ export async function runAuditsForConfig({ config, configPath, }) {
                 logLevel,
                 throttlingMethod,
                 cpuSlowdownMultiplier,
+                onlyCategories,
+            });
+        }
+    }
+    const results = new Array(tasks.length);
+    const tasksToRun = [];
+    const taskIndexByRunIndex = [];
+    let cachedSteps = 0;
+    let cachedCombos = 0;
+    if (incrementalEnabled) {
+        for (let i = 0; i < tasks.length; i += 1) {
+            const task = tasks[i];
+            const key = buildCacheKey({
+                buildId: config.buildId,
+                url: task.url,
+                path: task.path,
+                label: task.label,
+                device: task.device,
+                runs: task.runs,
+                throttlingMethod: task.throttlingMethod,
+                cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                onlyCategories: task.onlyCategories,
             });
+            const cached = cacheEntries[key];
+            if (cached) {
+                results[i] = cached;
+                cachedSteps += task.runs;
+                cachedCombos += 1;
+            }
+            else {
+                taskIndexByRunIndex.push(i);
+                tasksToRun.push(task);
+            }
         }
     }
+    else {
+        for (let i = 0; i < tasks.length; i += 1) {
+            taskIndexByRunIndex.push(i);
+            tasksToRun.push(tasks[i]);
+        }
+    }
+    const startedAtMs = Date.now();
+    const parallelCount = resolveParallelCount({ requested: config.parallel, chromePort: config.chromePort, taskCount: tasksToRun.length });
+    if (showParallel === true) {
+        // eslint-disable-next-line no-console
+        console.log(`Resolved parallel workers: ${parallelCount}`);
+    }
     const totalSteps = tasks.length * runs;
-    let completedSteps = 0;
-    const progressLock = { count: 0 };
+    const executedCombos = tasksToRun.length;
+    const executedSteps = executedCombos * runs;
+    const cachedComboCount = cachedCombos;
+    let completedSteps = cachedSteps;
+    const progressLock = { count: cachedSteps };
     const updateProgress = (path, device) => {
         progressLock.count += 1;
         completedSteps = progressLock.count;
-        logProgress({ completed: completedSteps, total: totalSteps, path, device });
+        const etaMs = computeEtaMs({ startedAtMs, completed: completedSteps, total: totalSteps });
+        logProgress({ completed: completedSteps, total: totalSteps, path, device, etaMs });
+        if (typeof onProgress === "function") {
+            onProgress({ completed: completedSteps, total: totalSteps, path, device, etaMs });
+        }
     };
-    let results;
-    if (parallelCount <= 1 || config.chromePort !== undefined) {
+    let resultsFromRunner;
+    if (tasksToRun.length === 0) {
+        resultsFromRunner = [];
+    }
+    else if (parallelCount <= 1 || config.chromePort !== undefined) {
         // Sequential execution (original behavior) or using external Chrome
-        results = await runSequential(tasks, config.chromePort, updateProgress);
+        resultsFromRunner = await runSequential(tasksToRun, config.chromePort, auditTimeoutMs, signal, updateProgress);
     }
     else {
-        // Parallel execution with multiple Chrome instances
-        results = await runParallel(tasks, parallelCount, updateProgress);
+        resultsFromRunner = await runParallelInProcesses(tasksToRun, parallelCount, auditTimeoutMs, signal, updateProgress);
     }
-    return { configPath, results };
+    for (let runIndex = 0; runIndex < resultsFromRunner.length; runIndex += 1) {
+        const originalTaskIndex = taskIndexByRunIndex[runIndex];
+        results[originalTaskIndex] = resultsFromRunner[runIndex];
+    }
+    if (incrementalEnabled) {
+        const nextEntries = { ...cacheEntries };
+        for (let i = 0; i < tasks.length; i += 1) {
+            const task = tasks[i];
+            const key = buildCacheKey({
+                buildId: config.buildId,
+                url: task.url,
+                path: task.path,
+                label: task.label,
+                device: task.device,
+                runs: task.runs,
+                throttlingMethod: task.throttlingMethod,
+                cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                onlyCategories: task.onlyCategories,
+            });
+            nextEntries[key] = results[i];
+        }
+        await saveIncrementalCache({ version: CACHE_VERSION, entries: nextEntries });
+    }
+    const completedAtMs = Date.now();
+    const elapsedMs = completedAtMs - startedAtMs;
+    const averageStepMs = totalSteps > 0 ? elapsedMs / totalSteps : 0;
+    return {
+        meta: {
+            configPath,
+            buildId: typeof config.buildId === "string" ? config.buildId : undefined,
+            incremental: incrementalEnabled,
+            resolvedParallel: parallelCount,
+            totalSteps,
+            comboCount: tasks.length,
+            executedCombos,
+            cachedCombos: cachedComboCount,
+            runsPerCombo: runs,
+            executedSteps,
+            cachedSteps,
+            warmUp: config.warmUp === true,
+            throttlingMethod,
+            cpuSlowdownMultiplier,
+            startedAt: new Date(startedAtMs).toISOString(),
+            completedAt: new Date(completedAtMs).toISOString(),
+            elapsedMs,
+            averageStepMs,
+        },
+        results,
+    };
 }
-async function runSequential(tasks, chromePort, updateProgress) {
+async function runSequential(tasks, chromePort, auditTimeoutMs, signal, updateProgress) {
     const results = [];
-    const session = await createChromeSession(chromePort);
+    const sessionRef = { session: await createChromeSession(chromePort) };
     try {
         for (const task of tasks) {
             const summaries = [];
             for (let index = 0; index < task.runs; index += 1) {
-                const summary = await runSingleAudit({
+                if (signal?.aborted) {
+                    throw new Error("Aborted");
+                }
+                const summary = await withTimeout(runSingleAudit({
                     url: task.url,
                     path: task.path,
                     label: task.label,
                     device: task.device,
-                    port: session.port,
+                    port: sessionRef.session.port,
                     logLevel: task.logLevel,
                     throttlingMethod: task.throttlingMethod,
                     cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                    onlyCategories: task.onlyCategories,
+                }), auditTimeoutMs).catch(async (error) => {
+                    const message = error instanceof Error ? error.message : "Unknown error";
+                    logLinePreservingProgress(`Timeout: ${task.path} [${task.device}] (run ${index + 1}/${task.runs}). Retrying... (${message})`);
+                    if (sessionRef.session.close) {
+                        await sessionRef.session.close();
+                    }
+                    sessionRef.session = await createChromeSession(chromePort);
+                    return withTimeout(runSingleAudit({
+                        url: task.url,
+                        path: task.path,
+                        label: task.label,
+                        device: task.device,
+                        port: sessionRef.session.port,
+                        logLevel: task.logLevel,
+                        throttlingMethod: task.throttlingMethod,
+                        cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                        onlyCategories: task.onlyCategories,
+                    }), auditTimeoutMs).catch((secondError) => {
+                        const secondMessage = secondError instanceof Error ? secondError.message : "Unknown error";
+                        logLinePreservingProgress(`Giving up: ${task.path} [${task.device}] (run ${index + 1}/${task.runs}) after timeout retry.`);
+                        return buildFailureSummary(task, secondMessage);
+                    });
                 });
                 summaries.push(summary);
                 updateProgress(task.path, task.device);
@@ -185,8 +630,8 @@ async function runSequential(tasks, chromePort, updateProgress) {
         }
     }
     finally {
-        if (session.close) {
-            await session.close();
+        if (sessionRef.session.close) {
+            await sessionRef.session.close();
         }
     }
     return results;
@@ -196,26 +641,25 @@ async function runParallel(tasks, parallelCount, updateProgress) {
     const sessions = [];
     const effectiveParallel = Math.min(parallelCount, tasks.length);
     for (let i = 0; i < effectiveParallel; i += 1) {
-        sessions.push(await createChromeSession());
+        if (i > 0) {
+            await delayMs(200 * i);
+        }
+        sessions.push({ session: await createChromeSession() });
     }
     const results = new Array(tasks.length);
     let taskIndex = 0;
-    const runWorker = async (session, workerIndex) => {
+    const runWorker = async (sessionRef, workerIndex) => {
         while (taskIndex < tasks.length) {
             const currentIndex = taskIndex;
             taskIndex += 1;
             const task = tasks[currentIndex];
             const summaries = [];
             for (let run = 0; run < task.runs; run += 1) {
-                const summary = await runSingleAudit({
-                    url: task.url,
-                    path: task.path,
-                    label: task.label,
-                    device: task.device,
-                    port: session.port,
-                    logLevel: task.logLevel,
-                    throttlingMethod: task.throttlingMethod,
-                    cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                const summary = await runSingleAuditWithRetry({
+                    task,
+                    sessionRef,
+                    updateProgress,
+                    maxRetries: 2,
                 });
                 summaries.push(summary);
                 updateProgress(task.path, task.device);
@@ -224,32 +668,79 @@ async function runParallel(tasks, parallelCount, updateProgress) {
         }
     };
     try {
-        await Promise.all(sessions.map((session, index) => runWorker(session, index)));
+        await Promise.all(sessions.map((sessionRef, index) => runWorker(sessionRef, index)));
     }
     finally {
         // Close all Chrome sessions
-        await Promise.all(sessions.map(async (session) => {
-            if (session.close) {
-                await session.close();
+        await Promise.all(sessions.map(async (sessionRef) => {
+            if (sessionRef.session.close) {
+                await sessionRef.session.close();
             }
         }));
     }
     return results;
 }
+function isTransientLighthouseError(error) {
+    const message = error instanceof Error && typeof error.message === "string" ? error.message : "";
+    return (message.includes("performance mark has not been set") ||
+        message.includes("TargetCloseError") ||
+        message.includes("Target closed") ||
+        message.includes("setAutoAttach") ||
+        message.includes("LanternError") ||
+        message.includes("top level events") ||
+        message.includes("CDP") ||
+        message.includes("disconnected"));
+}
+async function runSingleAuditWithRetry({ task, sessionRef, updateProgress, maxRetries, }) {
+    let attempt = 0;
+    let lastError;
+    while (attempt <= maxRetries) {
+        try {
+            return await runSingleAudit({
+                url: task.url,
+                path: task.path,
+                label: task.label,
+                device: task.device,
+                port: sessionRef.session.port,
+                logLevel: task.logLevel,
+                throttlingMethod: task.throttlingMethod,
+                cpuSlowdownMultiplier: task.cpuSlowdownMultiplier,
+                onlyCategories: task.onlyCategories,
+            });
+        }
+        catch (error) {
+            lastError = error;
+            const shouldRetry = isTransientLighthouseError(error) && attempt < maxRetries;
+            if (!shouldRetry) {
+                throw error instanceof Error ? error : new Error("Lighthouse failed");
+            }
+            if (sessionRef.session.close) {
+                await sessionRef.session.close();
+            }
+            await delayMs(300 * (attempt + 1));
+            sessionRef.session = await createChromeSession();
+            attempt += 1;
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error("Lighthouse failed after retries");
+}
 function buildUrl({ baseUrl, path, query }) {
     const cleanBase = baseUrl.replace(/\/$/, "");
     const cleanPath = path.startsWith("/") ? path : `/${path}`;
     const queryPart = query && query.length > 0 ? query : "";
     return `${cleanBase}${cleanPath}${queryPart}`;
 }
-function logProgress({ completed, total, path, device, }) {
+function logProgress({ completed, total, path, device, etaMs, }) {
     const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
-    const message = `Running audits ${completed}/${total} (${percentage}%) – ${path} [${device}]`;
+    const etaText = etaMs !== undefined ? ` | ETA ${formatEta(etaMs)}` : "";
+    const message = `Running audits ${completed}/${total} (${percentage}%) – ${path} [${device}]${etaText}`;
     if (typeof process !== "undefined" && process.stdout && typeof process.stdout.write === "function" && process.stdout.isTTY) {
-        const padded = message.padEnd(80, " ");
+        const padded = message.padEnd(100, " ");
+        lastProgressLine = padded;
         process.stdout.write(`\r${padded}`);
         if (completed === total) {
             process.stdout.write("\n");
+            lastProgressLine = undefined;
         }
         return;
     }
@@ -263,22 +754,21 @@ async function runSingleAudit(params) {
         logLevel: params.logLevel,
         onlyCategories: ["performance", "accessibility", "best-practices", "seo"],
         formFactor: params.device,
-        // Throttling configuration for more accurate results
         throttlingMethod: params.throttlingMethod,
-        throttling: {
-            // CPU throttling - adjustable via config
+        screenEmulation: params.device === "mobile"
+            ? { mobile: true, width: 412, height: 823, deviceScaleFactor: 1.75, disabled: false }
+            : { mobile: false, width: 1350, height: 940, deviceScaleFactor: 1, disabled: false },
+    };
+    if (params.throttlingMethod === "simulate") {
+        options.throttling = {
             cpuSlowdownMultiplier: params.cpuSlowdownMultiplier,
-            // Network throttling (Slow 4G / Fast 3G preset - Lighthouse default)
             rttMs: 150,
             throughputKbps: 1638.4,
             requestLatencyMs: 150 * 3.75,
             downloadThroughputKbps: 1638.4,
             uploadThroughputKbps: 750,
-        },
-        screenEmulation: params.device === "mobile"
-            ? { mobile: true, width: 412, height: 823, deviceScaleFactor: 1.75, disabled: false }
-            : { mobile: false, width: 1350, height: 940, deviceScaleFactor: 1, disabled: false },
-    };
+        };
+    }
     const runnerResult = await lighthouse(params.url, options);
     const lhrUnknown = runnerResult.lhr;
     if (!lhrUnknown || typeof lhrUnknown !== "object") {
@@ -395,3 +885,39 @@ function averageOf(values) {
     const total = defined.reduce((sum, value) => sum + value, 0);
     return total / defined.length;
 }
+function resolveParallelCount({ requested, chromePort, taskCount, }) {
+    if (chromePort !== undefined) {
+        return 1;
+    }
+    if (requested !== undefined) {
+        return requested;
+    }
+    const logicalCpus = cpus().length;
+    const cpuBased = Math.max(1, Math.min(10, Math.floor(logicalCpus * 0.75)));
+    const memoryBased = Math.max(1, Math.min(10, Math.floor(freemem() / 1_500_000_000)));
+    const suggested = Math.max(1, Math.min(cpuBased, memoryBased));
+    const cappedSuggested = Math.min(4, suggested || 1);
+    return Math.max(1, Math.min(10, Math.min(taskCount, cappedSuggested)));
+}
+function computeEtaMs({ startedAtMs, completed, total, }) {
+    if (completed === 0 || total === 0 || completed > total) {
+        return undefined;
+    }
+    const elapsedMs = Date.now() - startedAtMs;
+    const averagePerStep = elapsedMs / completed;
+    const remainingSteps = total - completed;
+    return Math.max(0, Math.round(averagePerStep * remainingSteps));
+}
+function formatEta(etaMs) {
+    const totalSeconds = Math.ceil(etaMs / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const minutesPart = minutes > 0 ? `${minutes}m ` : "";
+    const secondsPart = `${seconds}s`;
+    return `${minutesPart}${secondsPart}`.trim();
+}
+function delayMs(duration) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, duration);
+    });
+}