diff --git a/docs/output.md b/docs/output.md
index ba3cd6c..71b0ccd 100644
--- a/docs/output.md
+++ b/docs/output.md
@@ -65,6 +65,7 @@ per-shot output when piped, `--no-progress` the summary on a terminal.
 | `findings: N repeated on 2+ routes` | After the routes: the same `dom` entry, text line, `fonts` face or element-less band delta (`band -24px`) on two or more routes, once per line with `×N routes` and where (`/a@1440,375`, then `+N routes`), most widespread first, accepted ones aside. Text lines seen on exactly the same routes and widths share one line, `text -"Users" -"Billing" -"Docs" (+9 more)` (a nav folded into a menu button), and N counts lines as printed. Top 20; `summary.findings` in results.json has every finding, one per text line. One cause behind many rows: fix it once. A selector names an element per page, so the same path may be a different element on another route: check one crop. |
 | `computed: N findings` | With `--computed`: each `key prop left→right` once, with the routes and widths it was seen at; `dom identical`: the markup matches apart from asset hashes and generated class names, so look at CSS or script. See [below](#computed-styles---computed). |
 | `rules: N changed groups` | With `--computed`: style rules only one side has, by stylesheet and `@media`, and whether any shot had an element they could style. `matched nothing`: the run proved nothing about those rules. See [below](#rule-coverage). |
+| `prefixes: N prefixed declarations only one side has` | With `--computed`: `-webkit-`, `-moz-`, `-ms-` and `-o-` declarations in one side's CSS source only, which Chrome's parsed rules can't show. See [below](#vendor-prefixes). |
 | `aria: identical on N of M route(s)` | With `--aria`: routes whose accessibility tree matches at every width, then each differing route's lines, `+` left only, `-` right only. See [below](#aria-snapshots---aria). |
 | `crops …` | Up to 3 PNGs per comparison, worst first, relative to `results.json`. Left is on top or on the left, and the change is boxed in red. |
 | `ERROR …` | Unmeasured, which is neither a pass nor a fail. Exits 3. |
@@ -317,6 +318,34 @@ rules: 3 changed groups, 1 never matched, 2 matched on some shots
   rules then show as one side's. renderdiff's own CSS (hidden selectors, stilled animations,
   `extraCss`) isn't read.
 
+### Vendor prefixes
+
+Chrome parses `-webkit-user-select: none` and `user-select: none` into the same rule, so a lint
+autofix that drops a prefix Safari still needs is no pixel change and no rule change. So
+`--computed` also reads each side's CSS as written and counts its prefixed properties:
+
+```
+prefixes: 3 prefixed declarations only one side has
+  only left has: -webkit-background-clip: text; -webkit-text-size-adjust: 100%; -webkit-user-select: none  /a@1440,375
+```
+
+- The source is every stylesheet the page loaded, as served (cross-origin and `@import`ed ones
+  too), and the text of every `<style>`, open shadow roots included. Frames aren't read.
+- What counts is how many declarations of each prefixed property a side has; which selector,
+  rule or file holds them, and their values, don't. So a dropped prefix is one fewer
+  `-webkit-user-select` on that side, while minifying (`0.3s` → `.3s`), reordering, moving a
+  declaration between files or a new asset hash is no change. The value is shown as context:
+  that side's declarations of the property, ones the other side lacks as written first.
+- Prefixed selectors (`::-webkit-scrollbar`), media features and values (`-webkit-box`) aren't
+  read.
+- Up to 10 declarations per side shown; results.json has them all. `prefixes: no prefixed
+  declaration differs between the sides`: the sources hold the same ones.
+- Informational, like `rules:`: it never changes the exit code.
+- CSS with no source text isn't seen: rules a script adds with `insertRule`, constructed
+  (adopted) stylesheets, and `style` attributes.
+- A third-party sheet that changes between loads (an ad or chat widget) shows as prefixes
+  either side has; block it with `blockUrlPatterns` in the config.
+
 ## ARIA snapshots (`--aria`)
 
 With `--aria`, after the shot (and `--computed`) renderdiff takes Playwright's ARIA snapshot
@@ -531,7 +560,8 @@ file, not each line), scores rounded down to four decimals (so a shot that diffe
       "fonts": { "added": [], "removed": ["Inter 600"] },   // web font faces one side loaded; absent when equal
       "masked": ["rotating quote (data-renderdiff-mask)"],   // absent unless a side marked elements data-renderdiff-mask
       "computed": { "dom": 1, "changes": [], "truncated": 0, "unmatched": { "left": [], "right": ["body > nav > a[href=\"/pricing\"]"] },
-        "rules": [{ "side": "left", "sheet": "docs.css", "conditions": ["@media (width >= 60em)"], "rules": 5, "elements": 67 }] },   // --computed only; null: snapshot failed, "computedError" says why; rules: one-sided rule groups, elements they could style here
+        "rules": [{ "side": "left", "sheet": "docs.css", "conditions": ["@media (width >= 60em)"], "rules": 5, "elements": 67 }],
+        "prefixes": { "left": ["-webkit-user-select: none"], "right": [] } },   // --computed only; null: snapshot failed, "computedError" says why; rules: one-sided rule groups, elements they could style here; prefixes: { left, right }, prefixed declarations only that side's CSS source has
       "aria": { "added": ["- text: Buy now"], "removed": ["- button \"Buy now\""], "truncated": 0 },   // --aria only; both empty: identical; null: snapshot failed, "ariaError" says why
       "images": { "left": "about.1440.left.png", "right": "about.1440.right.png", "diff": "about.1440.diff.png" },   // packed: .webp, right may name left's file, no diff when diffPixels is 0
       "crops": [{
@@ -552,7 +582,8 @@ file, not each line), scores rounded down to four decimals (so a shot that diffe
     "stale": [],                  // accepted entries the run measured but didn't see
     "findings": [],               // { finding, selector?, at: [{ url, widths }] }, seen on 2+ routes
     "computed": [],               // --computed: { key, prop, values: [left, right], at: [{ url, widths }] }
-    "rules": []                   // --computed: { side, sheet, conditions, rules, matched: [{ url, widths }], unmatched: [{ url, widths }] }
+    "rules": [],                  // --computed: { side, sheet, conditions, rules, matched: [{ url, widths }], unmatched: [{ url, widths }] }
+    "prefixes": []                // --computed: { side, declaration, at: [{ url, widths }] }
   }
 }
 ```
diff --git a/skills/renderdiff/SKILL.md b/skills/renderdiff/SKILL.md
index a38a4c6..7da5dbc 100644
--- a/skills/renderdiff/SKILL.md
+++ b/skills/renderdiff/SKILL.md
@@ -20,6 +20,7 @@ the § named at each step. Setting up a project (`/renderdiff init`): [init.md](
 | Change | Run |
 | --- | --- |
 | CSS only, markup untouched (refactor, dead-CSS removal, token swap) | pixels + `--computed`. First diff the two builds (§ Reference and routes): if only asset hashes differ, or every changed rule means the same, no shots are needed; otherwise shoot the routes the changed rules reach. Expect `dom identical` on every route: then each `computed:` finding is a real style change, even on a clean route. A changed rule that matched nothing (`rules:`) means the run proved nothing about it: add a route or hook that reaches it. `dom differs`: often a wrapper's class changed, re-keying its subtree (§ `--computed`). Hover menus and open menus aren't shot without a `before` hook that ends waiting for the open state, and dead-CSS removal breaks exactly those. |
+| Lint autofix, Autoprefixer or browserslist change | pixels + `--computed`; read `prefixes:` and decide whether each dropped prefix's browsers still need it. |
 | Markup changes (framework, template or component migration) | pixels, plus `--aria`: `aria: identical` means a screen reader gets the same page. `--computed` findings would only be hints. |
 | Dependency or build upgrade | pixels, plus `--computed` if the markup should be identical. |
 | One component | pixels with `--selector <sel>` or `'/route @sel'`. |
diff --git a/skills/renderdiff/reference.md b/skills/renderdiff/reference.md
index 84f53cf..069dace 100644
--- a/skills/renderdiff/reference.md
+++ b/skills/renderdiff/reference.md
@@ -228,6 +228,9 @@ computed: 2 findings; dom identical on 2 of 3 route(s), differs /pricing (1), so
   that reaches them. Rules compare as Chrome parses them: `rgb()` notation is no change,
   `min-width:` → `width >=` is. Details and limits: docs/output.md § Rule coverage in the
   renderdiff repo.
+- `prefixes: N prefixed declarations only one side has`: `-webkit-`/`-moz-`/`-ms-`/`-o-`
+  properties one side's CSS source declares more often. Details and limits: docs/output.md
+  § Vendor prefixes in the renderdiff repo.
 
 ## `--aria`
 
@@ -449,15 +452,16 @@ commas: `JSON.parse` the whole file, not each line. Paths are relative to the ou
   (`kind`, each side's box with `h` 0 at an insertion point, `layout`, `scale`, `clipped`);
   `accepted`; `rightReplayedFrom`; with `--computed`, `computed` (`dom`, 0 = identical;
   `changes` `{ key, prop, values }`, first 500; `truncated`; `unmatched`; `rules`
-  `{ side, sheet, conditions, rules, elements }`) or null with
+  `{ side, sheet, conditions, rules, elements }`; `prefixes` `{ left, right }`) or null with
   `computedError`; with `--aria`, `aria` (`added`, `removed`, first 200 each, both empty =
   identical; `truncated`) or null with `ariaError`.
 - **`summary`:** `compared`, `errors`, `mean` and `worst` (accepted shots aside),
   `belowThreshold`, `differing` (unaccepted shots with any differing pixel; without
   `--threshold`, any exits 1), `accepted`, `stale`, `findings` (each `dom` entry, text line
   or element-less band on 2+ routes once: `finding`, `selector?`, `at: [{ url, widths }]`),
-  and with `--computed` `computed` (each change once with `at: [{ url, widths }]`) and `rules`
-  (each rule group once with `matched` and `unmatched` `[{ url, widths }]`).
+  and with `--computed` `computed` (each change once with `at: [{ url, widths }]`), `rules`
+  (each rule group once with `matched` and `unmatched` `[{ url, widths }]`) and `prefixes`
+  (each declaration once: `side`, `declaration`, `at`).
 - **`meta`:** origins, widths, threshold, `clock`, block patterns, hidden selectors, mask
   reasons, `browser` (`chromium`, or `chrome` after a fallback), storage state file names,
   `config` hash, `rightReplayedFrom`, `freezeVideo`, `lottieFrame` (only when set), `platform`, `rerun` (`{ rerun, reused }` or
diff --git a/src/capture.ts b/src/capture.ts
index a174219..0164591 100644
--- a/src/capture.ts
+++ b/src/capture.ts
@@ -153,6 +153,8 @@ const MAX_PAGE_AREA = 1440 * 40_000;
 const network = new WeakMap<Page, { open: Set<Request>; last: number; failed: Set<string> }>();
 /** Each page's last main-frame document response; redirect hops come first, so it is the final one. */
 const doc = new WeakMap<Page, Response>();
+/** With `--computed`: the bodies of this load's main-frame stylesheets, as served. */
+const sources = new WeakMap<Page, Promise<string>[]>();
 
 const html = (r: Response) => {
   const type = r.headers()["content-type"];
@@ -201,9 +203,17 @@ export async function prepare(page: Page, cfg: ResolvedConfig, now: number): Pro
     // Aborted: cancelled by the page or by the next navigation, not a load that failed.
     if (r.failure()?.errorText !== "net::ERR_ABORTED") sheet(r);
   });
+  if (cfg.computed) sources.set(page, []);
   page.on("response", (r) => {
     if (r.status() >= 400) sheet(r.request());
-    if (r.request().isNavigationRequest() && r.frame() === page.mainFrame()) doc.set(page, r);
+    if (r.request().isNavigationRequest() && r.frame() === page.mainFrame()) {
+      doc.set(page, r);
+      // A new document, from the load, a hook or a redirect; a pushState has no response.
+      sources.get(page)?.splice(0);
+    }
+    // Routing is always on, so the HTTP cache is off and no sheet is a bodiless 304; read now, before navigating drops it.
+    if (r.ok() && r.request().resourceType() === "stylesheet" && r.frame() === page.mainFrame())
+      sources.get(page)?.push(r.text().catch(() => ""));
   });
   // A request the old document left open never finishes or fails, so it can't hold the next load.
   page.on("framenavigated", (f) => {
@@ -262,6 +272,21 @@ export async function prepare(page: Page, cfg: ResolvedConfig, now: number): Pro
   });
 }
 
+/** `--computed`: this document's CSS as written, which Chromium's CSSOM isn't: stylesheet bodies and `<style>` text. */
+export async function sheetSources(page: Page): Promise<string[]> {
+  const inline = await page.evaluate(() => {
+    const out: string[] = [];
+    const walk = (root: Document | ShadowRoot) =>
+      root.querySelectorAll("*").forEach((e) => {
+        if (e.localName === "style") out.push(e.textContent ?? "");
+        if (e.shadowRoot) walk(e.shadowRoot);
+      });
+    walk(document);
+    return out;
+  });
+  return [...(await Promise.all(sources.get(page) ?? [])), ...inline];
+}
+
 /** Not addStyleTag: it fails on any CSP violation logged meanwhile, and a <style> is subject to style-src. */
 function adoptCss(css: string) {
   const sheet = new CSSStyleSheet();
diff --git a/src/computed.ts b/src/computed.ts
index f88024d..3b61404 100644
--- a/src/computed.ts
+++ b/src/computed.ts
@@ -1,6 +1,7 @@
 import type { Page } from "playwright";
 import { textDiff } from "./compare.ts";
 import { name } from "./config.ts";
+import { andMore } from "./format.ts";
 import { MAX_STATES, SNAP_PROPS } from "./locate.ts";
 import type { ComparedResult, RouteResult } from "./report.ts";
 
@@ -33,6 +34,16 @@ export interface ComputedDiff {
   unchecked?: number;
   /** Style rules only that side has, grouped by stylesheet and enclosing at-rules; absent when not read. */
   rules?: RuleGroup[];
+  /** Vendor-prefixed declarations in the CSS source only that side has, each once; absent when not read. */
+  prefixes?: { left: string[]; right: string[] };
+}
+
+/** One prefixed declaration only one side has, with every route and width it was seen at. */
+export interface PrefixFinding {
+  side: "left" | "right";
+  /** As written, whitespace normalised: `-webkit-user-select: none`. */
+  declaration: string;
+  at: Finding["at"];
 }
 
 export interface RuleGroup {
@@ -447,6 +458,67 @@ function oneSided(a: string[], b: string[]): number[] {
   });
 }
 
+/** The `-webkit-`/`-moz-`/`-ms-`/`-o-` declarations in CSS source, whitespace normalised. */
+export function prefixed(css: string): string[] {
+  // A value is quoted strings, parenthesised groups (a data URI's `;`) and other text, each one way only.
+  const decl =
+    /(?<![\w-])(-(?:webkit|moz|ms|o)-[a-z-]+)\s*:((?:"[^"]*"|'[^']*'|\([^)]*\)|[^;{}"'(])+)(?=[;}])/gi;
+  return [...uncomment(css).matchAll(decl)].map(
+    ([, prop, value]) =>
+      `${prop!.toLowerCase()}: ${value!
+        .trim()
+        .replace(/\s+/g, " ")
+        .replace(/\s*!\s*important$/i, " !important")}`,
+  );
+}
+
+/** `css` without its comments; a `/*` inside a string or parentheses (`url(/img/*.png)`) isn't one. */
+function uncomment(css: string): string {
+  const out: string[] = [];
+  let [from, quote, depth] = [0, "", 0];
+  for (let i = 0; i < css.length; i++) {
+    const c = css[i];
+    if (quote) {
+      if (c === "\\") i++;
+      else if (c === quote) quote = "";
+    } else if (c === '"' || c === "'") quote = c;
+    else if (c === "(") depth++;
+    else if (c === ")") depth = Math.max(0, depth - 1);
+    else if (!depth && c === "/" && css[i + 1] === "*") {
+      out.push(css.slice(from, i));
+      const end = css.indexOf("*/", i + 2);
+      i = end < 0 ? css.length : end + 1;
+      from = i + 1;
+    }
+  }
+  out.push(css.slice(from));
+  return out.join("");
+}
+
+/**
+ * Per side, the prefixed properties it has more declarations of, as that many of its
+ * declarations, ones the other side lacks verbatim first. Counting names, not values, keeps a
+ * minifier's `0.3s`→`.3s` from reading as a pair.
+ */
+export function prefixDiff(left: string[], right: string[]): { left: string[]; right: string[] } {
+  const [l, r] = [left, right].map((texts) => texts.flatMap(prefixed));
+  const prop = (d: string) => d.slice(0, d.indexOf(":"));
+  const only = (a: string[], b: string[]) => {
+    const extra = new Map<string, number>();
+    for (const d of a) extra.set(prop(d), (extra.get(prop(d)) ?? 0) + 1);
+    for (const d of b) extra.set(prop(d), (extra.get(prop(d)) ?? 0) - 1);
+    const picked: string[] = [];
+    for (const i of new Set([...oneSided(a, b), ...a.keys()])) {
+      const n = extra.get(prop(a[i]!))!;
+      if (n <= 0) continue;
+      extra.set(prop(a[i]!), n - 1);
+      picked.push(a[i]!);
+    }
+    return [...new Set(picked)].sort();
+  };
+  return { left: only(l!, r!), right: only(r!, l!) };
+}
+
 /** `--computed`'s rule coverage: the style rules only one side has, and what each side's could style. */
 export async function ruleCoverage(
   pages: [Page, Page],
@@ -531,6 +603,46 @@ export function groupRules(results: RouteResult[]): RuleFinding[] {
   return [...out.values()].sort((a, b) => rank(a) - rank(b));
 }
 
+/** Each one-sided prefixed declaration once, most widespread first. */
+export function groupPrefixes(results: RouteResult[]): PrefixFinding[] {
+  const out = new Map<string, PrefixFinding>();
+  for (const r of computedOf(results)) {
+    for (const side of ["left", "right"] as const) {
+      for (const declaration of r.computed!.prefixes?.[side] ?? []) {
+        const id = JSON.stringify([side, declaration]);
+        const f = out.get(id) ?? { side, declaration, at: [] };
+        out.set(id, f);
+        addAt(f.at, r);
+      }
+    }
+  }
+  const shots = (f: PrefixFinding) => f.at.reduce((n, a) => n + a.widths.length, 0);
+  return [...out.values()].sort(
+    (a, b) => shots(b) - shots(a) || a.declaration.localeCompare(b.declaration),
+  );
+}
+
+/** The `prefixes:` block: per side, the prefixed declarations only it has, and where. */
+function fmtPrefixes(rows: ComparedResult[]): string[] {
+  if (!rows.some((r) => r.computed?.prefixes)) return [];
+  const all = groupPrefixes(rows);
+  if (!all.length) return ["prefixes: no prefixed declaration differs between the sides"];
+  const out = [
+    `prefixes: ${all.length} prefixed declaration${all.length === 1 ? "" : "s"} only one side has`,
+  ];
+  for (const side of ["left", "right"] as const) {
+    const fs = all.filter((f) => f.side === side);
+    if (!fs.length) continue;
+    const at: Finding["at"] = [];
+    for (const r of rows) if (r.computed?.prefixes?.[side].length) addAt(at, r);
+    const shown = fs.slice(0, PREFIXES_SHOWN).map((f) => f.declaration);
+    out.push(
+      `  only ${side} has: ${shown.join("; ")}${andMore(fs.length, PREFIXES_SHOWN)}  ${fmtAt(at)}`,
+    );
+  }
+  return out;
+}
+
 const fmtGroup = (f: RuleFinding) =>
   `${f.side === "left" ? "+" : "-"}${[f.sheet, ...f.conditions].join(" ")} (${f.rules} rule${f.rules === 1 ? "" : "s"})`;
 
@@ -559,6 +671,7 @@ function fmtRules(rows: ComparedResult[]): string[] {
 
 /** Findings shown in the console summary; results.json has them all. */
 export const SHOWN = 20;
+const PREFIXES_SHOWN = 10;
 const AT_ROUTES = 3;
 /** Unmatched routes, and keys per route, in the console summary. */
 const UNMATCHED_SHOWN = 5;
@@ -621,7 +734,7 @@ export function fmtComputed(results: RouteResult[], routes: string[]): string[]
   out.push(...unmatched.slice(0, UNMATCHED_SHOWN));
   if (unmatched.length > UNMATCHED_SHOWN)
     out.push(`  (+${unmatched.length - UNMATCHED_SHOWN} more routes with unmatched elements)`);
-  return [...out, ...fmtRules(rows)];
+  return [...out, ...fmtRules(rows), ...fmtPrefixes(rows)];
 }
 
 // ponytail: raw indented lines, so a wrapper role added or removed re-indents everything below it; key lines by role path if that gets noisy
diff --git a/src/report.ts b/src/report.ts
index f6d9989..f464b3c 100644
--- a/src/report.ts
+++ b/src/report.ts
@@ -8,11 +8,13 @@ import {
   fmtAria,
   fmtComputed,
   groupFindings,
+  groupPrefixes,
   groupRules,
   SHOWN,
   type AriaDiff,
   type ComputedDiff,
   type Finding,
+  type PrefixFinding,
   type RuleFinding,
 } from "./computed.ts";
 import type { Band, Box, Region, TextDiff } from "./compare.ts";
@@ -175,6 +177,8 @@ export interface Summary {
   computed?: Finding[];
   /** With `--computed`: each one-sided rule group once, with where it matched an element and where none. */
   rules?: RuleFinding[];
+  /** With `--computed`: each prefixed declaration in the CSS source only one side has, once, with where. */
+  prefixes?: PrefixFinding[];
 }
 
 /** An element change, text line or element-less band delta, as the summary prints it. */
@@ -294,7 +298,11 @@ export function writeResults(
       stale,
       findings: pixelFindings(results),
       ...(compared.some((r) => "computed" in r)
-        ? { computed: groupFindings(results), rules: groupRules(results) }
+        ? {
+            computed: groupFindings(results),
+            rules: groupRules(results),
+            prefixes: groupPrefixes(results),
+          }
         : {}),
     },
   };
diff --git a/src/run.ts b/src/run.ts
index 310225d..b775556 100644
--- a/src/run.ts
+++ b/src/run.ts
@@ -14,6 +14,7 @@ import {
   HookError,
   prepare,
   readText,
+  sheetSources,
   step,
   type Shot,
 } from "./capture.ts";
@@ -24,6 +25,7 @@ import {
   fmtAria,
   fmtComputed,
   pageError,
+  prefixDiff,
   ruleCoverage,
 } from "./computed.ts";
 import { locate, MAX_SPOTS, severity, snapshotStates, type ElementDiff } from "./locate.ts";
@@ -585,20 +587,23 @@ export async function run({
               })),
             ])
           : null;
