webperf-snippets 1.14.0 → 1.15.0

package/README.md

@@ -24,6 +24,12 @@ npm install --save-dev webperf-snippets playwright
 npx playwright install chromium
 ```
 
+`npx playwright install chromium` downloads two builds of Chromium: the full Chromium and the headless shell. The CLI and its MCP server run the full Chromium in its headless mode, the binary of Chrome DevTools MCP and of a `--headed` run, and the headless shell only when it is the one installed (`--only-shell`). The full Chromium alone is enough, and skips the download of the headless shell (266 MB on Linux ARM64):
+
+```bash
+npx playwright install --no-shell chromium
+```
+
 ## Usage
 
 ```bash
@@ -70,10 +76,10 @@ JSON output (for piping into `jq` or CI):
 npx webperf-snippets https://example.com --json
 ```
 
-The JSON output records how the page was measured in `conditions`, so a later run can tell whether it measured the same way: the viewport, the workflow (or the path of the snippet with `--snippet`), the wait, the version of the CLI and the machine: its CPU model, cores, architecture and memory, as the operating system reports them, and a benchmark index, a short CPU test in Node before Chromium starts, which only informs, since on the same machine it moves by up to 40 % with the load.
+The JSON output records how the page was measured in `conditions`, so a later run can tell whether it measured the same way: the viewport, the workflow (or the path of the snippet with `--snippet`), the wait, the browser (`build` `chromium` for the full Chromium or `chromium-headless-shell`, its `mode` and its `version`), the version of the CLI and the machine: its CPU model, cores, architecture and memory, as the operating system reports them, and a benchmark index, a short CPU test in Node before Chromium starts, which only informs, since on the same machine it moves by up to 40 % with the load.
 
 ```json
-"conditions": { "viewport": "mobile", "workflow": "core-web-vitals", "waitMs": 3000, "cliVersion": "1.14.0", "machine": { "cpu": "Apple M4", "cores": 10, "arch": "arm64", "memoryGB": 16, "benchmarkIndex": 2371 } }
+"conditions": { "viewport": "mobile", "workflow": "core-web-vitals", "waitMs": 3000, "browser": { "build": "chromium", "mode": "headless", "version": "153.0.8010.12" }, "cliVersion": "1.15.0", "machine": { "cpu": "Apple M4", "cores": 10, "arch": "arm64", "memoryGB": 16, "benchmarkIndex": 2371 } }
 ```
 
 Single snippet:
@@ -171,7 +177,7 @@ Without `--report-to` the CLI makes no external calls. With it, the results are
   "timestamp": "2026-05-06T10:00:00.000Z",
   "navMs": 1240,
   "results": [],
-  "meta": { "viewport": "mobile", "waitMs": 3000, "cli_version": "1.14.0" }
+  "meta": { "viewport": "mobile", "waitMs": 3000, "cli_version": "1.15.0" }
 }
 ```
 
@@ -297,7 +303,7 @@ The report adds the comparison after the usual one, and `--markdown` a table for
 }
 ```
 
-When both runs were measured differently, with another workflow or snippet, viewport, wait, throttling, number of runs or version of the CLI, on another CPU model or with other cores, or on another path or query, the CLI compares anyway and warns on stderr, in the reports and in `warnings`: whoever reads the pull request comment does not see the stderr of the CI. Another host does not warn, since it is the review app of a pull request against production. A baseline of one run warns that only the thresholds apply, and any other metric compared without statistics gets a line with the values left on each side, as in `no statistics for LCP: the baseline has 5 values, and this run 4 after 1 failed run; they need 5 a side, so measure both with 5 runs or more`.
+When both runs were measured differently, with another workflow or snippet, viewport, wait, throttling, number of runs, browser (build, mode or version) or version of the CLI, on another CPU model or with other cores, or on another path or query, the CLI compares anyway and warns on stderr, in the reports and in `warnings`: whoever reads the pull request comment does not see the stderr of the CI. Another host does not warn, since it is the review app of a pull request against production. A baseline of one run warns that only the thresholds apply, and any other metric compared without statistics gets a line with the values left on each side, as in `no statistics for LCP: the baseline has 5 values, and this run 4 after 1 failed run; they need 5 a side, so measure both with 5 runs or more`.
 
 The comparison only informs, and the exit code is the same as without it, unless `--fail-on-regression`, which exits with `1` when a metric regressed or an error is new, and names them on stderr. A baseline that does not exist or is not an output of the CLI, a baseline of a page for a matrix or of a matrix for a page, or a `--threshold` the CLI does not understand exits with code `2`, before the page loads.
 
@@ -526,18 +532,7 @@ LCP, CLS and INP vary by 15 to 30% on shared runners; prefer the deterministic `
 
 ## Publishing
 
