webperf-snippets 1.13.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.13.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.13.0" }
+  "meta": { "viewport": "mobile", "waitMs": 3000, "cli_version": "1.15.0" }
 }
 ```
 
@@ -203,7 +209,7 @@ One page load is one sample, and lab values vary from one load to the next. `--r
 npx webperf-snippets https://example.com --runs 5 --budget-lcp 2500
 ```
 
-The median run is the one with the median LCP. A workflow without LCP uses the first of FCP, TTFB and the navigation time that it measures, and `--median-by <metric>` picks another one (`LCP`, `FCP`, `TTFB`, `CLS`, `INP` or `navMs`). With an even count it takes the lower of the two middle runs, so the report is always a run that happened. The report adds the median, min and max of each metric across the runs, and how much the runs agree, and the JSON output carries them in `runs`:
+The median run is the one with the median LCP. A workflow without LCP uses the first of FCP, TTFB, INP and the navigation time that it measures, so a measurement of interactions answers with its median INP, and `--median-by <metric>` picks another one (`LCP`, `FCP`, `TTFB`, `CLS`, `INP` or `navMs`). With an even count it takes the lower of the two middle runs, so the report is always a run that happened. The report adds the median, min and max of each metric across the runs, and how much the runs agree, and the JSON output carries them in `runs`:
 
 ```json
 "runs": {
@@ -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.
 
@@ -334,7 +340,7 @@ Each budget compares the value measured, or the median with `--runs`, and fails
 | `--header "Name: value"`     | Request header for the origin of the URL only, such as the token of an access proxy. Repeat it for more headers. |
 | `--own-domains <list>`       | Domains of the site to count as first party, such as its own CDN. Comma-separated or repeated. |
 | `--runs <n>`                 | Measure the page n times, from 1 to 9, one after the other, and report the median run. |
-| `--median-by <metric>`       | Metric that picks the median run: `LCP`, `FCP`, `TTFB`, `CLS`, `INP` or `navMs`. Default: the first of LCP, FCP, TTFB and `navMs` measured. |
+| `--median-by <metric>`       | Metric that picks the median run: `LCP`, `FCP`, `TTFB`, `CLS`, `INP` or `navMs`. Default: the first of LCP, FCP, TTFB, INP and `navMs` measured. |
 | `--matrix <file>`            | Measure every URL of a JSON file on every device and in every variant it lists, and report a table of the medians. |
 | `--baseline <file>`          | Compare the page, or each combination of a matrix, with the `--json` output of an earlier run: which metrics got worse or better beyond the noise, and which errors are new or fixed. |
 | `--threshold <metric>=<v>`   | The threshold of a metric for `--baseline`, such as `LCP=15%`, `LCP=200ms` or `CLS=0.1`. Repeat it for more metrics. |
@@ -404,15 +410,30 @@ It needs the Chromium of Playwright (`npx playwright install chromium`); without
 | Tool            | What it does                                                                 |
 | --------------- | ---------------------------------------------------------------------------- |
 | `list_snippets` | Lists the snippets with their category, title, short aliases and whether they track interactions. Takes an optional `category`. |
-| `run_snippet`   | Opens a URL in a headless Chromium, runs one snippet and returns a summary of its result. Takes `url`, `snippet` (name, alias or `Category/Name`), and optional `viewport`, `waitMs`, `runs`, `baseline` and `thresholds`. The snippets that record interactions run on a page opened with `open_page`. |
-| `run_workflow`  | Runs a workflow of the CLI (`core-web-vitals`, `audit`, `loading`, `interaction`) and the follow-ups of its decision tree. Takes `url`, `workflow`, and optional `viewport`, `waitMs`, `runs`, `baseline` and `thresholds`. |
+| `run_snippet`   | Opens a URL in a headless Chromium, runs one snippet and returns a summary of its result. Takes `url`, `snippet` (name, alias or `Category/Name`), and optional `viewport`, `waitMs`, `cpu`, `network`, `interactions`, `runs`, `baseline` and `thresholds`. The snippets that record interactions need `interactions` with a click or a key press, or a page opened with `open_page`. |
+| `run_workflow`  | Runs a workflow of the CLI (`core-web-vitals`, `audit`, `loading`, `interaction`) and the follow-ups of its decision tree. Takes `url`, `workflow`, and optional `viewport`, `waitMs`, `cpu`, `network`, `interactions`, `runs`, `baseline` and `thresholds`. |
 | `get_crux`      | Returns the CrUX p75 of LCP, CLS and INP for a URL, or its origin. Takes `url` and an optional `formFactor` (`phone`, `desktop`, `tablet`). Needs `CRUX_API_KEY` in the environment of the server. |
-| `open_page`     | Opens a URL in a page that stays open between calls and installs tracking snippets (`track`, such as `INP`). Returns a `sessionId`. |
+| `open_page`     | Opens a URL in a page that stays open between calls and installs tracking snippets (`track`, such as `INP`). Takes optional `viewport`, `waitMs`, `cpu` and `network`. Returns a `sessionId`. |
 | `interact`      | Runs steps on an open page: `click`, `type`, `hover`, `scroll` or `wait`. |
 | `read_results`  | Returns what the tracking snippets of an open page have recorded. |
 | `get_details`   | Returns the whole object of one snippet of a run, by the `runId` that `run_snippet`, `run_workflow` or `read_results` returned, without measuring again. Takes `runId` and `snippet`. |
 | `close_page`    | Closes an open page. |
 
+`run_snippet`, `run_workflow` and `open_page` take `cpu` and `network`, as `--cpu` and `--network`: a CPU factor of at least 1, such as `4`, and a DevTools preset (`fast-4g`, `slow-4g`, `3g`), applied before the page loads. The answer adds `throttling`, as the JSON does, and the conditions of the run name them, so a baseline measured under other throttling gives a warning.
+
+`run_snippet` and `run_workflow` take `interactions`, the steps of `interact` (up to 50), as `--interact-script`: they run after the load of each run, so `runs`, `baseline` and `thresholds` work with them. With a click or a key press, `run_snippet` runs INP, Interactions and Input-Latency-Breakdown, and the `interaction` workflow runs its steps that need input instead of skipping them. The INP of a page over five runs with a click each, with the CPU 4 times slower, against an earlier run:
+
+```json
+{
+  "url": "http://localhost:3000/product",
+  "snippet": "INP",
+  "interactions": [{ "action": "click", "selector": "#buy" }, { "action": "wait", "ms": 300 }],
+  "runs": 5,
+  "cpu": 4,
+  "baseline": "<runId of the run before the change>"
+}
+```
+
 `run_snippet` and `run_workflow` take `runs`, from 1 to 9, as `--runs`: the page loads that many times, one after the other, and the answer is the median run plus a `runs` field, the one of the JSON, with the median, min, max, the value of each run and the agreement of each metric. A run that fails counts in `failed` and is left out; when every run fails, the answer is a tool error. The server keeps the results of the median run only, as the JSON does, so `get_details` answers from that run and names it in `medianRun`; a metric other than the one that picked it (`medianBy`) can differ there from its median in `runs`.
 
 Each run is a page load plus `waitMs`. With the default wait of 3 seconds, five runs of a workflow take about 20 seconds on a local page, and about a minute on a page that takes a few seconds to load. When the client asks for progress, the server reports the three stages of each run, numbered across the runs. A client sets its own limit on a tool call: the MCP SDK stops waiting after 60 seconds unless it is given a longer `timeout` or `resetTimeoutOnProgress`, and in Claude Code `MCP_TOOL_TIMEOUT` sets the limit. When the client gives up, the run in progress ends and no other starts.
@@ -511,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
 
@@ -532,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.13.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/Interaction/Scroll-Performance.js

@@ -26,9 +26,13 @@
     "scroll", "wheel", "touchstart", "touchmove", "touchend",
   ]);
 