-        // Outside the snapshot's race, so a slow read loses only `rules`.
-        const cov = computed?.computed
-          ? await Promise.race([
-              ruleCoverage([pages.left, pages.right], [pages.left.url(), pages.right.url()]).catch(
-                () => null,
+        // Outside the snapshot's race, and each in its own, so a slow read loses only its part.
+        const bounded = <T>(p: Promise<T>) =>
+          Promise.race([p.catch(() => null), sleep(RULES_TIMEOUT, null, { ref: false })]);
+        const [cov, sources] = computed?.computed
+          ? await Promise.all([
+              bounded(
+                ruleCoverage([pages.left, pages.right], [pages.left.url(), pages.right.url()]),
               ),
-              sleep(RULES_TIMEOUT, null, { ref: false }),
+              bounded(Promise.all([sheetSources(pages.left), sheetSources(pages.right)])),
             ])
-          : null;
+          : [null, null];
         if (cov) {
           computed!.computed!.rules = cov.rules;
           cov.unreadable[0].forEach((h) => unreadable.left.add(h));
           cov.unreadable[1].forEach((h) => unreadable.right.add(h));
         }
+        if (sources) computed!.computed!.prefixes = prefixDiff(...sources);
         // Masked content is noise here too; every next job reloads the page, so no restore.
         const tree = async (page: Page, side: "left" | "right") => {
           for (const m of masksFor(cfg, page, route))
diff --git a/tests/fixtures/pages/README.md b/tests/fixtures/pages/README.md
index 5f34a79..e404ccc 100644
--- a/tests/fixtures/pages/README.md
+++ b/tests/fixtures/pages/README.md
@@ -20,7 +20,7 @@ Three groups:
   elements each change names (`margin`, `color`, `nav`), and a lost `::before` line and a
   re-parented pairing (`divider`).
 - **Guard rails** — `blank`, `tall`, `animated`, `lazy`, `lazy-deep`, `lazy-js`, `lazy-grow`, `consent`,
-  `drifting`, `tracker`, `clock`, `ticker`, `unsettled`, `unsettled-once`, `sprite`, `short`, `tall-region`, `reorder`, `stripe`, `frameset`, `menu`, `scroll-spy`, `signed-in`, `fixed`, `inserted`, `labelled`, `broken-asset`, `fonts`, `media`, `long`, `video`, `video-seek`, `lottie`, `hang`, `origin`, `cooperate`, `mask-geometry`, `bistable`, `offcanvas`, `appshell`, `smooth-scroll`, `rules`, `reflowing`, `waapi`, `geometry`, `stalled-frame`.
+  `drifting`, `tracker`, `clock`, `ticker`, `unsettled`, `unsettled-once`, `sprite`, `short`, `tall-region`, `reorder`, `stripe`, `frameset`, `menu`, `scroll-spy`, `signed-in`, `fixed`, `inserted`, `labelled`, `broken-asset`, `fonts`, `media`, `long`, `video`, `video-seek`, `lottie`, `hang`, `origin`, `cooperate`, `mask-geometry`, `bistable`, `offcanvas`, `appshell`, `smooth-scroll`, `rules`, `prefix`, `prefix-same`, `reflowing`, `waapi`, `geometry`, `stalled-frame`.
   One per defence in `src/capture.ts` / `src/config.ts`.
 
 ## Authoring rules
diff --git a/tests/fixtures/pages/prefix-same/left.html b/tests/fixtures/pages/prefix-same/left.html
new file mode 100644
index 0000000..c7e39ad
--- /dev/null
+++ b/tests/fixtures/pages/prefix-same/left.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Vendor prefixes, rewritten</title>
+<link rel="stylesheet" href="/shared/base.css">
+<link rel="stylesheet" href="/shared/prefix/site.css">
+<style>
+/* GUARD RAIL for --computed's prefix check: the same prefixed declarations, minified,
+   reordered, moved between a style element and the sheet, and under a hashed file name on
+   the right. None of that is a finding. */
+.clip { display: inline-block; font-size: 48px; color: transparent; }
+.pick { -webkit-user-select: none; }
+</style>
+</head>
+<body>
+<div class="page">
+<h1>Vendor prefixes, rewritten</h1>
+<p class="lede">Both sides hold the same three -webkit- declarations. Only where they are written, and how, differs, so the prefix check finds nothing.</p>
+<p class="clip">Gradient text</p>
+<p class="pick">This line is not selectable.</p>
+<section class="notes">
+<h2>Notes</h2>
+<p>A build that minifies or fingerprints its stylesheets keeps every declaration, so it is no change.</p>
+</section>
+</div>
+</body>
+</html>
diff --git a/tests/fixtures/pages/prefix-same/right.html b/tests/fixtures/pages/prefix-same/right.html
new file mode 100644
index 0000000..dc1b581
--- /dev/null
+++ b/tests/fixtures/pages/prefix-same/right.html
@@ -0,0 +1,28 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Vendor prefixes, rewritten</title>
+<link rel="stylesheet" href="/shared/base.css">
+<link rel="stylesheet" href="/shared/prefix/site.3f9a8c1d.css">
+<style>
+/* GUARD RAIL for --computed's prefix check: the same prefixed declarations, minified,
+   reordered, moved between a style element and the sheet, and under a hashed file name on
+   the right. None of that is a finding. */
+.clip { display: inline-block; font-size: 48px; color: transparent; }
+
+</style>
+</head>
+<body>
+<div class="page">
+<h1>Vendor prefixes, rewritten</h1>
+<p class="lede">Both sides hold the same three -webkit- declarations. Only where they are written, and how, differs, so the prefix check finds nothing.</p>
+<p class="clip">Gradient text</p>
+<p class="pick">This line is not selectable.</p>
+<section class="notes">
+<h2>Notes</h2>
+<p>A build that minifies or fingerprints its stylesheets keeps every declaration, so it is no change.</p>
+</section>
+</div>
+</body>
+</html>
diff --git a/tests/fixtures/pages/prefix/left.html b/tests/fixtures/pages/prefix/left.html
new file mode 100644
index 0000000..4dd7325
--- /dev/null
+++ b/tests/fixtures/pages/prefix/left.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Vendor prefixes</title>
+<link rel="stylesheet" href="/shared/base.css">
+<link rel="stylesheet" href="/shared/prefix/link.left.css">
+<style>
+/* GUARD RAIL for --computed's prefix check. The left side writes four declarations with a
+   -webkit- prefix and the right without, as a lint autofix would: one here, one in the linked
+   sheet, one in the sheet it @imports, one in a sheet from another origin. Chromium renders both alike and its CSSOM reads
+   both as the unprefixed name, so only the CSS source tells them apart. */
+html { -webkit-text-size-adjust: 100%; }
+.clip { display: inline-block; font-size: 48px; color: transparent; background-image: linear-gradient(90deg, #0b5, #05b); }
+</style>
+<script>
+// localhost, not 127.0.0.1: the same fixture server on another origin.
+const cross = document.createElement("link");
+cross.rel = "stylesheet";
+cross.href = location.origin.replace("127.0.0.1", "localhost") + "/shared/prefix/cross.left.css";
+document.head.append(cross);
+</script>
+</head>
+<body>
+<div class="page">
+<h1>Vendor prefixes</h1>
+<p class="lede">Three declarations lost their -webkit- prefix on one side. Chromium honours both spellings, so the pixels match; Safari honours only the prefixed one.</p>
+<p class="clip">Gradient text</p>
+<p class="pick">This line is not selectable.</p>
+<section class="notes">
+<h2>Notes</h2>
+<p>The prefix check reads every stylesheet as served and every style element's text, so a declaration counts wherever it is written.</p>
+</section>
+</div>
+</body>
+</html>
diff --git a/tests/fixtures/pages/prefix/right.html b/tests/fixtures/pages/prefix/right.html
new file mode 100644
index 0000000..14ff063
--- /dev/null
+++ b/tests/fixtures/pages/prefix/right.html
@@ -0,0 +1,36 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Vendor prefixes</title>
+<link rel="stylesheet" href="/shared/base.css">
+<link rel="stylesheet" href="/shared/prefix/link.right.css">
+<style>
+/* GUARD RAIL for --computed's prefix check. The left side writes four declarations with a
+   -webkit- prefix and the right without, as a lint autofix would: one here, one in the linked
+   sheet, one in the sheet it @imports, one in a sheet from another origin. Chromium renders both alike and its CSSOM reads
+   both as the unprefixed name, so only the CSS source tells them apart. */
+html { text-size-adjust: 100%; }
+.clip { display: inline-block; font-size: 48px; color: transparent; background-image: linear-gradient(90deg, #0b5, #05b); }
+</style>
+<script>
+// localhost, not 127.0.0.1: the same fixture server on another origin.
+const cross = document.createElement("link");
+cross.rel = "stylesheet";
+cross.href = location.origin.replace("127.0.0.1", "localhost") + "/shared/prefix/cross.right.css";
+document.head.append(cross);
+</script>
+</head>
+<body>
+<div class="page">
+<h1>Vendor prefixes</h1>
+<p class="lede">Three declarations lost their -webkit- prefix on one side. Chromium honours both spellings, so the pixels match; Safari honours only the prefixed one.</p>
+<p class="clip">Gradient text</p>
+<p class="pick">This line is not selectable.</p>
+<section class="notes">
+<h2>Notes</h2>
+<p>The prefix check reads every stylesheet as served and every style element's text, so a declaration counts wherever it is written.</p>
+</section>
+</div>
+</body>
+</html>
diff --git a/tests/fixtures/shared/prefix/cross.left.css b/tests/fixtures/shared/prefix/cross.left.css
new file mode 100644
index 0000000..dd023fd
--- /dev/null
+++ b/tests/fixtures/shared/prefix/cross.left.css
@@ -0,0 +1 @@
+.pick { -webkit-user-select: none; }
diff --git a/tests/fixtures/shared/prefix/cross.right.css b/tests/fixtures/shared/prefix/cross.right.css
new file mode 100644
index 0000000..b997f6a
--- /dev/null
+++ b/tests/fixtures/shared/prefix/cross.right.css
@@ -0,0 +1 @@
+.pick { user-select: none; }
diff --git a/tests/fixtures/shared/prefix/import.left.css b/tests/fixtures/shared/prefix/import.left.css
new file mode 100644
index 0000000..fc6dbfc
--- /dev/null
+++ b/tests/fixtures/shared/prefix/import.left.css
@@ -0,0 +1 @@
+button { -webkit-appearance: none; }
diff --git a/tests/fixtures/shared/prefix/import.right.css b/tests/fixtures/shared/prefix/import.right.css
new file mode 100644
index 0000000..23f8924
--- /dev/null
+++ b/tests/fixtures/shared/prefix/import.right.css
@@ -0,0 +1 @@
+button { appearance: none; }
diff --git a/tests/fixtures/shared/prefix/link.left.css b/tests/fixtures/shared/prefix/link.left.css
new file mode 100644
index 0000000..979e231
--- /dev/null
+++ b/tests/fixtures/shared/prefix/link.left.css
@@ -0,0 +1,2 @@
+@import "import.left.css";
+.clip { -webkit-background-clip: text; }
diff --git a/tests/fixtures/shared/prefix/link.right.css b/tests/fixtures/shared/prefix/link.right.css
new file mode 100644
index 0000000..76e4e57
--- /dev/null
+++ b/tests/fixtures/shared/prefix/link.right.css
@@ -0,0 +1,2 @@
+@import "import.right.css";
+.clip { background-clip: text; }
diff --git a/tests/fixtures/shared/prefix/site.3f9a8c1d.css b/tests/fixtures/shared/prefix/site.3f9a8c1d.css
new file mode 100644
index 0000000..e943115
--- /dev/null
+++ b/tests/fixtures/shared/prefix/site.3f9a8c1d.css
@@ -0,0 +1 @@
+.clip{background-image:linear-gradient(90deg,#0b5,#05b);-webkit-background-clip:text}.pick{-webkit-user-select:none}html{-webkit-text-size-adjust:100%}
diff --git a/tests/fixtures/shared/prefix/site.css b/tests/fixtures/shared/prefix/site.css
new file mode 100644
index 0000000..d1d01bc
--- /dev/null
+++ b/tests/fixtures/shared/prefix/site.css
@@ -0,0 +1,9 @@
+/* prefix-same, left: pretty-printed, in source order. */
+html {
+  -webkit-text-size-adjust: 100%;
+}
+
+.clip {
+  -webkit-background-clip: text;
+  background-image: linear-gradient(90deg, #0b5, #05b);
+}
diff --git a/tests/helpers/corpus.ts b/tests/helpers/corpus.ts
index fa08c93..364c032 100644
--- a/tests/helpers/corpus.ts
+++ b/tests/helpers/corpus.ts
@@ -69,6 +69,8 @@ export const GUARDRAILS = [
   "appshell",
   "smooth-scroll",
   "rules",
+  "prefix",
+  "prefix-same",
   "reflowing",
   "waapi",
   "geometry",
diff --git a/tests/helpers/parse.ts b/tests/helpers/parse.ts
index f89e404..15415b3 100644
--- a/tests/helpers/parse.ts
+++ b/tests/helpers/parse.ts
@@ -53,6 +53,8 @@ export interface Summary {
   stale: string[];
   /** With `--computed`: the `rules:` line and the group lines under it; empty without one. */
   rules: string[];
+  /** With `--computed`: the `prefixes:` line and the side lines under it; empty without one. */
+  prefixes: string[];
   /** The `rerun:` line of a `--rerun-failed` run, else null. */
   rerun: { shots: number; routes: number; reused: number; untouched: number } | null;
   /** Each differing route: widths that were clean or accepted, then one row per collapsed width group. */
@@ -144,6 +146,7 @@ export function parseSummary(stdout: string): Summary {
     unstable: listed("unstable ≤100px"),
     stale,
     rules: /^rules: .*(?:\n  .*)*/m.exec(stdout)?.[0].split("\n") ?? [],
+    prefixes: /^prefixes: .*(?:\n  .*)*/m.exec(stdout)?.[0].split("\n") ?? [],
     rerun: rerun && {
       shots: Number(rerun[1]),
       routes: Number(rerun[2]),
diff --git a/tests/unit/computed.test.ts b/tests/unit/computed.test.ts
index b89eaa8..755d328 100644
--- a/tests/unit/computed.test.ts
+++ b/tests/unit/computed.test.ts
@@ -13,6 +13,8 @@ import {
   groupFindings,
   normalizeAssets,
   pageError,
+  prefixDiff,
+  prefixed,
   type Snapshot,
 } from "../../src/computed.ts";
 import { SNAP_PROPS } from "../../src/locate.ts";
@@ -414,6 +416,32 @@ describe("groupFindings", () => {
     );
   });
 
+  test("fmtComputed lists each side's prefixed declarations, capped, with where", () => {
+    const none = { dom: 0, changes: [], truncated: 0, unmatched: { left: [], right: [] } };
+    const many = Array.from({ length: 12 }, (_, i) => `-webkit-x${String(i).padStart(2, "0")}: 1`);
+    assert.deepEqual(
+      fmtComputed(
+        [
+          shot("/a", 1440, { computed: { ...none, prefixes: { left: many, right: [] } } }),
+          shot("/a", 375, { computed: { ...none, prefixes: { left: [], right: ["-moz-y: 2"] } } }),
+        ],
+        ["/a"],
+      ).filter((l) => /^(prefixes|  only)/.test(l)),
+      [
+        "prefixes: 13 prefixed declarations only one side has",
+        `  only left has: ${many.slice(0, 10).join("; ")} (+2 more)  /a@1440`,
+        "  only right has: -moz-y: 2  /a@375",
+      ],
+    );
+    assert.deepEqual(
+      fmtComputed(
+        [shot("/a", 1440, { computed: { ...none, prefixes: { left: [], right: [] } } })],
+        ["/a"],
+      ).at(-1),
+      "prefixes: no prefixed declaration differs between the sides",
+    );
+  });
+
   test("without --computed there is no block", () => {
     assert.deepEqual(fmtComputed([shot("/a", 1440, {})], ["/a"]), []);
   });
@@ -432,6 +460,78 @@ test("a snapshot error keeps the page's message, not page.evaluate's prefix or s
   assert.equal(pageError(new Error(timeout)), timeout);
 });
 
+describe("prefixed", () => {
+  test("reads declarations as written, comments dropped, whitespace and importance normalised", () => {
+    assert.deepEqual(
+      prefixed(`html{-webkit-text-size-adjust:100%}/* -moz-x: y; */
+        .a { -webkit-mask : linear-gradient( red , blue )  !important ; -MS-filter: none }`),
+      [
+        "-webkit-text-size-adjust: 100%",
+        "-webkit-mask: linear-gradient( red , blue ) !important",
+        "-ms-filter: none",
+      ],
+    );
+  });
+
+  test("a /* in url() or a string is no comment, and a data URI's ; stays in its value", () => {
+    assert.deepEqual(prefixed(".a{background:url(/img/*.png)} .b{-webkit-user-select:none}"), [
+      "-webkit-user-select: none",
+    ]);
+    assert.deepEqual(
+      prefixed('.a{content:"/*"} .b{-webkit-user-select:none} /* .c{-webkit-x:1} */'),
+      ["-webkit-user-select: none"],
+    );
+    assert.deepEqual(
+      prefixed(
+        '.a{-webkit-mask:url("data:image/svg+xml;utf8,<svg/>") center;-webkit-x:1 !IMPORTANT}',
+      ),
+      ['-webkit-mask: url("data:image/svg+xml;utf8,<svg/>") center', "-webkit-x: 1 !important"],
+    );
+  });
+
+  test("leaves out selectors, media features, values and unprefixed names", () => {
+    assert.deepEqual(
+      prefixed(`::-webkit-scrollbar:hover { width: 0 }
+        input::-webkit-inner-spin-button, a:focus { display: none }
+        @media (-webkit-min-device-pixel-ratio: 2) { .b { transition: -webkit-transform 1s } }
+        .c { user-select: none; x-webkit-y: 1 }`),
+      [],
+    );
+  });
+
+  test("a minifier's rewrite of a value is no finding; a dropped prefix still is", () => {
+    const none = { left: [], right: [] };
+    assert.deepEqual(
+      prefixDiff(
+        [".a { -webkit-transition: opacity 0.3s ease; }"],
+        [".a{-webkit-transition:opacity .3s ease}"],
+      ),
+      none,
+    );
+    assert.deepEqual(
+      prefixDiff(
+        [
+          ".a{-webkit-transition:opacity 0.3s;-webkit-user-select:none} .b{-webkit-user-select:none}",
+        ],
+        [".a{-webkit-transition:opacity .3s;user-select:none} .b{-webkit-user-select:none}"],
+      ),
+      { left: ["-webkit-user-select: none"], right: [] },
+    );
+  });
+
+  test("a side's extra copy is a finding; which file or rule holds it is not", () => {
+    const decl = "-webkit-user-select: none";
+    assert.deepEqual(prefixDiff([`.a{${decl}}`, `.b{${decl}}`], [`.z { ${decl}; }`]), {
+      left: [decl],
+      right: [],
+    });
+    assert.deepEqual(prefixDiff([`.a{${decl}}`, ".b{}"], [".b{}", `.c{${decl}}`]), {
+      left: [],
+      right: [],
+    });
+  });
+});
+
 describe("diffAria", () => {
   const same = { added: [], removed: [], truncated: 0 };
 
diff --git a/tests/visual/controls.test.ts b/tests/visual/controls.test.ts
index 6f07d83..0dd9253 100644
--- a/tests/visual/controls.test.ts
+++ b/tests/visual/controls.test.ts
@@ -729,6 +729,7 @@ test("--computed names the changed rule's property, once across widths, and the
       (f) => /swatch/.test(f.key) && f.prop === "background-color" && f.at[0]!.url === "/color",
     ),
   );
+  assert.deepEqual(summary.prefixes, [], context(r));
   // /margin's Contact chip only moved, so it is no finding of its own.
   assert.ok(!summary.computed!.some((f) => /#contact/.test(f.key)), context(r));
   const inserted = rows.find((x) => x.url === "/inserted" && x.status === "compared");
diff --git a/tests/visual/guardrails.test.ts b/tests/visual/guardrails.test.ts
index 6715647..8179918 100644
--- a/tests/visual/guardrails.test.ts
+++ b/tests/visual/guardrails.test.ts
@@ -459,6 +459,36 @@ test("--computed shows whether a rewritten breakpoint, and a rule nothing has, e
   );
 });
 
+test("--computed lists the prefixed declarations only one side's CSS source has, where pixels match", async () => {
+  const run = await capture(["/prefix", "/prefix-same"], {
+    widths: [1440, 375],
+    extra: ["--computed"],
+  });
+  assert.equal(run.code, 0, context(run));
+  const out = results(run.outDir);
+  for (const route of ["/prefix", "/prefix-same"])
+    for (const width of [1440, 375]) assert.equal(result(out, route, width).diffPixels, 0);
+  // One in the <style>, one in the linked sheet, one it @imports, one in a sheet the CSSOM can't read.
+  assert.deepEqual(result(out, "/prefix", 1440).computed?.prefixes, {
+    left: [
+      "-webkit-appearance: none",
+      "-webkit-background-clip: text",
+      "-webkit-text-size-adjust: 100%",
+      "-webkit-user-select: none",
+    ],
+    right: [],
+  });
+  assert.ok(
+    out.meta.unreadableSheets?.left.some((s) => s.includes("cross.left.css")),
+    `the cross-origin sheet was readable${context(run)}`,
+  );
+  assert.deepEqual(result(out, "/prefix-same", 375).computed?.prefixes, { left: [], right: [] });
+  assert.deepEqual(parseSummary(run.stdout).prefixes, [
+    "prefixes: 4 prefixed declarations only one side has",
+    "  only left has: -webkit-appearance: none; -webkit-background-clip: text; -webkit-text-size-adjust: 100%; -webkit-user-select: none  /prefix@1440,375",
+  ]);
+});
+
 test("a page whose CSP refuses inline styles still gets renderdiff's CSS", async () => {
   const run = await capture(["/csp"]);
   assert.equal(run.code, 0, context(run));