-The CLI package is published to npm via a tag-based workflow. Publishing is explicit and intentional; it only happens when a `cli-v*` tag is pushed.
-
-### Release steps
-
-1. Bump the version in `cli/package.json`.
-2. Commit the version change.
-3. Tag and push:
-   ```bash
-   git tag cli-v0.2.0
-   git push origin cli-v0.2.0
-   ```
-4. The `publish-cli` CI job runs, executes the full test suite, and publishes to npm.
+The CLI package is published to npm and to the MCP Registry via a tag-based workflow. Publishing is explicit and intentional; it only happens when a `cli-v*` tag is pushed, and it waits for a maintainer to approve it in the `npm-publish` environment. [`RELEASING.md`](https://github.com/nucliweb/webperf-snippets/blob/main/RELEASING.md) has the steps: the versions to bump, the checks, the tags, and what to do when a publication fails halfway.
 
 ### Why tag-based and not path-based
 
@@ -547,9 +542,9 @@ An alternative is to publish automatically on every push to `main` that touches
 
 Tag protection rules restrict who can push `cli-v*` tags. Configure them under **Settings → Rules → New ruleset** in the repository, targeting the `cli-v*` tag pattern and limiting push access to admins or maintainers. This ensures only authorized collaborators can trigger a publish.
 
-### Required secret
+### No stored token
 
-The `NPM_TOKEN` secret must be set in the repository settings with publish access to the `webperf-snippets` npm package.
+The workflow publishes with npm trusted publishing: npm exchanges the OIDC token of the run for a short-lived one, so no npm token is stored in the repository. The MCP Registry takes the same OIDC token.
 
 ## Known limitations
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webperf-snippets",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "mcpName": "io.github.nucliweb/webperf-snippets",
   "description": "Run curated WebPerf Snippets headlessly via Playwright. Diagnose Core Web Vitals beyond what Lighthouse exposes.",
   "type": "module",
@@ -22,7 +22,7 @@
   "devDependencies": {
     "@modelcontextprotocol/client": "^2.3.1",
     "@projectwallace/css-analyzer": "9.9.5",
-    "vitest": "^5.0.5",
+    "vitest": "^5.1.0",
     "web-vitals": "^6.2.3"
   },
   "engines": {

package/snippets/Media/Image-Element-Audit.js

@@ -172,6 +172,18 @@
     return { script: "Image-Element-Audit", status: "ok", count: 0, corsLimitedAnalysis: false, items: [], issues: [] };
   }
 
+  // An <img> with no src or srcset, and no <source> of its <picture> with one, loads nothing yet: a
+  // carousel or a lazy loader fills it in later with JavaScript. The checks of one image (its format,
+  // its loading, its dimensions) say nothing about it, so it is counted, and the practice named once.
+  const hasSource = (img) =>
+    Boolean(img.currentSrc) ||
+    Boolean(img.getAttribute("src")?.trim()) ||
+    Boolean(img.getAttribute("srcset")?.trim()) ||
+    (img.parentElement?.tagName === "PICTURE" &&
+      Array.from(img.parentElement.querySelectorAll("source")).some((source) => source.getAttribute("srcset")?.trim()));
+  const withoutSrc = images.filter((img) => !hasSource(img));
+  const withSrc = images.filter(hasSource);
+
   const { candidate: lcpCandidate, nonImageTag } = await findLcpCandidate(images);
   const imagePreloads = Array.from(document.querySelectorAll('link[rel="preload"][as="image"]'));
 
@@ -179,7 +191,7 @@
   // Uses the browser cache (force-cache) so already-loaded images
   // don't trigger new network requests. Falls back to URL detection
   // if the server does not expose CORS headers.
-  const formats = await Promise.all(images.map((img) => fetchFormat(img.currentSrc || img.src)));
+  const formats = await Promise.all(withSrc.map((img) => fetchFormat(img.currentSrc || img.src)));
 
   // @shared uniqueSelector
   // A CSS selector that matches only el in its document (or shadow root): its id when it is unique,
@@ -215,7 +227,7 @@
   }
   // @end-shared uniqueSelector
 