+  // When Playwright clicks, as the CLI does, its injected script can add touch listeners of its own to
+  // window, without passive, to check that the click lands on the element. They are not the page's.
+  const addedByPlaywright = () => /\bInjectedScript\b/.test(new Error().stack || "");
+
   const _origAddEventListener = EventTarget.prototype.addEventListener;
   EventTarget.prototype.addEventListener = function (type, listener, options) {
-    if (SCROLL_EVENT_TYPES.has(type)) {
+    if (SCROLL_EVENT_TYPES.has(type) && !addedByPlaywright()) {
       const isPassive =
         options === true
           ? false // old-style capture boolean, not passive

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

@@ -71,7 +71,8 @@ Options:
   --matrix <file>           Measure every URL of a JSON file on every device and in every
                             variant it lists, and report a table of the medians
   --median-by <metric>      Metric that picks the median run: LCP, FCP, TTFB, CLS, INP,
-                            navMs (default: the first of LCP, FCP, TTFB, navMs measured)
+                            navMs (default: the first of LCP, FCP, TTFB, INP, navMs
+                            measured)
   --baseline <file>         Compare the page, or each combination of a matrix, with the --json
                             output of an earlier run: which metrics got worse or better beyond
                             the noise, and which errors are new or fixed. It only informs,
@@ -313,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) =>
-    measurementConditions({ viewport, waitMs, 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;
@@ -336,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(viewportName);
+  const { browser, ...measured } = payload;
+  payload = { ...measured, conditions: conditionsFor({ viewport: viewportName, cpu, network, browser }) };
 
   if (cruxKey) payload.crux = await fieldDataOf(url, formFactorFor(viewportName));
 
@@ -420,10 +423,11 @@ 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.viewport) }
-        : { ...identity, status: "error", error: `Every run failed: ${median.errors.join("; ")}`, runs: { count: matrix.runs, failed: matrix.runs }, conditions: conditionsFor(c.viewport) }
+        ? { ...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

@@ -1,7 +1,18 @@
 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.
-export function measurementConditions({ viewport, workflow, snippet, waitMs, machine }) {
-  return { viewport, ...(snippet ? { snippet } : { workflow }), waitMs, cliVersion, ...(machine ? { machine } : {}) };
+// 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. 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/next-steps.js

@@ -1,29 +1,49 @@
 import { RULES, nextSteps } from "../decision-tree.js";
 import { loadSnippet } from "../load-snippet.js";
 import { isTrackingSnippet } from "../tracking.js";
+import { throttlingOf } from "../throttling.js";
 
 const isTrackingPath = (path) => isTrackingSnippet(path, loadSnippet(path));
 
 // The call of the tool that runs a snippet: a tracking snippet needs a page the agent interacts with. A
-// snippet waits as long as the run that called for it, so it reads the same paint.
-const callFor = ({ path, reason, url, viewport, waitMs, isTracking }) =>
+// snippet waits as long as the run that called for it, so it reads the same paint, and loads under its
+// throttling, so it measures the same page.
+const callFor = ({ path, reason, url, viewport, waitMs, cpu, network, isTracking }) =>
   isTracking(path)
-    ? { tool: "open_page", args: { url, track: [path], viewport }, reason }
-    : { tool: "run_snippet", args: { url, snippet: path, viewport, ...(waitMs !== undefined ? { waitMs } : {}) }, reason };
+    ? { tool: "open_page", args: { url, track: [path], viewport, ...throttlingOf({ cpu, network }) }, reason }
+    : { tool: "run_snippet", args: { url, snippet: path, viewport, ...(waitMs !== undefined ? { waitMs } : {}), ...throttlingOf({ cpu, network }) }, reason };
 
 // The follow-ups the decision tree of the CLI asks for, as the calls an agent makes next. The rules name
 // the steps of a workflow (LCP, CLS, TTFB, FCP), which are the scripts of the snippets, so a result of
 // run_snippet, whose id is Category/Name, is matched by its script. `ran` leaves out what already ran.
-export function followUpCalls({ results, url, viewport, waitMs, ran = [], rules = RULES, isTracking = isTrackingPath }) {
+export function followUpCalls({ results, url, viewport, waitMs, cpu, network, ran = [], rules = RULES, isTracking = isTrackingPath }) {
   const named = results.map((r) => ({ ...r, id: r.script ?? r.id }));
-  return nextSteps(named, rules, ran).map(({ path, reason }) => callFor({ path, reason, url, viewport, waitMs, isTracking }));
+  return nextSteps(named, rules, ran).map(({ path, reason }) => callFor({ path, reason, url, viewport, waitMs, cpu, network, isTracking }));
 }
 
 // The steps a workflow skipped because they measure clicks and key presses, in one page to open
-export function trackingCall({ paths, url, viewport }) {
+export function trackingCall({ paths, url, viewport, cpu, network }) {
   return {
     tool: "open_page",
-    args: { url, track: paths, viewport },
+    args: { url, track: paths, viewport, ...throttlingOf({ cpu, network }) },
     reason: "These steps measure clicks and key presses: open the page with them, interact with it and read them with read_results",
   };
 }
+
+// A click the agent completes: only the agent can choose the element of the page to click
+const CLICK_TO_COMPLETE = { action: "click", selector: "<selector of the element to click>" };
+
+// The steps a workflow skipped because they measure clicks and key presses. First the workflow again
+// with interactions, which measures them in one call, with the runs and the baseline of a page load; then
+// a page to open with them, for an agent that explores the page step by step.
+export function inputStepsCalls({ workflow, paths, url, viewport, waitMs, cpu, network }) {
+  return [
+    {
+      tool: "run_workflow",
+      args: { url, workflow, viewport, ...(waitMs !== undefined ? { waitMs } : {}), ...throttlingOf({ cpu, network }), interactions: [CLICK_TO_COMPLETE] },
+      reason:
+        "These steps measure clicks and key presses: run the workflow again with interactions, a click or type step on an element of the page in place of this selector; runs and baseline work with them",
+    },
+    trackingCall({ paths, url, viewport, cpu, network }),
+  ];
+}

package/src/mcp/server.js

@@ -15,12 +15,13 @@ import { launchChromium, isMissingBrowser, MISSING_BROWSER } from "../browser.js
 import { registerResources } from "./documents.js";
 import { registerPrompts } from "./prompts.js";
 import { shapeResults, createRuns, RunError } from "./summary.js";
-import { followUpCalls, trackingCall } from "./next-steps.js";
+import { followUpCalls, inputStepsCalls } from "./next-steps.js";
 import { isHttpUrl } from "../url.js";
 import { machineOf } from "../machine.js";
 import { measurementConditions } from "../conditions.js";
 import { prepareBaseline, compareWithBaseline } from "./baseline.js";
 import { MAX_RUNS, measureRuns } from "../runs.js";
+import { MIN_CPU_FACTOR, NETWORK_PRESETS, applyThrottling, throttlingOf } from "../throttling.js";
 
 const VIEWPORTS = Object.keys(VIEWPORT_PRESETS);
 const STAGES = 3;
@@ -72,7 +73,27 @@ const Runs = z
     "Measure the page this many times, one after the other, as --runs of the CLI: the answer is the median run, plus runs with the median, min, max and agreement of each metric. With baseline, 5 or more on both sides give the statistical verdict: use 5 for a comparison, and more only when agreement says noisy. Each run is a full page load and wait, so it takes that much longer"
   );
 
+// The throttling of --cpu and --network, applied to the page before it loads. Without them the page runs
+// at the speed of the machine, as the CLI does. A network of the tools is a preset: its own values are
+// for --matrix.
+const Cpu = z
+  .number()
+  .min(MIN_CPU_FACTOR)
+  .optional()
+  .describe(
+    "Slow the CPU of the page down by this factor, as --cpu of the CLI. Leave it out unless the user asks for throttling or the baseline was throttled: compared with a baseline, use the cpu it was measured with (no throttling by default)"
+  );
+const Network = z
+  .enum(Object.keys(NETWORK_PRESETS))
+  .optional()
+  .describe(
+    "Throttle the network as DevTools does, as --network of the CLI. Leave it out unless the user asks for throttling or the baseline was throttled: compared with a baseline, use the network it was measured with (no throttling by default)"
+  );
+
 const LooseObject = (shape) => z.looseObject(shape).meta({ additionalProperties: true });
+const Throttling = LooseObject({})
+  .optional()
+  .describe("With cpu or network, the throttling the page ran under, as the throttling field of the JSON of the CLI");
 const RunsSummary = LooseObject({
   count: z.number(),
   failed: z.number().describe("Runs left out because they failed"),
@@ -117,6 +138,7 @@ const DETAIL_NOTE =
   "Large results come as summaries with a runId for get_details; nextSteps, when present, is the call to make next.";
 const BASELINE_NOTE = "With baseline, it also compares the run with an earlier one, as --baseline of the CLI, and says what regressed.";
 const QUEUE_NOTE = "Measurements run one at a time, so several in one turn save no time.";
+const THROTTLING_NOTE = "cpu and network throttle the page as --cpu and --network of the CLI, and the answer says so in throttling.";
 
 // A page can put instructions for the agent in what a snippet returns: an alt text, a class in a
 // selector, the URL of a script. The tools that return what a page holds say how to read it, and so
@@ -133,6 +155,16 @@ const Step = z.discriminatedUnion("action", [
   z.object({ action: z.literal("wait"), ms: z.number().int().min(0).max(10000) }),
 ]);
 
+// The steps of interact, run after the load of each run, as --interact-script of the CLI
+const Interactions = z
+  .array(Step)
+  .min(1)
+  .max(50)
+  .optional()
+  .describe(
+    "Steps to run on the page after the load, as --interact-script of the CLI: click, type, hover, scroll or wait, as in interact. A click or a key press is what INP, Interactions and Input-Latency-Breakdown measure. Each run repeats them, so runs and baseline work with them"
+  );
+
 const SnippetInfo = z.object({
   name: z.string().describe("Category/Name, the name other tools take"),
   category: z.enum(CATEGORIES),
@@ -282,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
@@ -341,12 +376,15 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
     {
       title: "Run a snippet",
       description:
-        `Opens the URL in a headless Chromium, runs one web performance snippet on the loaded page and returns the object the snippet returns, as defined in snippets/SCHEMA.md. Use list_snippets for the names. The snippets that record interactions (INP, Interactions, Input-Latency-Breakdown) run on a page opened with open_page instead. ${QUEUE_NOTE} ${BASELINE_NOTE} ${DETAIL_NOTE} ${PAGE_DATA}`,
+        `Opens the URL in a headless Chromium, runs one web performance snippet on the loaded page and returns the object the snippet returns, as defined in snippets/SCHEMA.md. Use list_snippets for the names. The snippets that record interactions (INP, Interactions, Input-Latency-Breakdown) need interactions with a click or a key press, which run after the load of each run; open_page explores a page step by step instead. ${THROTTLING_NOTE} ${QUEUE_NOTE} ${BASELINE_NOTE} ${DETAIL_NOTE} ${PAGE_DATA}`,
       inputSchema: z.object({
         url: HttpUrl,
         snippet: z.string().describe("The snippet: its name (LCP-Subparts), an alias (render-blocking) or Category/Name"),
         viewport: z.enum(VIEWPORTS).default("mobile").describe("Device size of the page"),
         waitMs: z.number().int().min(0).max(10000).default(3000).describe("Wait after the load event before running the snippet, in ms"),
+        cpu: Cpu,
+        network: Network,
+        interactions: Interactions,
         runs: Runs,
         detail: Detail,
         baseline: Baseline,
@@ -360,6 +398,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
         viewport: z.enum(VIEWPORTS),
         navMs: z.number().describe("From the start of the navigation to the end of the wait"),
         pageErrors: z.array(z.string()).describe("Uncaught errors of the page during the run"),
+        throttling: Throttling,
         result: SnippetResult,
         runs: RunsSummary,
         baseline: Comparison,
@@ -367,7 +406,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
       }),
       annotations: { readOnlyHint: true, openWorldHint: true },
     },
-    async ({ url, snippet, viewport, waitMs, runs: count, detail, baseline, thresholds }, ctx) => {
+    async ({ url, snippet, viewport, waitMs, cpu, network, interactions, runs: count, detail, baseline, thresholds }, ctx) => {
       let path;
       try {
         path = resolveSnippetName(snippet);
@@ -375,8 +414,11 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
         return toolError(err.message);
       }
       const source = loadSnippet(path);
-      if (isTrackingSnippet(path, source)) {
-        return toolError(`${path} records interactions: open the page with open_page and this snippet in track, use it with interact, and read it with read_results.`);
+      // With interactions, the runner installs it before the steps and reads it after them
+      if (isTrackingSnippet(path, source) && !interactions) {
+        return toolError(
+          `${path} records interactions: run it with interactions that click or type on an element of the page, which run after the load, or open the page with open_page and this snippet in track, use it with interact, and read it with read_results.`
+        );
       }
       let base;
       try {
@@ -387,15 +429,15 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
 
       try {
         const { conditions, run } = await measureInTurn(
-          { viewport, snippet: path, waitMs },
-          (onProgress, signal) => runSnippets({ url, items: [{ id: path, path, source }], waitMs, viewport: VIEWPORT_PRESETS[viewport], onProgress, signal }),
+          { viewport, snippet: path, waitMs, cpu, network },
+          (onProgress, signal) => runSnippets({ url, items: [{ id: path, path, source }], waitMs, viewport: VIEWPORT_PRESETS[viewport], cpu, network, interactions, onProgress, signal }),
           count,
           ctx
         );
         const shaped = shapeResults(run.results.map(({ id, ...result }) => result), detail);
         const { runId, current } = keepPage(run, run.results, conditions);
         const id = run.results[0].id;
-        const nextSteps = followUpCalls({ results: run.results, url, viewport, waitMs, ran: [path] });
+        const nextSteps = followUpCalls({ results: run.results, url, viewport, waitMs, cpu, network, ran: [path] });
         return toolResult({
           url,
           runId,
@@ -404,6 +446,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
           viewport,
           navMs: run.navMs,
           pageErrors: run.pageErrors,
+          ...(run.throttling ? { throttling: run.throttling } : {}),
           result: shaped.results[0],
           ...(run.runs ? { runs: run.runs } : {}),
           ...(base ? { baseline: compareWithBaseline(base, current) } : {}),
@@ -422,12 +465,15 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
     {
       title: "Run a workflow",
       description:
-        `Opens the URL in a headless Chromium and runs a workflow: a sequence of snippets plus the follow-ups its decision tree adds from the results (for example LCP-Subparts when LCP is over 2.5 s, with the reason). core-web-vitals: LCP and CLS. audit: render-blocking resources, resource hints, critical CSS, TTFB, scripts, images and more. loading: TTFB, FCP, render-blocking, scripts and fonts. interaction: long tasks, animation frames, scroll and layout shifts while it scrolls the page. ${QUEUE_NOTE} ${BASELINE_NOTE} ${DETAIL_NOTE} ${PAGE_DATA}`,
+        `Opens the URL in a headless Chromium and runs a workflow: a sequence of snippets plus the follow-ups its decision tree adds from the results (for example LCP-Subparts when LCP is over 2.5 s, with the reason). core-web-vitals: LCP and CLS. audit: render-blocking resources, resource hints, critical CSS, TTFB, scripts, images and more. loading: TTFB, FCP, render-blocking, scripts and fonts. interaction: long tasks, animation frames, scroll and layout shifts while it scrolls the page, or while it runs interactions, which with a click or a key press also measure INP, Interactions and Input-Latency-Breakdown. ${THROTTLING_NOTE} ${QUEUE_NOTE} ${BASELINE_NOTE} ${DETAIL_NOTE} ${PAGE_DATA}`,
       inputSchema: z.object({
         url: HttpUrl,
         workflow: z.enum(Object.keys(WORKFLOWS)).default("core-web-vitals"),
         viewport: z.enum(VIEWPORTS).default("mobile").describe("Device size of the page"),
         waitMs: z.number().int().min(0).max(10000).default(3000).describe("Wait after the load event before running the workflow, in ms"),
+        cpu: Cpu,
+        network: Network,
+        interactions: Interactions,
         runs: Runs,
         detail: Detail,
         baseline: Baseline,
@@ -441,6 +487,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
         viewport: z.enum(VIEWPORTS),
         navMs: z.number(),
         pageErrors: z.array(z.string()),
+        throttling: Throttling,
         results: z
           .array(z.looseObject({ id: z.string(), status: z.string() }).meta({ additionalProperties: true }))
           .describe("One object per step, in order, then the follow-ups, each with the reason it was added"),
@@ -450,7 +497,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
       }),
       annotations: { readOnlyHint: true, openWorldHint: true },
     },
-    async ({ url, workflow, viewport, waitMs, runs: count, detail, baseline, thresholds }, ctx) => {
+    async ({ url, workflow, viewport, waitMs, cpu, network, interactions, runs: count, detail, baseline, thresholds }, ctx) => {
       let base;
       try {
         base = baselineFor({ baseline, thresholds });
@@ -459,15 +506,19 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
       }
       try {
         const { conditions, run } = await measureInTurn(
-          { viewport, workflow, waitMs },
-          (onProgress, signal) => runMeasurement({ url, workflow: WORKFLOWS[workflow], rules: RULES, waitMs, viewport: VIEWPORT_PRESETS[viewport], onProgress, signal }),
+          { viewport, workflow, waitMs, cpu, network },
+          (onProgress, signal) => runMeasurement({ url, workflow: WORKFLOWS[workflow], rules: RULES, waitMs, viewport: VIEWPORT_PRESETS[viewport], cpu, network, interactions, onProgress, signal }),
           count,
           ctx
         );
         // The runner explains a skipped step with the flag of the CLI; here the tools are what the model has
         const results = run.results.map((r) =>
           r.status === "skipped"
-            ? { ...r, reason: "This step measures clicks and key presses: open the page with open_page and this snippet in track, use it with interact, and read it with read_results." }
+            ? {
+                ...r,
+                reason:
+                  "This step measures clicks and key presses: run the workflow with interactions that click or type on an element of the page, or open the page with open_page and this snippet in track, use it with interact, and read it with read_results.",
+              }
             : r
         );
         const shaped = shapeResults(results, detail);
@@ -477,7 +528,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
           .filter((r) => r.status === "skipped")
           .map((r) => WORKFLOWS[workflow].steps.find((s) => s.id === r.id)?.path)
           .filter(Boolean);
-        const nextSteps = skipped.length ? [trackingCall({ paths: skipped, url, viewport })] : [];
+        const nextSteps = skipped.length ? inputStepsCalls({ workflow, paths: skipped, url, viewport, waitMs, cpu, network }) : [];
         return toolResult({
           url,
           runId,
@@ -486,6 +537,7 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
           viewport,
           navMs: run.navMs,
           pageErrors: run.pageErrors,
+          ...(run.throttling ? { throttling: run.throttling } : {}),
           ...(run.runs ? { runs: run.runs } : {}),
           ...(base ? { baseline: compareWithBaseline(base, current) } : {}),
           ...(nextSteps.length ? { nextSteps } : {}),
@@ -558,23 +610,26 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
     {
       title: "Open a page",
       description:
-        `Opens the URL in a headless Chromium that stays open between calls, and installs the snippets that record interactions (INP, Interactions, Input-Latency-Breakdown, and the other tracking snippets in list_snippets). Returns a sessionId for interact, read_results and close_page. At most 3 pages are open at a time, and a page closes after 10 minutes without use. ${PAGE_DATA}`,
+        `Opens the URL in a headless Chromium that stays open between calls, and installs the snippets that record interactions (INP, Interactions, Input-Latency-Breakdown, and the other tracking snippets in list_snippets). Returns a sessionId for interact, read_results and close_page. ${THROTTLING_NOTE} The throttling stays for the interactions on the page. At most 3 pages are open at a time, and a page closes after 10 minutes without use. ${PAGE_DATA}`,
       inputSchema: z.object({
         url: HttpUrl,
         track: z.array(z.string()).min(1).describe("The tracking snippets to install, by name, alias or Category/Name"),
         viewport: z.enum(VIEWPORTS).default("mobile").describe("Device size of the page"),
         waitMs: z.number().int().min(0).max(10000).default(1000).describe("Wait after the load event before installing the snippets, in ms"),
+        cpu: Cpu,
+        network: Network,
       }),
       outputSchema: z.object({
         sessionId: z.string(),
         url: z.string(),
         viewport: z.enum(VIEWPORTS),
         navMs: z.number(),
+        throttling: Throttling,
         tracking: z.array(z.object({ snippet: z.string(), status: z.string() })).describe("The installed snippets"),
       }),
       annotations: { readOnlyHint: true, openWorldHint: true },
     },
-    withSession(async ({ url, track, viewport, waitMs }, ctx) => {
+    withSession(async ({ url, track, viewport, waitMs, cpu, network }, ctx) => {
       const items = [];
       for (const name of track) {
         let path;
@@ -600,6 +655,8 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
           throw err;
         }
         try {
+          // Before the load, as the runner applies it: the load and every interaction run throttled
+          await applyThrottling(session.context, session.page, { cpu, network });
           const navStart = Date.now();
           await session.page.goto(url, { waitUntil: "load", timeout: NAV_TIMEOUT_MS });
           if (waitMs > 0) await session.page.waitForTimeout(waitMs);
@@ -609,7 +666,8 @@ export function createServer({ launchBrowser = () => launchChromium(), maxPages,
           if (limit.aborted) return toolError(`Opening the page failed: ${stoppedAnswering(callLimitMs)}`);
           session.stopListening();
           const tracking = session.tracking.map(({ id, status }) => ({ snippet: id, status }));
-          return toolResult({ sessionId: session.id, url, viewport, navMs, tracking });
+          const throttling = throttlingOf({ cpu, network });
+          return toolResult({ sessionId: session.id, url, viewport, navMs, ...(throttling ? { throttling } : {}), tracking });
         } catch (err) {
           await sessions.close(session.id);
           if (limit.aborted) return toolError(`Opening the page failed: ${stoppedAnswering(callLimitMs)}`);

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();

package/src/runs.js

@@ -13,7 +13,7 @@ export const MAX_RUNS = 9;
 export const MEDIAN_METRICS = ["LCP", "FCP", "TTFB", "CLS", "INP", "navMs"];
 
 // Without --median-by, the median follows the first of these that the runs measured
-const DEFAULT_ORDER = ["LCP", "FCP", "TTFB", "navMs"];
+const DEFAULT_ORDER = ["LCP", "FCP", "TTFB", "INP", "navMs"];
 
 const SUMMARY_METRICS = MEDIAN_METRICS.filter((metric) => metric !== "navMs");
 

package/src/throttling.js

@@ -10,10 +10,13 @@ export const NETWORK_PRESETS = {
   "3g": { title: "3G", download: (500 * 1000) / 8 * 0.8, upload: (500 * 1000) / 8 * 0.8, latency: 400 * 5 },
 };
 
+// The smallest CPU factor, no slowdown, for --cpu and the cpu of the tools of the MCP server
+export const MIN_CPU_FACTOR = 1;
+
 // The factor given to --cpu, or null when it is not a number of at least 1
 export function parseCpuFactor(raw) {
   const factor = Number(raw);
-  return raw.trim() !== "" && Number.isFinite(factor) && factor >= 1 ? factor : null;
+  return raw.trim() !== "" && Number.isFinite(factor) && factor >= MIN_CPU_FACTOR ? factor : null;
 }
 
 const NETWORK_VALUES = ["downloadKbps", "uploadKbps", "latencyMs"];