-  const audited = images.map((img, i) => {
+  const audited = withSrc.map((img, i) => {
     const inViewport = isInViewport(img);
     const isLcp = img === lcpCandidate;
     const rect = img.getBoundingClientRect();
@@ -282,6 +294,8 @@
     };
   });
 
+  const WITHOUT_SRC_MESSAGE = `${withoutSrc.length} <img> without src or srcset load nothing until JavaScript fills them in, as in a carousel: put the real URL in src with loading="lazy" and width/height, so the browser loads them without waiting for the script and reserves their space`;
+
   const withIssues = audited.filter((r) => r.issues.length > 0);
   const totalErrors = audited.flatMap((r) => r.issues.filter((i) => i.s === "error")).length;
   const totalWarnings = audited.flatMap((r) => r.issues.filter((i) => i.s === "warning")).length;
@@ -293,6 +307,7 @@
   console.log("");
   console.log("%cSummary", "font-weight: bold;");
   console.log(`   Total images  : ${images.length}`);
+  if (withoutSrc.length > 0) console.log(`   Without src   : ${withoutSrc.length} (filled in later by JavaScript, not audited one by one)`);
   console.log(`   In viewport   : ${audited.filter((r) => r.inViewport).length}`);
   console.log(`   Off viewport  : ${audited.filter((r) => !r.inViewport).length}`);
   console.log(
@@ -326,7 +341,7 @@
 
   // Full table
   console.log("");
-  console.group(`%c📋 All Images (${images.length})`, "font-weight: bold;");
+  console.group(`%c📋 Images with a source (${audited.length})`, "font-weight: bold;");
   console.table(
     audited.map((r) => ({
       src: shortSrc(r.src),
@@ -376,6 +391,12 @@
     console.log("%c✅ No issues found.", "color: #22c55e; font-weight: bold;");
   }
 
+  if (withoutSrc.length > 0) {
+    console.log("");
+    console.log(`%cℹ️ ${WITHOUT_SRC_MESSAGE}`, "color: #3b82f6;");
+    console.log("   First of them:", withoutSrc[0]);
+  }
+
   // Quick reference
   console.log("");
   console.group("%c📝 Quick Reference", "color: #3b82f6; font-weight: bold;");
@@ -420,6 +441,7 @@
     corsLimitedAnalysis: formatGuessedCount > 0,
     details: {
       totalImages: images.length,
+      withoutSrc: withoutSrc.length,
       formatGuessedCount,
       inViewport: audited.filter((r) => r.inViewport).length,
       offViewport: audited.filter((r) => !r.inViewport).length,
@@ -464,6 +486,7 @@
           ...(r.src ? { target: r.src.startsWith("data:") ? r.src.slice(0, 60) : r.src } : {}),
         }))
       ),
+      ...(withoutSrc.length > 0 ? [{ code: "images-without-src", severity: "info", message: WITHOUT_SRC_MESSAGE }] : []),
     ],
   };
 })();

package/snippets/SCHEMA.md

@@ -1152,7 +1152,7 @@ Returns buffered long tasks immediately. Ongoing tracking continues. `items` lis
 
 #### Image-Element-Audit (async)
 
-`items` holds the 50 images to look at first: the LCP image, then those with the most errors and warnings. `count` and `details` cover every image. The format comes from the `Content-Type` of the response; when a cross-origin image blocks `fetch()` it is guessed from the URL, `details.formatGuessedCount` counts those images and `corsLimitedAnalysis` is `true`.
+`items` holds the 50 images to look at first: the LCP image, then those with the most errors and warnings. `count` and `details` cover every image. The format comes from the `Content-Type` of the response; when a cross-origin image blocks `fetch()` it is guessed from the URL, `details.formatGuessedCount` counts those images and `corsLimitedAnalysis` is `true`. An `<img>` without `src` or `srcset`, and without a `<source>` of its `<picture>` that has one, loads nothing yet, as the slides a carousel fills in with JavaScript: `details.withoutSrc` counts those images, they stay out of `items` and of the checks of one image, and one `images-without-src` issue names them all.
 
 ```json
 {
@@ -1649,7 +1649,7 @@ Each issue about one hint names its URL in `target`.
 
 ### Image-Element-Audit
 
-Each issue names its image in `target`, except `lcp-not-img`.
+Each issue names its image in `target`, except `lcp-not-img` and `images-without-src`.
 
 | Code | Severity | When |
 |------|----------|------|
@@ -1665,6 +1665,7 @@ Each issue names its image in `target`, except `lcp-not-img`.
 | `lazy-and-high-priority` | error | An image with both `loading="lazy"` and `fetchpriority="high"` |
 | `missing-dimensions` | warning | An image without `width` and `height` |
 | `no-modern-format` | info | An image that is not WebP, AVIF, JPEG XL or SVG, outside a `<picture>` |
+| `images-without-src` | info | One or more `<img>` without `src` or `srcset`, which JavaScript fills in later; one issue for all of them |
 
 ### Oversized-Images
 

package/src/baseline.js

@@ -204,6 +204,23 @@ function machineWarning(base, current) {
   return `the baseline was measured on another machine (${base.cpu}, ${base.cores} cores) than this run (${current.cpu}, ${current.cores} cores); timings can differ for that alone`;
 }
 
+// The full Chromium and the headless shell are two builds, and a version of either can move the timings
+// of the same page. A baseline without a browser comes from a CLI that launched the headless shell, with
+// Playwright 1.49 or later, so it warns only when this run used another browser.
+const BUILDS = { chromium: "the full Chromium", "chromium-headless-shell": "the headless shell" };
+const describeBrowser = ({ build, mode, version }) => `${BUILDS[build] ?? build} ${version}${mode === "headed" ? ", headed" : ""}`;
+
+function browserWarning(base, current) {
+  if (!base || !current?.browser) return null;
+  if (!base.browser) {
+    const { build, mode } = current.browser;
+    if (build === "chromium-headless-shell" && mode === "headless") return null;
+    return `the baseline does not name its browser (CLI ${base.cliVersion} launched the headless shell with Playwright 1.49 or later), and this run used ${describeBrowser(current.browser)}; timings can differ for that alone`;
+  }
+  const [was, is] = [describeBrowser(base.browser), describeBrowser(current.browser)];
+  return was === is ? null : `the baseline was measured with ${was}, and this run with ${is}; timings can differ for that alone`;
+}
+
 const valueCount = (payload, metric) => measured(payload, metric).values?.length ?? 1;
 
 // Why five runs can leave four values, when a run failed; a run that missed a metric alone does not count
@@ -251,6 +268,8 @@ function warningsOf(base, current, metrics) {
   }
   const machine = machineWarning(b?.machine, c?.machine);
   if (machine) warnings.push(machine);
+  const browser = browserWarning(b, c);
+  if (browser) warnings.push(browser);
   if (b && c && b.cliVersion !== c.cliVersion) {
     warnings.push(`the baseline was measured with CLI ${b.cliVersion}, and this run with ${c.cliVersion}; the snippets may have changed`);
   }

package/src/bin.js

@@ -314,8 +314,9 @@ async function main() {
   // What the JSON records of how each page was measured, for a later run to compare with. The machine is
   // measured once, before Chromium starts, so its processes do not slow the benchmark down.
   const machine = machineOf();
-  const conditionsFor = ({ viewport, cpu, network }) =>
-    measurementConditions({ viewport, waitMs, cpu, network, machine, ...(items ? { snippet: items[0].path } : { workflow: values.workflow ?? "core-web-vitals" }) });
+  // The browser is the one of the run the report keeps: the run itself, or the median one
+  const conditionsFor = ({ viewport, cpu, network, browser }) =>
+    measurementConditions({ viewport, waitMs, cpu, network, browser, machine, ...(items ? { snippet: items[0].path } : { workflow: values.workflow ?? "core-web-vitals" }) });
 
   if (matrixPath) {
     let matrix;
@@ -337,7 +338,8 @@ async function main() {
     if (!median.payload) throw new Error(`Every run failed: ${median.errors.join("; ")}`);
     payload = { ...median.payload, runs: median.runs };
   }
-  payload.conditions = conditionsFor({ viewport: viewportName, cpu, network });
+  const { browser, ...measured } = payload;
+  payload = { ...measured, conditions: conditionsFor({ viewport: viewportName, cpu, network, browser }) };
 
   if (cruxKey) payload.crux = await fieldDataOf(url, formFactorFor(viewportName));
 
@@ -421,9 +423,10 @@ async function runMatrix(matrixPath, matrix, measureWith, { values, waitMs, repo
     const conditions = { url: c.url, viewport: VIEWPORT_PRESETS[c.viewport], storageState: c.storageState, headers: c.headers, cpu: c.cpu, network: c.network, ownDomains: c.ownDomains };
     const median = await measureRunsWithProgress(() => measureWith(conditions), matrix.runs, matrix.medianBy, (i) => `[${String(++started).padStart(width)}/${total}] ${c.id} · run ${i}/${matrix.runs}`);
     const identity = { id: c.id, name: c.name, device: c.device, ...(c.variant ? { variant: c.variant } : {}), url: c.url };
+    const { browser, ...measured } = median.payload ?? {};
     combinations.push(
       median.payload
-        ? { ...identity, ...median.payload, runs: median.runs, conditions: conditionsFor(c) }
+        ? { ...identity, ...measured, runs: median.runs, conditions: conditionsFor({ ...c, browser }) }
         : { ...identity, status: "error", error: `Every run failed: ${median.errors.join("; ")}`, runs: { count: matrix.runs, failed: matrix.runs }, conditions: conditionsFor(c) }
     );
   }

package/src/browser.js

@@ -1,3 +1,4 @@
+import { existsSync } from "node:fs";
 import { chromium } from "playwright";
 
 // Chromium for Playwright is a download of its own: npx installs this package and its peer playwright,
@@ -13,9 +14,45 @@ export class MissingBrowserError extends Error {
 
 export const isMissingBrowser = (err) => err instanceof MissingBrowserError || /Executable doesn't exist/.test(err?.message ?? "");
 
-export async function launchChromium(options) {
+// Whether the full Chromium of this Playwright is on the machine. executablePath() names it in every
+// version since 1.40, whichever of the two binaries a launch would pick.
+function fullChromiumInstalled() {
   try {
-    return await chromium.launch(options);
+    return existsSync(chromium.executablePath());
+  } catch {
+    return false;
+  }
+}
+
+// Which Chromium a launch uses. Headless, Playwright 1.49 and later picks the headless shell
+// (chromium_headless_shell-*), a build of its own, and channel "chromium" picks the full Chromium in its
+// headless mode, the binary Chrome DevTools MCP runs. So the full Chromium when it is installed
+// (npx playwright install chromium installs both; --no-shell only this one), and the headless shell
+// otherwise (--only-shell). It is checked on disk, not by a launch that fails: Playwright makes the same
+// check before it starts the process, so the outcome is the same, without a failure in its logs.
+// Before 1.49 there is no headless shell, and channel "chromium" is the executable a launch without a
+// channel runs, with the same arguments. Headed, Playwright already runs the full Chromium; and a
+// channel or an executable of the caller wins.
+export function chromiumLaunchOptions(options = {}, { hasFullChromium = fullChromiumInstalled } = {}) {
+  if (options.headless === false || options.channel || options.executablePath) return options;
+  return hasFullChromium() ? { channel: "chromium", ...options } : options;
+}
+
+// The browser a launch with these options ran, for the conditions of a measurement: its build (the full
+// Chromium, "chromium", or the headless shell, "chromium-headless-shell"), its mode and its version. A
+// later run compared with it can then say when the browser changed, which can move the timings.
+export function launchedBrowser(options = {}, browser) {
+  const headed = options.headless === false;
+  return {
+    build: options.channel ?? (headed ? "chromium" : "chromium-headless-shell"),
+    mode: headed ? "headed" : "headless",
+    version: browser.version(),
+  };
+}
+
+export async function launchChromium(options, { launch = (o) => chromium.launch(o), hasFullChromium } = {}) {
+  try {
+    return await launch(chromiumLaunchOptions(options, { hasFullChromium }));
   } catch (err) {
     throw isMissingBrowser(err) ? new MissingBrowserError() : err;
   }

package/src/conditions.js

@@ -3,14 +3,15 @@ import { cliVersion } from "./report-to.js";
 // How a measurement was taken, kept in its JSON so that a later run compared with it can tell whether
 // both were measured the same way. A snippet is named by its path, so an alias and its path match. The
 // CPU factor and the network go in only when the run was throttled, so a run without throttling keeps
-// the conditions of earlier versions.
-export function measurementConditions({ viewport, workflow, snippet, waitMs, cpu, network, machine }) {
+// the conditions of earlier versions. The browser is the one the run launched (browser.js, launchedBrowser).
+export function measurementConditions({ viewport, workflow, snippet, waitMs, cpu, network, browser, machine }) {
   return {
     viewport,
     ...(snippet ? { snippet } : { workflow }),
     waitMs,
     ...(cpu != null ? { cpu } : {}),
     ...(network != null ? { network } : {}),
+    ...(browser ? { browser } : {}),
     cliVersion,
     ...(machine ? { machine } : {}),
   };

package/src/mcp/server.js

@@ -314,11 +314,14 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
 
   // The machine goes in the conditions of every run, as in the JSON of the CLI, so a baseline measured
   // on another one warns. It is measured once, in the turn of the first run, before its Chromium starts.
+  // The browser is the one the run launched, the median one with several runs.
   let machineOfServer;
-  const conditionsOf = (conditions) => measurementConditions({ ...conditions, machine: (machineOfServer ??= machine()) });
-
   const measureInTurn = (conditions, measure, count, ctx) =>
-    inTurn(ctx, STAGES * count, async () => ({ conditions: conditionsOf(conditions), run: await measurePage(measure, count, ctx, callLimitMs) }));
+    inTurn(ctx, STAGES * count, async () => {
+      machineOfServer ??= machine();
+      const { browser, ...run } = await measurePage(measure, count, ctx, callLimitMs);
+      return { conditions: measurementConditions({ ...conditions, browser, machine: machineOfServer }), run };
+    });
 
   // A run of a page load, kept with its page in the shape of the JSON of the CLI: its runId is the
   // baseline of a later run, and the resources list it

package/src/runner.js

@@ -1,4 +1,4 @@
-import { launchChromium } from "./browser.js";
+import { chromiumLaunchOptions, launchChromium, launchedBrowser } from "./browser.js";
 import { loadSnippet } from "./load-snippet.js";
 import { runInteractions, loadInteractionSteps, isInputStep, settle } from "./interactions.js";
 import { isTrackingSnippet } from "./tracking.js";
@@ -131,7 +131,9 @@ export async function runSnippets({
   signal,
 }) {
   await onProgress(1, "Opening Chromium");
-  const browser = await launchChromium({ headless });
+  const launchOptions = chromiumLaunchOptions({ headless });
+  const browser = await launchChromium(launchOptions);
+  const launched = launchedBrowser(launchOptions, browser);
   const stopListening = closeOnAbort(browser, signal);
   try {
     const context = await browser.newContext({ viewport, storageState });
@@ -148,7 +150,7 @@ export async function runSnippets({
     const prepared = items.map((item) => ({ ...item, source: withOwnDomains(item.source, ownDomains) }));
     const results = await evaluateAroundInteractions(page, prepared, interactions);
     await onProgress(3, "Snippets evaluated");
-    return { url, navMs, results, pageErrors, throttling: throttlingOf({ cpu, network }) };
+    return { url, navMs, results, pageErrors, throttling: throttlingOf({ cpu, network }), browser: launched };
   } finally {
     stopListening();
     await browser.close();
@@ -174,7 +176,9 @@ export async function runMeasurement({
   signal,
 }) {
   await onProgress(1, "Opening Chromium");
-  const browser = await launchChromium({ headless });
+  const launchOptions = chromiumLaunchOptions({ headless });
+  const browser = await launchChromium(launchOptions);
+  const launched = launchedBrowser(launchOptions, browser);
   const stopListening = closeOnAbort(browser, signal);
   try {
     const context = await browser.newContext({ viewport, storageState });
@@ -237,7 +241,7 @@ export async function runMeasurement({
     }
 
     await onProgress(3, "Workflow and follow-ups evaluated");
-    return { url, navMs, results: [...initialResults, ...followUpResults], pageErrors, throttling: throttlingOf({ cpu, network }) };
+    return { url, navMs, results: [...initialResults, ...followUpResults], pageErrors, throttling: throttlingOf({ cpu, network }), browser: launched };
   } finally {
     stopListening();
     await browser.close();