@fulldotdev/scan 0.1.0

package/dist/report/build.js

@@ -0,0 +1,2263 @@
+import { areaTopics, auditCondition, accessibilityCondition, publicReport, unverifiedChanges, rules, topicLabels, topicOrder, } from "./rules.js";
+import { pageType, socialPlatform } from "../engine/crawl-scope.js";
+import { detectLanguage, languageOfTag } from "../engine/language.js";
+import jpeg from "jpeg-js";
+import { sameSite, slashTwin } from "../engine/network.js";
+const ITEM_LIMIT = 200;
+// Hosts that only exist to track visitors. Seen on first load, before any
+// interaction, they ran without consent.
+const trackerHosts = [
+    [/(^|\.)google-analytics\.com$/, "Google Analytics"],
+    [/(^|\.)analytics\.google\.com$/, "Google Analytics"],
+    [/(^|\.)doubleclick\.net$/, "Google Ads (DoubleClick)"],
+    [/(^|\.)googleadservices\.com$/, "Google Ads"],
+    [/(^|\.)googlesyndication\.com$/, "Google AdSense"],
+    [/(^|\.)connect\.facebook\.net$/, "Meta Pixel"],
+    [/(^|\.)facebook\.com$/, "Meta Pixel"],
+    [/(^|\.)hotjar\.com$/, "Hotjar"],
+    [/(^|\.)clarity\.ms$/, "Microsoft Clarity"],
+    [/(^|\.)ads\.linkedin\.com$/, "LinkedIn Insight"],
+    [/(^|\.)analytics\.tiktok\.com$/, "TikTok Pixel"],
+    [/(^|\.)ct\.pinterest\.com$/, "Pinterest Tag"],
+    [/(^|\.)sc-static\.net$/, "Snap Pixel"],
+    [/(^|\.)bat\.bing\.com$/, "Microsoft Ads"],
+    [/(^|\.)hubspot\.com$/, "HubSpot tracking"],
+    [/(^|\.)mixpanel\.com$/, "Mixpanel"],
+    [/(^|\.)segment\.io$/, "Segment"],
+];
+function trackerName(url) {
+    try {
+        const host = new URL(url).hostname;
+        return trackerHosts.find(([pattern]) => pattern.test(host))?.[1] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const businessTypes = /(Organization|LocalBusiness|Business|Store|Restaurant|Dentist|Physician|MedicalBusiness|ProfessionalService|Person|Corporation|Hotel|Attorney|RealEstateAgent|AutoRepair|Gym|HealthClub|SportsActivityLocation)$/;
+export function fieldVerdict(d) {
+    const grades = [
+        d.lcp == null ? null : d.lcp <= 2500 ? 0 : d.lcp <= 4000 ? 1 : 2,
+        d.inp == null ? null : d.inp <= 200 ? 0 : d.inp <= 500 ? 1 : 2,
+        d.cls == null ? null : d.cls <= 0.1 ? 0 : d.cls <= 0.25 ? 1 : 2,
+    ].filter((g) => g !== null);
+    if (!grades.length)
+        return null;
+    const worst = Math.max(...grades);
+    return worst === 0 ? "good" : worst === 1 ? "needs-improvement" : "poor";
+}
+const fieldFrom = (data) => data
+    ? data.available
+        ? {
+            available: true,
+            level: data.level ?? "origin",
+            lcp: data.lcp ?? null,
+            inp: data.inp ?? null,
+            cls: data.cls ?? null,
+            verdict: fieldVerdict(data),
+            period: data.period ?? null,
+            note: data.level === "url"
+                ? "Chrome UX Report for this page, real Chrome users over 28 days, 75th percentile"
+                : "Chrome UX Report for the whole origin, real Chrome users over 28 days, 75th percentile",
+        }
+        : {
+            available: false,
+            level: data.level ?? "origin",
+            lcp: null,
+            inp: null,
+            cls: null,
+            verdict: null,
+            period: null,
+            note: data.note ?? "Not enough Chrome traffic for field data",
+        }
+    : null;
+// Findings whose measured values wobble between runs are compared by
+// presence only, never by their items.
+const volatile = new Set([
+    "performance-opportunities",
+    "small-performance-opportunities",
+    "slow-responses",
+    "heavy-pages",
+    "slow-mobile",
+    "slow-lcp-own-browser",
+    "field-vitals-poor",
+    "field-page-vitals-poor",
+    "javascript-errors",
+    "external-errors",
+]);
+const itemKey = (item) => typeof item === "string" ? item : (item.url ?? item.text);
+// Items are identified by their URL (or text for site-level items). A
+// missing item counts as resolved only when `verified` confirms that the
+// evidence its rule depends on was collected again for that URL (or, for
+// site-level items, that the check ran); otherwise it stays unverified.
+export function diffFindings(before, after, verified = () => true) {
+    const id = (f) => f.id ?? f.code;
+    const beforeById = new Map(before.map((f) => [id(f), f]));
+    const afterById = new Map(after.map((f) => [id(f), f]));
+    const change = (f, count, extra = {}) => ({
+        id: id(f),
+        code: f.code,
+        title: f.title,
+        severity: f.severity,
+        count,
+        ...extra,
+    });
+    const newFindings = after.flatMap((f) => {
+        const old = beforeById.get(f.id);
+        if (!old)
+            return [f];
+        if (volatile.has(f.code))
+            return [];
+        const oldKeys = new Set(old.items.map(itemKey));
+        const items = f.items.filter((i) => !oldKeys.has(itemKey(i)));
+        return items.length ? [{ ...f, count: items.length, items }] : [];
+    });
+    const resolvedFindings = [], unverifiedFindings = [], recurringFindings = [], worsenedFindings = [];
+    for (const old of before) {
+        const now = afterById.get(id(old));
+        if (now) {
+            recurringFindings.push(change(old, now.count));
+            if (now.count > old.count && !volatile.has(old.code))
+                worsenedFindings.push(change(old, now.count, { from: old.count, to: now.count }));
+        }
+        // Volatile findings are compared by presence only; when one disappears,
+        // every retained item is judged on its own page. Items the old report
+        // did not retain cannot be verified and stay unverified.
+        const gone = volatile.has(old.code)
+            ? now
+                ? []
+                : old.items
+            : old.items.filter((i) => !new Set((now?.items ?? []).map(itemKey)).has(itemKey(i)));
+        const resolved = gone.filter((i) => verified(i, old)).length;
+        const unverified = gone.length - resolved + Math.max(0, old.count - old.items.length);
+        if (resolved)
+            resolvedFindings.push(change(old, resolved));
+        if (unverified && (gone.length || !now))
+            unverifiedFindings.push(change(old, unverified));
+    }
+    return {
+        newFindings,
+        resolvedFindings,
+        unverifiedFindings,
+        recurringFindings,
+        worsenedFindings,
+    };
+}
+// Share of a coarse luminance grid that differs between two screenshots.
+export function screenshotDifference(a, b) {
+    try {
+        const grid = (buffer) => {
+            const image = jpeg.decode(buffer, {
+                useTArray: true,
+                maxMemoryUsageInMB: 64,
+            });
+            const cols = 24, rows = 48;
+            const cells = [];
+            for (let r = 0; r < rows; r++)
+                for (let c = 0; c < cols; c++) {
+                    let sum = 0, n = 0;
+                    const x0 = Math.floor((c * image.width) / cols), x1 = Math.floor(((c + 1) * image.width) / cols), y0 = Math.floor((r * image.height) / rows), y1 = Math.floor(((r + 1) * image.height) / rows);
+                    for (let y = y0; y < y1; y += 2)
+                        for (let x = x0; x < x1; x += 2) {
+                            const i = (y * image.width + x) * 4;
+                            sum +=
+                                0.299 * image.data[i] +
+                                    0.587 * image.data[i + 1] +
+                                    0.114 * image.data[i + 2];
+                            n++;
+                        }
+                    cells.push(n ? sum / n : 0);
+                }
+            return cells;
+        };
+        const left = grid(a), right = grid(b);
+        const changed = left.filter((v, i) => Math.abs(v - right[i]) > 24).length;
+        return Math.round((changed / left.length) * 100);
+    }
+    catch {
+        return null;
+    }
+}
+const slug = (value) => value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 60);
+const severityRank = {
+    critical: 0,
+    warning: 1,
+    hint: 2,
+};
+const confidenceRank = {
+    confirmed: 0,
+    probable: 1,
+    review: 2,
+};
+const platformBlocked = (url) => !!socialPlatform(url)?.blocksBots;
+export async function buildReport(scan, input) {
+    const rows = input.records;
+    const urlRows = input.urls;
+    const sources = new Map(urlRows.map((r) => [r.url, r.sources]));
+    const omitted = Number(scan.coverage?.omittedCandidates ?? 0);
+    const of = (kind) => rows.filter((r) => r.kind === kind);
+    const pages = of("page");
+    const byKey = new Map(pages.map((p) => [p.key, p]));
+    // A trailing-slash twin recorded by a page job is a page when the twin
+    // itself was crawled; it must not double as a broken or checked file.
+    const resources = of("resource").filter((r) => !byKey.has(r.key));
+    const resourceByKey = new Map(resources.map((r) => [r.key, r]));
+    const renderedByKey = new Map(of("rendered").map((r) => [r.key, r.data]));
+    const home = pages.find((p) => p.key === scan.url) ??
+        pages.find((p) => new URL(p.key).pathname === "/");
+    const status = (o) => o.data.http?.status ?? null;
+    const failure = (o) => String(status(o) ?? o.data.http?.error ?? "no response");
+    // Where a URL was found: the pages that link to it.
+    const linkingPages = (url) => (sources.get(url) ?? [])
+        .filter((s) => s.startsWith("link:") || s.startsWith("browser:"))
+        .map((s) => s.replace(/^(link|browser):/, ""));
+    const linkedFrom = (url) => {
+        const from = linkingPages(url);
+        return from.length
+            ? ` (linked from ${from[0]}${from.length > 1 ? ` and ${from.length - 1} more` : ""})`
+            : "";
+    };
+    const okPages = pages.filter((p) => p.data.http?.outcome === "ok");
+    const htmlPages = okPages.filter((p) => p.data.html !== false);
+    // 401, 403 and 429 are "inconclusive" (coverage), not broken.
+    const brokenPages = pages.filter((p) => p.data.http?.outcome !== "inconclusive" &&
+        p.data.http?.outcome !== "blocked" &&
+        ((status(p) ?? 0) >= 400 || p.data.http?.outcome === "error"));
+    const isErrorPage = (url) => /\/404(\.html)?\/?$/.test(url);
+    const content = htmlPages.filter((p) => !isErrorPage(p.key));
+    const own = (url) => {
+        try {
+            return sameSite(url, scan.url);
+        }
+        catch {
+            return false;
+        }
+    };
+    const policyFor = (p) => {
+        const directives = [
+            p.data.xRobotsTag,
+            ...(p.data.robots ?? [])
+                .filter((r) => /^(robots|googlebot)$/i.test(r.name ?? ""))
+                .map((r) => r.content),
+        ].join(",");
+        const noindex = /\b(noindex|none)\b/i.test(directives);
+        return { noindex, status: noindex ? "noindex" : "indexable" };
+    };
+    const lighthouseOn = scan.options.lighthouse !== "off";
+    const noindex = (p) => policyFor(p).noindex;
+    const canonicalElsewhere = (p) => (p.data.canonicals ?? []).some((c) => c.href &&
+        c.href !== p.data.http?.finalUrl &&
+        c.href !== p.key);
+    // Findings: one entry per distinct problem or shared cause, with the
+    // affected pages and representative evidence.
+    const findings = [];
+    const skips = new Map();
+    const skip = (code, outcome, detail) => {
+        if (!findings.some((f) => f.code === code))
+            skips.set(code, { outcome, detail });
+    };
+    const add = (code, items, overrides = {}) => {
+        if (!items.length)
+            return;
+        const rule = rules[code];
+        if (!rule)
+            throw new Error(`Unknown finding code ${code}`);
+        const normalized = items.map((i) => typeof i === "string" ? { url: null, text: i } : i);
+        const urls = [
+            ...new Set(normalized.map((i) => i.url).filter((u) => !!u)),
+        ];
+        findings.push({
+            id: overrides.group ? `${code}:${slug(overrides.group)}` : code,
+            code,
+            group: overrides.group,
+            topic: rule.topic,
+            severity: overrides.severity ?? rule.severity,
+            confidence: overrides.confidence ?? rule.confidence,
+            title: overrides.title ?? rule.title,
+            problem: rule.problem,
+            impact: rule.impact,
+            count: normalized.length,
+            pages: urls.length,
+            items: normalized,
+            urls,
+        });
+    };
+    const withLink = (url) => ({ url, text: url });
+    // ---- Availability and security ----
+    const tls = of("tls")[0]?.data;
+    if (!home ||
+        home.data.http?.outcome === "error" ||
+        (status(home) ?? 500) >= 500)
+        add("homepage-unreachable", [
+            home
+                ? { url: home.key, text: `${failure(home)} ${home.key}` }
+                : withLink(scan.url),
+        ]);
+    if (tls?.status === "observed" && (!tls.authorized || !tls.hostnameValid))
+        add("tls-invalid", [
+            tls.authorizationError ?? tls.hostnameError ?? "certificate rejected",
+        ]);
+    else if (tls?.status !== "observed")
+        skip("tls-invalid", "unavailable", tls?.error);
+    if (tls?.status === "observed" &&
+        typeof tls.daysRemaining === "number" &&
+        tls.daysRemaining >= 0 &&
+        tls.daysRemaining <= 14)
+        add("tls-expiring", [
+            `expires ${String(tls.certificate?.validTo ?? "")} (${tls.daysRemaining} days)`,
+        ], {
+            title: `TLS certificate expires in ${tls.daysRemaining} days`,
+        });
+    const domainData = of("domain")[0]?.data;
+    const domain = domainData?.status === "observed"
+        ? {
+            name: domainData.domain,
+            expiresAt: domainData.expiresAt ?? null,
+            daysRemaining: domainData.daysRemaining ?? null,
+            registrar: domainData.registrar ?? null,
+        }
+        : null;
+    if (!domain)
+        skip("domain-expiring", "unavailable", domainData?.error ?? "registry data not published");
+    else if (domain.daysRemaining === null)
+        skip("domain-expiring", "unavailable", "registry does not publish an expiry date");
+    else if (domain.daysRemaining <= 60)
+        add("domain-expiring", [`${domain.name} on ${String(domain.expiresAt).slice(0, 10)}`], {
+            severity: domain.daysRemaining <= 30 ? "critical" : "warning",
+            title: `Domain registration expires in ${domain.daysRemaining} days`,
+        });
+    add("insecure-forms", htmlPages.flatMap((p) => (p.data.forms ?? [])
+        .filter((f) => f.insecureDestination)
+        .map((f) => ({ url: p.key, text: `${p.key} (${f.action})` }))));
+    const variants = of("url-variant");
+    add("http-not-redirected", variants
+        .filter((v) => v.key.startsWith("http://") &&
+        v.data.status === 200 &&
+        !String(v.data.finalUrl ?? "").startsWith("https://"))
+        .map((v) => withLink(v.key)));
+    if (home?.data.http?.headers) {
+        const headers = home.data.http.headers;
+        const missing = [];
+        if (home.key.startsWith("https://") &&
+            !headers["strict-transport-security"])
+            missing.push("Strict-Transport-Security");
+        if (!headers["content-security-policy"])
+            missing.push("Content-Security-Policy");
+        if (!headers["x-content-type-options"])
+            missing.push("X-Content-Type-Options");
+        if (!headers["x-frame-options"] &&
+            !/frame-ancestors/i.test(headers["content-security-policy"] ?? ""))
+            missing.push("X-Frame-Options or frame-ancestors");
+        if (!headers["referrer-policy"])
+            missing.push("Referrer-Policy");
+        add("security-headers", missing.map((m) => ({
+            url: home.key,
+            text: `${m} missing on ${home.key}`,
+        })));
+    }
+    else
+        skip("security-headers", "unavailable", "homepage response headers not available");
+    const dns = of("dns")[0]?.data;
+    if (dns?.email && dns.records?.mx?.status === "observed") {
+        const missing = [];
+        if (!dns.email.spf?.length)
+            missing.push("SPF record missing");
+        if (!dns.email.dmarc?.length)
+            missing.push("DMARC record missing");
+        else if (/p=none/i.test(dns.email.dmarc[0]))
+            missing.push("DMARC policy is p=none, which does not protect the domain");
+        add("email-authentication", missing);
+        if ((dns.records.mx.values ?? []).length)
+            add("email-transport-security", dns.email.mtaSts?.length
+                ? []
+                : [`_mta-sts.${dns.domain} record missing`]);
+        else
+            skip("email-transport-security", "not-applicable", "no mail servers published");
+    }
+    else {
+        skip("email-authentication", "unavailable", "MX lookup unavailable");
+        skip("email-transport-security", "unavailable", "MX lookup unavailable");
+    }
+    const details = of("browser-detail");
+    add("mixed-content", details.flatMap((d) => d.key.startsWith("https://")
+        ? (d.data.network ?? [])
+            .filter((n) => String(n.url).startsWith("http://"))
+            .map((n) => ({ url: d.key, text: `${n.url} on ${d.key}` }))
+        : []));
+    const trackers = new Map();
+    for (const d of details)
+        for (const n of d.data.network ?? []) {
+            const name = trackerName(String(n.url));
+            if (name)
+                trackers.set(`${name}|${d.key}`, {
+                    url: d.key,
+                    text: `${name} on ${d.key}`,
+                });
+        }
+    add("trackers-before-consent", [...trackers.values()]);
+    const browserMetrics = of("browser-metrics");
+    add("cookies-before-consent", browserMetrics.flatMap((m) => (m.data.cookies?.names ?? [])
+        .filter((c) => c.thirdParty)
+        .map((c) => ({
+        url: m.key,
+        text: `${c.name} from ${c.domain} on ${m.key}`,
+    }))));
+    const safe = of("safe-browsing")[0]?.data;
+    if (safe?.status === "observed" && safe.flagged)
+        add("safe-browsing-flagged", safe.threats.map((t) => ({
+            url: scan.url,
+            text: `${t.replace(/_/g, " ").toLowerCase()} on ${scan.url}`,
+        })));
+    else if (!safe)
+        skip("safe-browsing-flagged", "not-checked", "no Google API key configured");
+    else if (safe.status !== "observed")
+        skip("safe-browsing-flagged", "unavailable", safe.error);
+    const lists = of("blocklists")[0]?.data;
+    const listResults = (lists?.results ?? []);
+    add("blocklisted", listResults.filter((r) => r.status === "listed").map((r) => r.list));
+    if (listResults.length &&
+        listResults.every((r) => r.status === "unavailable"))
+        skip("blocklisted", "unavailable", "blocklist query refused");
+    const labs = of("ssl-labs")[0]?.data;
+    if (labs?.status === "observed" && labs.grade && /^[CDEFTM]/.test(labs.grade))
+        add("tls-grade-low", [`${labs.grade} for ${new URL(scan.url).hostname}`], {
+            title: `SSL Labs grades the TLS setup ${labs.grade}`,
+        });
+    else if (labs?.status !== "observed")
+        skip("tls-grade-low", "unavailable", labs?.note ?? labs?.error);
+    const certificates = of("certificates")[0]?.data;
+    // Only labels below the registered domain count: a .dev or .test
+    // domain is not a staging host.
+    const registeredDomain = dns?.domain ?? null;
+    const subdomainLabels = (h) => registeredDomain &&
+        (h === registeredDomain || h.endsWith(`.${registeredDomain}`))
+        ? h.slice(0, Math.max(0, h.length - registeredDomain.length - 1))
+        : h;
+    if (certificates?.status === "observed")
+        add("staging-hostnames", (certificates.hostnames ?? []).filter((h) => /(^|\.)(staging|stage|test|testing|dev|develop|acc|acceptance|beta|old|demo|preview|uat)(\.|$)/.test(subdomainLabels(h))));
+    else
+        skip("staging-hostnames", "unavailable", certificates?.error);
+    // ---- Crawling and indexability ----
+    add("broken-pages", brokenPages
+        .filter((p) => !isErrorPage(p.key))
+        .map((p) => ({
+        url: p.key,
+        text: `${failure(p)} ${p.key}${linkedFrom(p.key)}`,
+    })));
+    if (home &&
+        home.data.html !== false &&
+        noindex(home))
+        add("homepage-noindex", [withLink(home.key)]);
+    add("unexpected-noindex", htmlPages
+        .filter((p) => p.key !== home?.key && noindex(p))
+        .map((p) => withLink(p.key)));
+    const robots = of("robots")[0]?.data;
+    const homePolicy = of("crawler-policy").find((o) => o.key === home?.key)?.data ??
+        robots?.policy;
+    if (robots?.http?.outcome === "error" || (robots?.http?.status ?? 0) >= 500)
+        add("robots-unavailable", [
+            `${robots.http.status ?? robots.http.error} ${robots.http.finalUrl ?? robots.http.url}`,
+        ]);
+    if (homePolicy?.bots?.some((b) => b.bot === "Googlebot" && b.allowed === false))
+        add("search-blocked", [withLink(homePolicy.robotsUrl)]);
+    else if (!homePolicy)
+        skip("search-blocked", "unavailable", "robots policy not evaluated");
+    add("canonical-broken", (of("canonical-targets")[0]?.data ?? [])
+        .filter((c) => c.targetHttp && (c.targetHttp.status ?? 0) >= 400)
+        .map((c) => ({
+        url: c.source,
+        text: `${c.targetHttp.status} ${c.target} (canonical of ${c.source})`,
+    })));
+    const renderedPages = [...renderedByKey.entries()];
+    add("canonical-rendered-differs", renderedPages
+        .filter(([, r]) => r.comparison && !r.comparison.canonical.same)
+        .map(([url, r]) => ({
+        url,
+        text: `${url}: HTML ${r.comparison.canonical.original.join(", ") || "none"}, rendered ${r.comparison.canonical.rendered.join(", ") || "none"}`,
+    })));
+    add("robots-rendered-differs", renderedPages
+        .filter(([, r]) => r.comparison && !r.comparison.robots.same)
+        .map(([url, r]) => ({
+        url,
+        text: `${url}: HTML "${r.comparison.robots.original || "none"}", rendered "${r.comparison.robots.rendered || "none"}"`,
+    })));
+    const sitemaps = of("sitemap");
+    const validSitemaps = sitemaps.filter((s) => s.data.valid);
+    if (!validSitemaps.length)
+        add("sitemap-missing", [
+            withLink(`${new URL(scan.url).origin}/sitemap.xml`),
+        ]);
+    add("sitemap-invalid", sitemaps
+        .filter((s) => !s.data.valid &&
+        (sources.get(s.key) ?? []).some((src) => src !== "default-location"))
+        .map((s) => ({
+        url: s.key,
+        text: `${s.data.http?.status ?? s.data.http?.error ?? "no response"} ${s.key}${s.data.error ? `: ${s.data.error}` : ""}`,
+    })));
+    const sitemapEntries = new Map();
+    for (const s of validSitemaps)
+        for (const entry of s.data.urls ?? []) {
+            const url = entry.scanUrl ?? entry.url;
+            if (!sitemapEntries.has(url))
+                sitemapEntries.set(url, s.key);
+        }
+    add("sitemap-problems", [
+        ...new Map([...sitemapEntries].flatMap(([url, sitemap]) => {
+            const page = byKey.get(url) ?? resourceByKey.get(url);
+            if (!page)
+                return [];
+            if (page.data.http?.outcome === "inconclusive" ||
+                page.data.http?.outcome === "blocked")
+                return [];
+            if ((status(page) ?? 0) >= 400 ||
+                page.data.http?.outcome === "error" ||
+                isErrorPage(url))
+                return [
+                    [url, { url, text: `${failure(page)} ${url} (in ${sitemap})` }],
+                ];
+            if ((page.data.http?.redirects ?? []).length)
+                return [
+                    [
+                        url,
+                        {
+                            url,
+                            text: `redirects to ${page.data.http.finalUrl}: ${url} (in ${sitemap})`,
+                        },
+                    ],
+                ];
+            if (page.data.html !== false && byKey.has(url) && noindex(page))
+                return [[url, { url, text: `noindex ${url} (in ${sitemap})` }]];
+            return [];
+        })).values(),
+    ]);
+    const now = Date.now();
+    add("sitemap-dates", [
+        ...new Map(validSitemaps.flatMap((s) => (s.data.urls ?? []).flatMap((entry) => {
+            if (!entry.lastmod)
+                return [];
+            const url = entry.scanUrl ?? entry.url;
+            const t = Date.parse(entry.lastmod);
+            if (Number.isNaN(t))
+                return [
+                    [
+                        url,
+                        { url, text: `unreadable "${entry.lastmod}" for ${url}` },
+                    ],
+                ];
+            if (t > now + 86400000)
+                return [
+                    [
+                        url,
+                        {
+                            url,
+                            text: `in the future (${String(entry.lastmod).slice(0, 10)}) ${url}`,
+                        },
+                    ],
+                ];
+            if (t < now - 3 * 365 * 86400000)
+                return [
+                    [
+                        url,
+                        {
+                            url,
+                            text: `over three years old (${String(entry.lastmod).slice(0, 10)}) ${url}`,
+                        },
+                    ],
+                ];
+            return [];
+        }))).values(),
+    ]);
+    if (validSitemaps.length)
+        add("sitemap-not-listed", content
+            .filter((p) => status(p) === 200 &&
+            !noindex(p) &&
+            !canonicalElsewhere(p) &&
+            !sitemapEntries.has(p.key) &&
+            !sitemapEntries.has(p.data.http.finalUrl) &&
+            !new URL(p.key).search)
+            .map((p) => withLink(p.key)));
+    else
+        skip("sitemap-not-listed", "not-applicable", "no valid sitemap");
+    const linkGraph = of("link-graph")[0]?.data;
+    const graphPages = linkGraph?.pages ?? [];
+    const pageRows = urlRows.filter((u) => u.kind === "page");
+    const followedPages = pageRows.filter((u) => u.scheduled);
+    const crawlComplete = pages.length >= followedPages.length &&
+        !pageRows.some((u) => u.skipReason === "explicit-limit") &&
+        omitted === 0;
+    // Orphans are only meaningful when every followed page was crawled.
+    if (crawlComplete && linkGraph)
+        add("orphan-pages", graphPages
+            .filter((p) => p.orphanCandidate && byKey.has(p.url))
+            .map((p) => withLink(p.url)));
+    else
+        skip("orphan-pages", linkGraph ? "not-checked" : "unavailable", "crawl did not cover every followed page");
+    const slashVariants = of("slash-variant");
+    add("trailing-slash-variants", slashVariants
+        .filter((r) => ["duplicate", "different-redirect-target"].includes(r.data.result))
+        .map((r) => ({
+        url: r.data.url,
+        text: `${r.data.result}: ${r.data.url} and ${r.data.alternateUrl}`,
+    })));
+    add("canonicalized-slash-variants", slashVariants
+        .filter((r) => r.data.result === "canonicalized")
+        .map((r) => ({
+        url: r.data.url,
+        text: `${r.data.url} and ${r.data.alternateUrl}, canonical ${r.data.original.canonicals[0]}`,
+    })));
+    add("different-slash-content", slashVariants
+        .filter((r) => r.data.result === "different-content")
+        .map((r) => ({
+        url: r.data.url,
+        text: `${r.data.url} and ${r.data.alternateUrl}`,
+    })));
+    const redirectChains = [...pages, ...resources].filter((r) => (r.data.http?.redirects ?? []).length >= 2);
+    const successfulExternal = (r) => !own(r.key) &&
+        r.data.http?.outcome === "ok" &&
+        r.data.http?.status >= 200 &&
+        r.data.http?.status < 300;
+    add("redirect-chains", redirectChains
+        .filter((r) => !successfulExternal(r))
+        .map((r) => ({
+        url: r.key,
+        text: `${r.data.http.redirects.length} hops ${r.key} to ${r.data.http.finalUrl}`,
+    })));
+    const hreflangs = of("hreflang-links")[0]?.data ?? [];
+    if (hreflangs.length) {
+        add("hreflang-not-reciprocal", hreflangs
+            .filter((h) => h.reciprocal === false)
+            .map((h) => ({
+            url: h.source,
+            text: `${h.source} to ${h.href} (${h.hreflang})`,
+        })));
+        add("hreflang-unreachable", hreflangs
+            .filter((h) => (h.targetStatus ?? 0) >= 400 || h.targetOutcome === "error")
+            .map((h) => ({
+            url: h.source,
+            text: `${h.targetStatus ?? h.targetOutcome} ${h.href} (${h.hreflang} alternate of ${h.source})`,
+        })));
+        add("hreflang-invalid", hreflangs
+            .filter((h) => !h.languageValid)
+            .map((h) => ({
+            url: h.source,
+            text: `hreflang="${h.hreflang}" on ${h.source}`,
+        })));
+    }
+    else
+        for (const code of [
+            "hreflang-not-reciprocal",
+            "hreflang-unreachable",
+            "hreflang-invalid",
+        ])
+            skip(code, "not-applicable", "no hreflang declarations");
+    const paginated = of("pagination")[0]?.data ?? [];
+    if (paginated.length) {
+        add("pagination-broken", paginated.flatMap((p) => [
+            ...((p.nextStatus ?? 0) >= 400
+                ? [
+                    {
+                        url: p.url,
+                        text: `${p.nextStatus} next page ${p.next} from ${p.url}`,
+                    },
+                ]
+                : []),
+            ...p.numberedBroken.map((u) => ({
+                url: p.url,
+                text: `broken page link ${u} from ${p.url}`,
+            })),
+        ]));
+        add("pagination-canonical-first", paginated
+            .filter((p) => p.canonicalRelation === "first-page")
+            .map((p) => ({
+            url: p.url,
+            text: `${p.url} canonical ${p.canonical}`,
+        })));
+        add("pagination-noindex", paginated
+            .filter((p) => !p.isFirst && p.noindex)
+            .map((p) => withLink(p.url)));
+        add("pagination-rendered-only", paginated
+            .filter((p) => p.renderedOnly)
+            .map((p) => ({
+            url: p.url,
+            text: `${p.url}: ${p.next ?? p.numbered[0]}`,
+        })));
+    }
+    else
+        for (const code of [
+            "pagination-broken",
+            "pagination-canonical-first",
+            "pagination-noindex",
+            "pagination-rendered-only",
+        ])
+            skip(code, linkGraph ? "not-applicable" : "unavailable", "no pagination detected");
+    if (renderedByKey.size)
+        add("rendered-only-pages", graphPages
+            .filter((p) => p.renderedOnly && byKey.has(p.url))
+            .map((p) => withLink(p.url)));
+    // ---- Content and structure ----
+    add("missing-title", content.filter((p) => !p.data.title).map((p) => withLink(p.key)));
+    add("title-length", content
+        .filter((p) => p.data.title &&
+        (p.data.title.length < 30 || p.data.title.length > 60))
+        .map((p) => ({
+        url: p.key,
+        text: `${p.data.title.length} characters "${p.data.title}" on ${p.key}`,
+    })));
+    add("missing-description", content
+        .filter((p) => !(p.data.descriptions ?? []).some(Boolean))
+        .map((p) => withLink(p.key)));
+    add("description-length", content
+        .map((p) => ({
+        key: p.key,
+        d: (p.data.descriptions ?? []).find(Boolean),
+    }))
+        .filter((p) => p.d && (p.d.length < 70 || p.d.length > 160))
+        .map((p) => ({
+        url: p.key,
+        text: `${p.d.length} characters on ${p.key}`,
+    })));
+    const duplicateData = of("duplicates")[0]?.data;
+    for (const [field, code] of [
+        ["title", "duplicate-titles"],
+        ["description", "duplicate-descriptions"],
+        ["textHash", "duplicate-content"],
+    ])
+        add(code, (duplicateData?.exact ?? [])
+            .filter((d) => d.field === field)
+            .flatMap((d, index) => d.urls.map((url) => ({
+            url,
+            text: `${url} (group ${index + 1}, ${d.urls.length} pages${field === "textHash" ? "" : `, "${d.value}"`})`,
+        }))));
+    const near = duplicateData?.near ?? [];
+    add("similar-content", near
+        .filter((d) => !d.substitution)
+        .flatMap((d, index) => d.urls.map((url) => ({
+        url,
+        text: `${url} (pair ${index + 1}, ${Math.round(d.similarity * 100)}% word-set overlap with ${d.urls.find((u) => u !== url)})`,
+    }))));
+    add("substituted-content", near
+        .filter((d) => d.substitution)
+        .flatMap((d) => d.urls.map((url, i) => ({
+        url,
+        text: `${url} differs from ${d.urls[1 - i]} only in: ${[...d.differences.onlyLeft, ...d.differences.onlyRight].join(", ")}`,
+    }))));
+    add("overlapping-collections", (duplicateData?.collections ?? []).flatMap((c) => c.urls.map((url, i) => ({
+        url,
+        text: `${url} shares ${c.shared} of ${c.items[i]} listed products with ${c.urls[1 - i]}`,
+    }))));
+    if (!duplicateData) {
+        for (const code of [
+            "duplicate-titles",
+            "duplicate-descriptions",
+            "duplicate-content",
+            "similar-content",
+            "substituted-content",
+            "overlapping-collections",
+        ])
+            skip(code, "unavailable", "site analysis did not run");
+    }
+    add("thin-pages", content
+        .filter((p) => (p.data.wordCount ?? 0) < 100)
+        .map((p) => ({
+        url: p.key,
+        text: `${p.data.wordCount ?? 0} words on ${p.key}`,
+    })));
+    const h1s = (p) => (p.data.headings ?? []).filter((h) => h.level === 1).length;
+    add("h1-missing", content.filter((p) => h1s(p) === 0).map((p) => withLink(p.key)));
+    add("h1-multiple", content
+        .filter((p) => h1s(p) > 1)
+        .map((p) => ({ url: p.key, text: `${h1s(p)} on ${p.key}` })));
+    add("heading-skips", content
+        .filter((p) => {
+        const levels = (p.data.headings ?? []).map((h) => h.level);
+        return levels.some((l, i) => i > 0 && l > levels[i - 1] + 1);
+    })
+        .map((p) => withLink(p.key)));
+    add("long-paragraphs", content
+        .filter((p) => (p.data.readability?.paragraphsOver150 ?? 0) > 0)
+        .map((p) => ({
+        url: p.key,
+        text: `${p.data.readability.paragraphsOver150} on ${p.key}`,
+    })));
+    add("long-sentences", content
+        .filter((p) => (p.data.readability?.sentences ?? 0) >= 10 &&
+        (p.data.readability?.longSentenceShare ?? 0) > 0.25)
+        .map((p) => ({
+        url: p.key,
+        text: `${Math.round(p.data.readability.longSentenceShare * 100)}% on ${p.key}`,
+    })));
+    add("language-mismatch", content.flatMap((p) => {
+        const declared = languageOfTag(p.data.language);
+        const detected = detectLanguage(p.data.text ?? "");
+        if (!detected)
+            return [];
+        if (!declared)
+            return [
+                {
+                    url: p.key,
+                    text: `no lang attribute, content looks ${detected}: ${p.key}`,
+                },
+            ];
+        return declared !== detected
+            ? [
+                {
+                    url: p.key,
+                    text: `lang="${p.data.language}" but content looks ${detected}: ${p.key}`,
+                },
+            ]
+            : [];
+    }));
+    const languageSwitches = of("language-links")[0]?.data ?? [];
+    if (languageSwitches.length) {
+        add("language-switch-broken", languageSwitches
+            .filter((s) => (s.status ?? 0) >= 400 || s.outcome === "error")
+            .map((s) => ({
+            url: s.source,
+            text: `${s.status ?? s.outcome} ${s.url} ("${s.text}" on ${s.source})`,
+        })));
+        add("language-switch-mismatch", languageSwitches
+            .filter((s) => s.status === 200 &&
+            ((s.declaredMatches === false && s.targetLanguage) ||
+                (s.detectedLanguage && s.detectedLanguage !== s.expected)))
+            .map((s) => ({
+            url: s.source,
+            text: `"${s.text}" on ${s.source} leads to ${s.url}: declared ${s.targetLanguage ?? "none"}, text looks ${s.detectedLanguage ?? "unclear"}, expected ${s.expected}`,
+        })));
+    }
+    else {
+        skip("language-switch-broken", linkGraph ? "not-applicable" : "unavailable", "no language-switch links detected");
+        skip("language-switch-mismatch", linkGraph ? "not-applicable" : "unavailable", "no language-switch links detected");
+    }
+    add("content-requires-javascript", renderedPages
+        .filter(([, r]) => r.comparison?.text?.ratio !== null &&
+        r.comparison?.text?.ratio < 0.5 &&
+        r.comparison.text.renderedWords >= 50)
+        .map(([url, r]) => ({
+        url,
+        text: `${r.comparison.text.originalWords} of ${r.comparison.text.renderedWords} words without JavaScript on ${url}`,
+    })));
+    add("title-rendered-differs", renderedPages
+        .filter(([, r]) => r.comparison &&
+        (!r.comparison.title.same ||
+            r.comparison.headings.added.length ||
+            r.comparison.headings.removed.length))
+        .map(([url, r]) => ({
+        url,
+        text: `${url}: ${!r.comparison.title.same ? `title "${r.comparison.title.original}" became "${r.comparison.title.rendered}"; ` : ""}${r.comparison.headings.added.length} headings added, ${r.comparison.headings.removed.length} removed`,
+    })));
+    if (!renderedByKey.size)
+        for (const code of [
+            "canonical-rendered-differs",
+            "robots-rendered-differs",
+            "rendered-only-pages",
+            "content-requires-javascript",
+            "title-rendered-differs",
+            "structured-data-rendered-only",
+            "pagination-rendered-only",
+        ])
+            skip(code, scan.options.browser ? "unavailable" : "not-checked", scan.options.browser
+                ? "no page completed the browser pass"
+                : "browser pass disabled");
+    // ---- Links and navigation ----
+    // The guessed /favicon.ico probe is not a link; it only feeds the favicon check.
+    const guessed = (url) => (sources.get(url) ?? []).every((s) => s.startsWith("favicon-fallback:"));
+    const brokenResources = resources.filter((r) => ((status(r) ?? 0) >= 400 || r.data.http?.outcome === "error") &&
+        !guessed(r.key));
+    const resourceLine = (r) => ({
+        url: linkingPages(r.key)[0] ?? null,
+        text: `${failure(r)} ${r.key}${linkedFrom(r.key)}`,
+    });
+    add("broken-resources", brokenResources.filter((r) => own(r.key)).map(resourceLine));
+    add("broken-external-resources", brokenResources
+        .filter((r) => !own(r.key) && !platformBlocked(r.key))
+        .map(resourceLine));
+    add("unverifiable-external", resources
+        .filter((r) => !own(r.key) &&
+        (r.data.http?.outcome === "inconclusive" ||
+            r.data.http?.outcome === "blocked" ||
+            (platformBlocked(r.key) && (status(r) ?? 0) >= 400)))
+        .map(resourceLine));
+    add("broken-anchors", (of("anchors")[0]?.data ?? [])
+        .filter((a) => a.present === false)
+        .map((a) => ({
+        url: a.source,
+        text: `${a.target}#${a.fragment} from ${a.source}`,
+    })));
+    add("external-redirect-chains", redirectChains.filter(successfulExternal).map((r) => ({
+        url: linkingPages(r.key)[0] ?? null,
+        text: `${r.data.http.redirects.length} hops ${r.key} to ${r.data.http.finalUrl}`,
+    })));
+    const vagueByPage = new Map();
+    for (const v of linkGraph?.vagueAnchors ?? [])
+        vagueByPage.set(v.source, (vagueByPage.get(v.source) ?? 0) + 1);
+    add("vague-anchors", [...vagueByPage].map(([url, n]) => ({
+        url,
+        text: `${n} on ${url}, for example "${linkGraph.vagueAnchors.find((v) => v.source === url)?.text || "(empty)"}"`,
+    })));
+    add("few-contextual-links", (linkGraph?.fewContextual ?? []).map((f) => ({
+        url: f.url,
+        text: `${f.url}: 0 contextual links, peers in ${f.group} have a median of ${f.peerMedian} (${f.peers} pages compared)`,
+    })));
+    add("deep-pages", graphPages
+        .filter((p) => byKey.has(p.url) && p.clickDepth !== null && p.clickDepth >= 4)
+        .map((p) => ({ url: p.url, text: `${p.clickDepth} clicks: ${p.url}` })));
+    if (!linkGraph)
+        for (const code of [
+            "broken-anchors",
+            "vague-anchors",
+            "few-contextual-links",
+            "deep-pages",
+            "canonical-broken",
+        ])
+            skip(code, "unavailable", "site analysis did not run");
+    const business = of("business-identity")[0]?.data;
+    add("map-link-broken", (business?.maps ?? [])
+        .filter((m) => (m.status ?? 0) >= 400)
+        .map((m) => ({ url: null, text: `${m.status} ${m.url}` })));
+    // ---- Structured data ----
+    add("structured-data-invalid", content
+        .filter((p) => (p.data.structuredData ?? []).some((s) => s.parseValid === false))
+        .map((p) => withLink(p.key)));
+    add("structured-data-structural", content
+        .filter((p) => (p.data.structuredData ?? []).some((s) => (s.structuralErrors ?? []).length))
+        .map((p) => ({
+        url: p.key,
+        text: `${p.key}: ${p.data.structuredData
+            .flatMap((s) => s.structuralErrors ?? [])
+            .slice(0, 3)
+            .join("; ")}`,
+    })));
+    const types = (p) => (p.data.structuredData ?? []).flatMap((s) => [s.type, ...(s.graph ?? [])].flat().filter(Boolean).map(String));
+    if (home && home.data.html !== false) {
+        if (!content.some((p) => (p.data.structuredData ?? []).length))
+            add("structured-data-missing", [withLink(home.key)]);
+        else if (!types(home).some((t) => businessTypes.test(t)))
+            add("homepage-business-schema", [withLink(home.key)]);
+    }
+    const structured = of("structured-data")[0]?.data ?? [];
+    const missingByType = new Map();
+    for (const page of structured)
+        for (const check of page.richResults ?? [])
+            if (check.missingRequired.length || check.problems.length)
+                missingByType.set(check.type, [
+                    ...(missingByType.get(check.type) ?? []),
+                    {
+                        url: page.url,
+                        text: `${page.url}: ${[...check.missingRequired.map((p) => `${p} missing`), ...check.problems].join(", ")}`,
+                    },
+                ]);
+    for (const [type, items] of missingByType)
+        add("rich-result-required-missing", items, {
+            group: type,
+            title: `${type} structured data lacks documented required properties`,
+        });
+    const offerPages = structured.filter((s) => s.offers?.products?.length);
+    if (offerPages.length) {
+        const outcome = (key) => offerPages.flatMap((s) => s.offers.products
+            .filter((p) => p.outcomes[key] === "mismatch")
+            .map((p) => ({
+            url: s.url,
+            text: key === "price"
+                ? `${s.url}: declared ${p.declared.price} ${p.declared.currency ?? ""}, visible ${p.visible.prices.join(", ")}`
+                : key === "currency"
+                    ? `${s.url}: declared ${p.declared.currency}, visible ${p.visible.currencies.join(", ")}`
+                    : `${s.url}: declared ${p.declared.availability}, page says "${p.visible.availability}"`,
+        })));
+        add("offer-price-mismatch", outcome("price"));
+        add("offer-currency-mismatch", outcome("currency"));
+        add("offer-availability-mismatch", outcome("availability"));
+        add("offer-comparison-review", offerPages.flatMap((s) => s.offers.products
+            .filter((p) => Object.values(p.outcomes).includes("review"))
+            .map((p) => ({
+            url: s.url,
+            text: `${s.url}: ${Object.entries(p.outcomes)
+                .filter(([, v]) => v === "review")
+                .map(([k]) => k)
+                .join(", ")} ambiguous${p.ambiguous ? " (several products, a price range or many visible prices)" : ""}`,
+        }))));
+    }
+    else
+        for (const code of [
+            "offer-price-mismatch",
+            "offer-currency-mismatch",
+            "offer-availability-mismatch",
+            "offer-comparison-review",
+        ])
+            skip(code, structured.length || linkGraph ? "not-applicable" : "unavailable", "no product offers in structured data");
+    if (!structured.some((s) => s.richResults?.length))
+        skip("rich-result-required-missing", linkGraph ? "not-applicable" : "unavailable", "no recognised rich-result types");
+    add("structured-data-rendered-only", structured
+        .filter((s) => s.source === "rendered-only")
+        .map((s) => ({ url: s.url, text: `${s.url}: ${s.types.join(", ")}` })));
+    // ---- Performance ----
+    const lighthouse = of("lighthouse");
+    const mobileRuns = lighthouse.filter((l) => l.data.device === "mobile");
+    if (!lighthouse.length)
+        for (const code of [
+            "slow-mobile",
+            "performance-opportunities",
+            "small-performance-opportunities",
+            "heavy-pages",
+            "unsized-images",
+        ])
+            skip(code, lighthouseOn && scan.options.browser
+                ? "unavailable"
+                : "not-checked", lighthouseOn
+                ? "no Lighthouse run completed"
+                : "Lighthouse not run in this scan");
+    add("slow-mobile", mobileRuns
+        .filter((l) => typeof l.data.scores?.performance === "number" &&
+        l.data.scores.performance < 0.5)
+        .map((l) => ({
+        url: l.data.url,
+        text: `${Math.round(l.data.scores.performance * 100)} ${l.data.url}`,
+    })));
+    const opportunities = mobileRuns.flatMap((l) => (l.data.opportunities ?? []).map((o) => ({ ...o, url: l.data.url })));
+    const substantial = (o) => (o.savingsMs ?? 0) >= 500 || (o.savingsBytes ?? 0) >= 100_000;
+    const byAudit = new Map();
+    for (const o of opportunities)
+        byAudit.set(o.id, [...(byAudit.get(o.id) ?? []), o]);
+    for (const [id, items] of byAudit) {
+        const big = items.filter(substantial), small = items.filter((o) => !substantial(o));
+        const line = (o) => ({
+            url: o.url,
+            text: `${o.savingsMs ?? 0} ms, ${Math.round((o.savingsBytes ?? 0) / 1024)} KiB estimated on ${o.url}${o.items?.length
+                ? ` (${o.items
+                    .map((i) => i.url ?? i.node)
+                    .filter(Boolean)
+                    .slice(0, 3)
+                    .join(", ")})`
+                : ""}`,
+        });
+        if (big.length)
+            add("performance-opportunities", big.sort((a, b) => (b.savingsMs ?? 0) - (a.savingsMs ?? 0)).map(line), {
+                group: id,
+                title: auditCondition(id),
+            });
+        if (small.length)
+            add("small-performance-opportunities", small.map(line), {
+                group: id,
+                title: auditCondition(id),
+            });
+    }
+    // Page weight from Lighthouse when it ran, otherwise from our own pass.
+    const weights = (mobileRuns.length
+        ? mobileRuns.map((l) => ({
+            url: l.data.url,
+            bytes: l.data.weight?.total?.bytes ?? null,
+        }))
+        : browserMetrics.map((m) => ({ url: m.key, bytes: m.data.bytes ?? null }))).filter((w) => typeof w.bytes === "number");
+    const median = (values) => {
+        const sorted = values
+            .filter((v) => typeof v === "number")
+            .sort((a, b) => a - b);
+        return sorted.length ? sorted[Math.floor(sorted.length / 2)] : null;
+    };
+    const metrics = browserMetrics.length
+        ? {
+            pages: browserMetrics.length,
+            ttfb: median(browserMetrics.map((m) => m.data.ttfb)),
+            fcp: median(browserMetrics.map((m) => m.data.fcp)),
+            lcp: median(browserMetrics.map((m) => m.data.lcp)),
+            cls: median(browserMetrics.map((m) => m.data.cls)),
+            bytes: median(browserMetrics.map((m) => m.data.bytes)),
+            thirdPartyShare: (() => {
+                const total = browserMetrics.reduce((a, m) => a + (m.data.bytes ?? 0), 0);
+                const third = browserMetrics.reduce((a, m) => a + (m.data.thirdPartyBytes ?? 0), 0);
+                return total ? Math.round((third / total) * 100) : null;
+            })(),
+        }
+        : null;
+    add("slow-lcp-own-browser", browserMetrics
+        .filter((m) => (m.data.lcp ?? 0) > 4000)
+        .map((m) => ({
+        url: m.key,
+        text: `${((m.data.lcp ?? 0) / 1000).toFixed(1)} s ${m.key}`,
+    })));
+    add("heavy-pages", weights
+        .filter((w) => w.bytes > 3_000_000)
+        .sort((a, b) => b.bytes - a.bytes)
+        .map((w) => ({
+        url: w.url,
+        text: `${(w.bytes / 1_000_000).toFixed(1)} MB ${w.url}`,
+    })));
+    add("slow-responses", okPages
+        .filter((p) => (p.data.http?.durationMs ?? 0) > 1500)
+        .sort((a, b) => b.data.http.durationMs - a.data.http.durationMs)
+        .map((p) => ({
+        url: p.key,
+        text: `${(p.data.http.durationMs / 1000).toFixed(1)} s ${p.key}`,
+    })));
+    const fieldRows = of("field-data");
+    const field = fieldFrom(fieldRows.find((f) => f.key === new URL(scan.url).origin)?.data ??
+        fieldRows.find((f) => f.data.level !== "url")?.data);
+    // Page-level data is kept only where Google has it; pages without data
+    // fall back to the origin record and are counted, not listed.
+    const fieldPageRows = fieldRows.filter((f) => f.data.level === "url");
+    const fieldPages = fieldPageRows
+        .filter((f) => f.data.available)
+        .map((f) => ({ url: f.key, ...fieldFrom(f.data) }));
+    const poorLines = (d) => [
+        ...(d.lcp !== null && d.lcp > 4000
+            ? [`Largest Contentful Paint ${(d.lcp / 1000).toFixed(1)} s`]
+            : []),
+        ...(d.inp !== null && d.inp > 500
+            ? [`Interaction to Next Paint ${d.inp} ms`]
+            : []),
+        ...(d.cls !== null && d.cls > 0.25
+            ? [`Cumulative Layout Shift ${d.cls}`]
+            : []),
+    ];
+    if (field?.verdict === "poor")
+        add("field-vitals-poor", poorLines(field));
+    else if (!fieldRows.length) {
+        skip("field-vitals-poor", "not-checked", "no Google API key configured");
+        skip("field-page-vitals-poor", "not-checked", "no Google API key configured");
+    }
+    else if (!field?.available)
+        skip("field-vitals-poor", "unavailable", field?.note);
+    add("field-page-vitals-poor", fieldPages
+        .filter((f) => f.verdict === "poor")
+        .flatMap((f) => poorLines(f).map((l) => ({ url: f.url, text: `${l} on ${f.url}` }))));
+    if (fieldRows.length && !fieldPages.length)
+        skip("field-page-vitals-poor", "unavailable", "no page-level Chrome UX Report data for any crawled page");
+    add("unsized-images", mobileRuns
+        .filter((l) => (l.data.unsizedImages ?? 0) > 0)
+        .map((l) => ({
+        url: l.data.url,
+        text: `${l.data.unsizedImages} on ${l.data.url}`,
+    })));
+    // ---- Accessibility and usability ----
+    const byRule = new Map();
+    const byReview = new Map();
+    for (const d of details) {
+        for (const v of d.data.accessibility?.violations ?? []) {
+            const entry = byRule.get(v.id) ?? {
+                help: v.help,
+                items: [],
+                impact: v.impact ?? null,
+            };
+            const sample = (v.nodes ?? [])[0];
+            entry.items.push({
+                url: d.key,
+                text: `${v.nodeCount ?? v.nodes?.length ?? 0} elements on ${d.key}${sample?.target ? `, for example ${sample.target}` : ""}`,
+            });
+            byRule.set(v.id, entry);
+        }
+        for (const v of d.data.accessibility?.incomplete ?? []) {
+            const entry = byReview.get(v.id) ?? {
+                help: v.help,
+                items: [],
+            };
+            entry.items.push({
+                url: d.key,
+                text: `${v.nodeCount ?? v.nodes?.length ?? 0} elements on ${d.key}`,
+            });
+            byReview.set(v.id, entry);
+        }
+    }
+    for (const [id, entry] of byRule)
+        add("accessibility-violations", entry.items, {
+            group: id,
+            title: accessibilityCondition(id),
+            severity: ["critical", "serious"].includes(entry.impact ?? "")
+                ? "warning"
+                : "hint",
+        });
+    for (const [id, entry] of byReview)
+        add("accessibility-review", entry.items, {
+            group: id,
+            title: accessibilityCondition(id, true),
+        });
+    if (!details.length)
+        for (const code of [
+            "accessibility-violations",
+            "accessibility-review",
+            "mobile-overflow",
+            "focus-indicator",
+            "javascript-errors",
+            "external-errors",
+            "mixed-content",
+            "trackers-before-consent",
+            "cookies-before-consent",
+            "slow-lcp-own-browser",
+        ])
+            skip(code, scan.options.browser ? "unavailable" : "not-checked", scan.options.browser
+                ? "no page completed the browser pass"
+                : "browser pass disabled");
+    add("missing-alt", content
+        .map((p) => ({
+        key: p.key,
+        missing: (p.data.images ?? []).filter((i) => i.alt === null)
+            .length,
+    }))
+        .filter((p) => p.missing)
+        .map((p) => ({ url: p.key, text: `${p.missing} on ${p.key}` })));
+    add("forms-without-labels", content.flatMap((p) => (p.data.forms ?? []).flatMap((f) => (f.controls ?? [])
+        .filter((c) => !c.hasAccessibleName &&
+        !["hidden", "submit", "button", "reset"].includes(c.type))
+        .map((c) => ({
+        url: p.key,
+        text: `${c.name ?? c.id ?? c.tag} on ${p.key}`,
+    })))));
+    add("mobile-overflow", details.flatMap((d) => (d.data.overflow ?? [])
+        .filter((o) => o.width <= 375 &&
+        o.conclusive === true &&
+        o.documentOverflow === true)
+        .map((o) => ({
+        url: d.key,
+        text: `${o.documentWidth}px document at ${o.width}px viewport on ${d.key}`,
+    }))));
+    add("focus-indicator", details
+        .filter((d) => (d.data.keyboard?.withoutVisibleIndicator ?? 0) > 0)
+        .map((d) => ({
+        url: d.key,
+        text: `${d.data.keyboard.withoutVisibleIndicator} of ${d.data.keyboard.stops} tab stops on ${d.key}`,
+    })));
+    const consoleLines = details.flatMap((d) => (d.data.console ?? [])
+        .filter((c) => c.type === "pageerror" || c.type === "error")
+        .map((c) => ({
+        text: String(c.text).replace(/\s+/g, " ").slice(0, 160),
+        page: d.key,
+    })));
+    const isExternalError = (text) => /Content Security Policy|Failed to load resource|net::ERR_|ERR_BLOCKED_BY_CLIENT|Refused to (connect|load|frame)/i.test(text) || [...text.matchAll(/https?:\/\/[^\s'")]+/g)].some((m) => !own(m[0]));
+    const errorGroups = (lines) => {
+        const groups = new Map();
+        for (const line of lines) {
+            const key = line.text.replace(/\d+/g, "N").slice(0, 80);
+            const items = groups.get(key) ?? [];
+            if (!items.some((i) => i.url === line.page))
+                items.push({ url: line.page, text: `${line.text} on ${line.page}` });
+            groups.set(key, items);
+        }
+        return groups;
+    };
+    for (const [key, items] of errorGroups(consoleLines.filter((c) => !isExternalError(c.text))))
+        add("javascript-errors", items, {
+            group: key,
+            title: `JavaScript error: ${items[0].text.replace(/ on https?:\/\/\S+$/, "")}`,
+        });
+    for (const [key, items] of errorGroups(consoleLines.filter((c) => isExternalError(c.text))))
+        add("external-errors", items, {
+            group: key,
+            title: `Third-party or blocked request error: ${items[0].text.replace(/ on https?:\/\/\S+$/, "")}`,
+        });
+    // ---- Business and profiles ----
+    if (home && home.data.html !== false) {
+        const social = (home.data.social ?? []);
+        const socialImages = social
+            .filter((m) => /^(og:image|twitter:image)/.test(m.property ?? m.name ?? ""))
+            .map((m) => m.content);
+        if (!socialImages.length)
+            add("missing-social-image", [withLink(home.key)]);
+        else {
+            const broken = socialImages.flatMap((src) => {
+                const key = [...resourceByKey.keys()].find((k) => k === src || k.endsWith(src));
+                const r = key ? resourceByKey.get(key) : null;
+                if (!r)
+                    return [];
+                const type = r.data.http?.headers?.["content-type"] ?? "";
+                return (status(r) ?? 0) >= 400 ||
+                    r.data.http?.outcome === "error" ||
+                    (status(r) === 200 && type && !/^image\//i.test(type))
+                    ? [
+                        {
+                            url: home.key,
+                            text: `${failure(r)}${type && !/^image\//i.test(type) ? ` ${type}` : ""} ${r.key}`,
+                        },
+                    ]
+                    : [];
+            });
+            add("social-image-broken", broken);
+        }
+        const favicon = (home.data.icons ?? []).length > 0 ||
+            resources.some((r) => /\/favicon\.ico$/.test(r.key) && r.data.http?.status === 200);
+        if (!favicon)
+            add("missing-favicon", [withLink(home.key)]);
+    }
+    if (business) {
+        const profiles = business.profiles ?? [];
+        add("profile-broken", profiles
+            .filter((p) => p.verification === "broken")
+            .map((p) => ({
+            url: null,
+            text: `${p.status ?? p.outcome} ${p.url} (${p.platform}, linked from ${p.pages} pages)`,
+        })));
+        add("profile-unverifiable", profiles
+            .filter((p) => p.verification === "unverifiable")
+            .map((p) => ({
+            url: null,
+            text: `${p.status ?? p.outcome} ${p.url} (${p.platform} blocks automated checks)`,
+        })));
+        add("profile-variants", (business.platformVariants ?? []).map((v) => `${v.platform}: ${v.urls.join(", ")}`));
+        add("sameas-not-linked", (business.sameAs ?? [])
+            .filter((s) => !s.linkedOnSite)
+            .map((s) => s.url));
+        if ((business.sameAs ?? []).length)
+            add("linked-not-sameas", profiles
+                .filter((p) => !p.inSameAs)
+                .map((p) => `${p.url} (${p.platform})`));
+        else
+            skip("linked-not-sameas", "not-applicable", "no sameAs declared");
+        const names = [
+            ...new Set([
+                ...(business.names?.structured ?? []).map((n) => n.name),
+                ...(business.names?.siteName ?? []),
+            ]),
+        ];
+        if (names.length > 1)
+            add("business-name-variants", names.map((n) => `"${n}"`));
+        if ((business.phones?.structured ?? []).length &&
+            (business.phones?.visibleNotDeclared?.length ||
+                business.phones?.declaredNotVisible?.length))
+            add("phone-mismatch", [
+                ...(business.phones.declaredNotVisible ?? []).map((p) => `declared ${p} not shown on any page`),
+                ...(business.phones.visibleNotDeclared ?? []).map((p) => `visible ${p} not in structured data`),
+            ]);
+        else if (!(business.phones?.structured ?? []).length)
+            skip("phone-mismatch", "not-applicable", "no telephone in structured data");
+        if (!profiles.length) {
+            skip("profile-broken", "not-applicable", "no profile links found");
+            skip("profile-unverifiable", "not-applicable", "no profile links found");
+            skip("profile-variants", "not-applicable", "no profile links found");
+        }
+        if (!(business.maps ?? []).length)
+            skip("map-link-broken", "not-applicable", "no map links found");
+    }
+    else
+        for (const code of [
+            "profile-broken",
+            "profile-unverifiable",
+            "profile-variants",
+            "sameas-not-linked",
+            "linked-not-sameas",
+            "business-name-variants",
+            "phone-mismatch",
+            "map-link-broken",
+        ])
+            skip(code, "unavailable", "site analysis did not run");
+    // ---- AI and agent access ----
+    const ai = of("ai-discovery")[0]?.data;
+    if (ai) {
+        if (!ai.llms?.present)
+            add("llms-missing", [
+                withLink(ai.llms?.url ?? `${new URL(scan.url).origin}/llms.txt`),
+            ]);
+        else {
+            add("llms-links-broken", ai.llms.links
+                .filter((l) => l.url &&
+                resourceByKey.has(l.url) &&
+                ((status(resourceByKey.get(l.url)) ?? 0) >= 400 ||
+                    resourceByKey.get(l.url).data.http?.outcome === "error"))
+                .map((l) => ({
+                url: null,
+                text: `${failure(resourceByKey.get(l.url))} ${l.url} ("${l.text}")`,
+            })));
+            const names = [
+                ...(business?.names?.structured ?? []).map((n) => n.name),
+                ...(business?.names?.siteName ?? []),
+                home?.data.title ?? "",
+            ]
+                .filter(Boolean)
+                .map((n) => n.toLowerCase());
+            if (ai.llms.title &&
+                names.length &&
+                !names.some((n) => n.includes(ai.llms.title.toLowerCase()) ||
+                    ai.llms.title.toLowerCase().includes(n.split(/[|–-]/)[0].trim())))
+                add("llms-title-mismatch", [
+                    `llms.txt: "${ai.llms.title}"; site: ${names
+                        .slice(0, 3)
+                        .map((n) => `"${n}"`)
+                        .join(", ")}`,
+                ]);
+        }
+    }
+    else
+        for (const code of [
+            "llms-missing",
+            "llms-links-broken",
+            "llms-title-mismatch",
+        ])
+            skip(code, "unavailable", "discovery did not run");
+    const markdown = of("markdown");
+    const probed = pages.filter((p) => p.data.markdownProbe === "full").length;
+    if (markdown.length && !markdown.some((m) => m.data.usable))
+        add("markdown-unavailable", [
+            `${probed} pages probed with Accept: text/markdown and .md locations`,
+        ]);
+    else if (!markdown.length)
+        skip("markdown-unavailable", "unavailable", "no Markdown probes recorded");
+    // ---- Secondary facts: security, scores, indexability ----
+    const security = {
+        safeBrowsing: safe?.status === "observed"
+            ? { flagged: !!safe.flagged, threats: safe.threats ?? [] }
+            : null,
+        tlsGrade: labs?.status === "observed" ? (labs.grade ?? null) : null,
+        hstsPreload: of("hsts-preload")[0]?.data?.preload ?? null,
+        blocklists: listResults.length
+            ? {
+                listed: listResults
+                    .filter((r) => r.status === "listed")
+                    .map((r) => r.list),
+                clean: listResults
+                    .filter((r) => r.status === "clean")
+                    .map((r) => r.list),
+                unavailable: listResults
+                    .filter((r) => r.status === "unavailable")
+                    .map((r) => r.list),
+            }
+            : null,
+        certificates: certificates?.status === "observed"
+            ? {
+                hostnames: certificates.hostnames.length,
+                issuedLast30Days: certificates.issuedLast30Days ?? 0,
+                sample: certificates.hostnames.slice(0, 20),
+            }
+            : null,
+    };
+    const history = of("field-history")[0]?.data;
+    if (field && history?.available)
+        field.history = history.points.filter((p) => p.to).slice(-25);
+    const scores = (device) => {
+        const runs = lighthouse.filter((l) => l.data.device === device && l.data.scores);
+        if (!runs.length)
+            return null;
+        const average = (id) => {
+            const values = runs
+                .map((r) => r.data.scores[id])
+                .filter((v) => typeof v === "number");
+            return values.length
+                ? Math.round((values.reduce((a, b) => a + b, 0) / values.length) * 100)
+                : null;
+        };
+        return {
+            performance: average("performance"),
+            accessibility: average("accessibility"),
+            bestPractices: average("best-practices"),
+            seo: average("seo"),
+        };
+    };
+    let mobile = scores("mobile");
+    let desktop = scores("desktop");
+    let measuredAt = lighthouse.length
+        ? scan.createdAt
+        : null;
+    let carried = false;
+    if (!lighthouse.length && input.previous?.lastScores?.mobile) {
+        // No Lighthouse in this scan: carry the last measured scores forward.
+        const last = input.previous.lastScores;
+        mobile = last.mobile;
+        desktop = last.desktop ?? null;
+        measuredAt = last.measuredAt ?? null;
+        carried = true;
+    }
+    // ---- Ordering, priorities, counts ----
+    findings.sort((a, b) => severityRank[a.severity] - severityRank[b.severity] ||
+        confidenceRank[a.confidence] - confidenceRank[b.confidence] ||
+        b.pages - a.pages ||
+        b.count - a.count ||
+        a.id.localeCompare(b.id));
+    const counts = {
+        critical: findings.filter((f) => f.severity === "critical").length,
+        warning: findings.filter((f) => f.severity === "warning").length,
+        hint: findings.filter((f) => f.severity === "hint").length,
+    };
+    const priorities = findings
+        .filter((f) => f.severity === "critical" ||
+        (f.severity === "warning" && f.confidence !== "review"))
+        .slice(0, 5)
+        .map((f) => f.id);
+    const indexability = {
+        indexable: htmlPages.filter((p) => !noindex(p) && !canonicalElsewhere(p))
+            .length,
+        noindex: htmlPages.filter((p) => noindex(p)).length,
+        canonicalElsewhere: htmlPages.filter((p) => !noindex(p) && canonicalElsewhere(p)).length,
+        broken: brokenPages.length,
+        blocked: pages.filter((p) => ["blocked", "inconclusive"].includes(p.data.http?.outcome)).length,
+    };
+    // ---- Coverage: what was discovered, checked, skipped or left ----
+    const jobs = scan.coverage?.jobs ?? [];
+    const jobCount = (kind, ...statuses) => jobs
+        .filter((j) => j.kind === kind && statuses.includes(j.status))
+        .reduce((n, j) => n + j.count, 0);
+    const remainingWork = jobs
+        .filter((j) => ["cancelled", "failed", "queued", "running"].includes(j.status))
+        .map((j) => ({ kind: j.kind, status: j.status, count: j.count }));
+    const resourceRows = urlRows.filter((u) => u.kind === "resource");
+    const sitemapRows = urlRows.filter((u) => u.kind === "sitemap");
+    const notFollowed = {};
+    for (const u of pageRows)
+        if (u.skipReason)
+            notFollowed[u.skipReason] = (notFollowed[u.skipReason] ?? 0) + 1;
+    const browserStatus = of("browser");
+    const lighthouseRuns = of("lighthouse-run");
+    const browserCount = (s) => browserStatus.filter((b) => b.data.status === s).length;
+    const renderedList = [...renderedByKey.values()];
+    const external = {
+        chromeUxReport: !fieldRows.length
+            ? "not configured"
+            : field?.available
+                ? "origin data available"
+                : (field?.note ?? "no data"),
+        safeBrowsing: !safe
+            ? "not configured"
+            : safe.status === "observed"
+                ? "checked"
+                : `unavailable (${safe.error})`,
+        sslLabs: labs?.status === "observed"
+            ? `grade ${labs.grade}, tested ${labs.testedAt ?? "unknown"}`
+            : (labs?.status ?? "unavailable"),
+        hstsPreload: of("hsts-preload")[0]?.data?.preload ?? "unavailable",
+        certificateLogs: certificates?.status ?? "unavailable",
+        blocklists: listResults.length
+            ? listResults.map((r) => `${r.list} ${r.status}`).join(", ")
+            : "unavailable",
+        registration: domainData?.status ?? "unavailable",
+    };
+    const limits = {};
+    for (const key of [
+        "maxPages",
+        "maxDiscoveredUrls",
+        "maxResources",
+        "maxBrowserPages",
+        "maxSitemaps",
+    ])
+        if (scan.options[key] !== undefined)
+            limits[key] = scan.options[key];
+    for (const key of ["maxQueryVariantsPerPath"])
+        if (scan.options[key] !== undefined)
+            limits[key] = scan.options[key];
+    const expectedSlash = new Set(htmlPages
+        .filter((p) => slashTwin(p.key))
+        .map((p) => p.key.replace(/\/$/, "")));
+    const checkedSlash = new Set(slashVariants.filter((r) => r.data.result !== "unknown").map((r) => r.key));
+    const missingSlash = [...expectedSlash].filter((key) => !checkedSlash.has(key));
+    const notReachedPages = followedPages.filter((u) => !byKey.has(u.url)).length;
+    const coverageNotes = [];
+    if (scan.coverage?.expired)
+        coverageNotes.push("The scan reached its time limit; remaining work was cancelled and is listed as remaining work.");
+    if (notFollowed["query-variants-limited"])
+        coverageNotes.push(`${notFollowed["query-variants-limited"]} query-string variants were not followed after ${scan.options.maxQueryVariantsPerPath} per path (crawl-trap rule).`);
+    if (omitted)
+        coverageNotes.push(`${omitted} discovered URLs were omitted by the explicit discovery limit.`);
+    if (missingSlash.length)
+        coverageNotes.push(`${missingSlash.length} trailing-slash pairs could not be verified.`);
+    // Lighthouse eligibility was fixed at the crawl-to-enrichment transition;
+    // every eligible page not selected was left out by an explicit limit.
+    const lighthouseEligible = Number(scan.coverage?.lighthouseEligible ?? htmlPages.length);
+    const lighthouseOmitted = scan.options.browser && lighthouseOn
+        ? Math.max(0, lighthouseEligible - (scan.coverage?.lighthouseSelected ?? []).length)
+        : 0;
+    if (lighthouseOmitted)
+        coverageNotes.push(`${lighthouseOmitted} of ${lighthouseEligible} eligible pages were not measured with Lighthouse because of the explicit page limit.`);
+    const coverage = {
+        discovered: pageRows.length + omitted,
+        crawled: pages.length,
+        omitted,
+        sampled: pageRows.length + omitted > pages.length,
+        // Complete means every discovered page, file and check was covered;
+        // explicit limits and unrun browser or Lighthouse passes make it false.
+        complete: scan.status === "completed" &&
+            remainingWork.length === 0 &&
+            notReachedPages === 0 &&
+            omitted === 0 &&
+            !urlRows.some((u) => u.skipReason === "explicit-limit") &&
+            (!scan.options.browser || browserStatus.length >= htmlPages.length) &&
+            (!(scan.options.browser && lighthouseOn) ||
+                (lighthouseOmitted === 0 &&
+                    (scan.coverage?.lighthouseSelected ?? []).length <=
+                        lighthouseRuns.length)) &&
+            !scan.coverage?.expired,
+        pages: {
+            discovered: pageRows.length + omitted,
+            followed: followedPages.length,
+            notFollowed,
+            observed: pages.length,
+            ok: okPages.length,
+            broken: brokenPages.length,
+            blocked: pages.filter((p) => p.data.http?.outcome === "blocked").length,
+            inconclusive: pages.filter((p) => p.data.http?.outcome === "inconclusive")
+                .length,
+            notReached: notReachedPages,
+        },
+        resources: {
+            // Trailing-slash twins are recorded by page jobs without a discovery row.
+            discovered: new Set([
+                ...resourceRows.map((u) => u.url),
+                ...resources.map((r) => r.key),
+            ]).size,
+            checked: resources.length,
+            ok: resources.filter((r) => r.data.http?.outcome === "ok").length,
+            broken: brokenResources.length,
+            inconclusive: resources.filter((r) => r.data.http?.outcome === "inconclusive" ||
+                r.data.http?.outcome === "blocked").length,
+            unverifiable: resources.filter((r) => !own(r.key) && platformBlocked(r.key) && (status(r) ?? 0) >= 400).length,
+            notChecked: resourceRows.filter((u) => u.scheduled && !resourceByKey.has(u.url))
+                .length +
+                resourceRows.filter((u) => u.skipReason === "explicit-limit").length,
+        },
+        sitemaps: {
+            discovered: sitemapRows.length,
+            fetched: sitemaps.length,
+            valid: validSitemaps.length,
+            invalid: sitemaps.filter((s) => !s.data.valid &&
+                (sources.get(s.key) ?? []).some((src) => src !== "default-location")).length,
+            entries: sitemapEntries.size,
+            notFetched: sitemapRows.filter((u) => u.scheduled).length - sitemaps.length,
+        },
+        browser: {
+            enabled: scan.options.browser,
+            eligible: htmlPages.length,
+            completed: browserCount("completed"),
+            partial: browserCount("partial"),
+            skipped: browserCount("skipped"),
+            notRun: Math.max(0, htmlPages.length - browserStatus.length),
+        },
+        lighthouse: {
+            enabled: scan.options.browser && lighthouseOn,
+            eligible: lighthouseEligible,
+            selected: (scan.coverage?.lighthouseSelected ?? []).length,
+            omitted: lighthouseOmitted,
+            completed: lighthouseRuns.filter((r) => r.data.status === "completed")
+                .length,
+            partial: lighthouseRuns.filter((r) => r.data.status === "partial").length,
+            notRun: Math.max(0, (scan.coverage?.lighthouseSelected ?? []).length -
+                lighthouseRuns.length),
+            devices: lighthouse.length
+                ? [...new Set(lighthouse.map((l) => l.data.device))]
+                : [],
+        },
+        interactions: {
+            pagesScrolled: renderedList.filter((r) => r.interactions?.scroll?.performed).length,
+            loadMoreFound: renderedList.filter((r) => r.interactions?.loadMore?.found)
+                .length,
+            loadMoreClicked: renderedList.filter((r) => r.interactions?.loadMore?.clicked).length,
+            notPerformed: renderedList[0]?.interactions?.notPerformed ?? [
+                "form submissions",
+                "filter, sort and dropdown controls",
+                "sign-in or account actions",
+                "cookie consent choices",
+                "repeated infinite-scroll loads beyond one pass",
+            ],
+        },
+        slashVariants: {
+            expected: expectedSlash.size,
+            verified: expectedSlash.size - missingSlash.length,
+            unknown: missingSlash,
+        },
+        remainingWork,
+        expired: !!scan.coverage?.expired,
+        external,
+        limits,
+        notes: coverageNotes,
+    };
+    // ---- Checks: every rule with its outcome ----
+    const available = {
+        pages: pages.length > 0,
+        browser: details.length > 0,
+        lighthouse: lighthouse.length > 0,
+        rendered: renderedByKey.size > 0,
+        dns: !!dns,
+        tls: tls?.status === "observed",
+        domain: !!domain,
+        "url-variant": variants.length > 0,
+        robots: !!homePolicy,
+        sitemap: sitemaps.length > 0 || sitemapRows.length > 0,
+        analysis: !!linkGraph,
+        "structured-data": structured.length > 0,
+        "field-data": !!field?.available,
+        "safe-browsing": safe?.status === "observed",
+        "ssl-labs": labs?.status === "observed",
+        blocklists: listResults.some((r) => r.status !== "unavailable"),
+        certificates: certificates?.status === "observed",
+        "ai-discovery": !!ai,
+        options: true,
+    };
+    const checks = Object.entries(rules).map(([code, rule]) => {
+        const raised = findings.filter((f) => f.code === code);
+        const skipped = skips.get(code);
+        const outcome = raised.length
+            ? raised.every((f) => f.confidence === "review")
+                ? "review"
+                : "issue"
+            : skipped
+                ? skipped.outcome
+                : available[rule.requires]
+                    ? "passed"
+                    : "not-checked";
+        return {
+            code,
+            topic: rule.topic,
+            title: rule.title,
+            outcome,
+            detail: raised.length
+                ? `${raised.reduce((n, f) => n + f.count, 0)} items on ${new Set(raised.flatMap((f) => f.urls)).size} pages`
+                : skipped?.detail,
+        };
+    });
+    const topics = Object.fromEntries(topicOrder.map((topic) => {
+        const own = findings.filter((f) => f.topic === topic);
+        const topicChecks = checks.filter((c) => c.topic === topic);
+        const status = own.some((f) => f.severity !== "hint")
+            ? "issues"
+            : own.length
+                ? "review"
+                : topicChecks.some((c) => c.outcome === "passed")
+                    ? "passed"
+                    : topicChecks.every((c) => c.outcome === "not-applicable")
+                        ? "not-applicable"
+                        : topicChecks.some((c) => c.outcome === "unavailable")
+                            ? "unavailable"
+                            : "not-checked";
+        return [
+            topic,
+            {
+                status,
+                findings: own.length,
+                critical: own.filter((f) => f.severity === "critical").length,
+                warning: own.filter((f) => f.severity === "warning").length,
+                hint: own.filter((f) => f.severity === "hint").length,
+                facts: [],
+            },
+        ];
+    }));
+    // Facts: useful measurements that are not problems.
+    const fact = (topic, text) => {
+        if (text)
+            topics[topic].facts.push(text);
+    };
+    if (tls?.status === "observed")
+        fact("availability-security", `TLS ${tls.protocol ?? ""} certificate by ${tls.certificate?.issuer?.O ?? tls.certificate?.issuer?.CN ?? "unknown issuer"}, valid until ${String(tls.certificate?.validTo ?? "").slice(0, 24)} (${tls.daysRemaining} days)`);
+    if (dns?.records)
+        fact("availability-security", `Nameservers ${(dns.records.ns?.values ?? []).join(", ") || "unavailable"}; mail servers ${(dns.records.mx?.values ?? []).map((m) => m.exchange).join(", ") || "none"}; SPF ${dns.email?.spf?.length ? "present" : "absent"}, DMARC ${dns.email?.dmarc?.[0]?.match(/p=(\w+)/)?.[1] ?? "absent"}, MTA-STS ${dns.email?.mtaSts?.length ? "present" : "absent"}, BIMI ${dns.email?.bimi?.length ? "present" : "absent"}`);
+    fact("availability-security", security.tlsGrade ? `SSL Labs grade ${security.tlsGrade}` : null);
+    fact("availability-security", security.hstsPreload ? `HSTS preload status ${security.hstsPreload}` : null);
+    fact("availability-security", security.certificates
+        ? `${security.certificates.hostnames} hostnames in certificate logs, ${security.certificates.issuedLast30Days} certificates issued in the last 30 days`
+        : null);
+    fact("availability-security", security.safeBrowsing
+        ? `Safe Browsing ${security.safeBrowsing.flagged ? "flagged" : "clean"}`
+        : null);
+    fact("crawling-indexability", `${indexability.indexable} indexable pages, ${indexability.noindex} noindex, ${indexability.canonicalElsewhere} canonical elsewhere, ${indexability.broken} broken, ${indexability.blocked} blocked or inconclusive`);
+    fact("crawling-indexability", validSitemaps.length
+        ? `${validSitemaps.length} valid sitemaps with ${sitemapEntries.size} entries; ${[...sitemapEntries.keys()].filter((u) => byKey.has(u)).length} of them crawled`
+        : null);
+    if (homePolicy?.bots)
+        for (const purpose of ["search", "training", "user-request"]) {
+            const bots = homePolicy.bots.filter((b) => b.purpose === purpose);
+            if (bots.length)
+                fact("ai-agent-access", `robots.txt for ${purpose} crawlers: ${bots.map((b) => `${b.bot} ${b.allowed === null ? "unknown" : b.allowed ? "allowed" : "disallowed"}`).join(", ")}`);
+        }
+    fact("ai-agent-access", ai
+        ? `llms.txt ${ai.llms?.present ? `present (${ai.llms.links.length} links, ${ai.llms.characters} characters)` : "absent"}; llms-full.txt ${ai.llmsFull?.present ? "present" : "absent"}`
+        : null);
+    fact("ai-agent-access", markdown.length
+        ? `Markdown alternatives: ${markdown.filter((m) => m.data.usable).length} usable of ${markdown.length} probes on ${probed} fully probed pages`
+        : null);
+    fact("ai-agent-access", renderedList.length
+        ? `${renderedList.filter((r) => r.comparison?.text?.ratio !== null && r.comparison?.text?.ratio >= 0.5).length} of ${renderedList.length} browser-tested pages keep at least half of their text without JavaScript`
+        : null);
+    fact("content-structure", `${[...new Set(content.map((p) => languageOfTag(p.data.language)).filter(Boolean))].join(", ") || "no"} declared languages; median ${median(content.map((p) => p.data.wordCount ?? 0)) ?? 0} words per page`);
+    fact("links-navigation", linkGraph
+        ? `${graphPages.filter((p) => p.clickDepth !== null).length} pages reachable from the homepage by links, deepest at ${Math.max(0, ...graphPages.map((p) => p.clickDepth ?? 0))} clicks; ${resources.length} linked files and external destinations checked`
+        : null);
+    fact("structured-data", structured.length
+        ? `Structured data on ${structured.length} pages: ${[...new Set(structured.flatMap((s) => s.types))].slice(0, 12).join(", ")}`
+        : null);
+    fact("performance", metrics
+        ? `Own browser medians over ${metrics.pages} pages: first byte ${metrics.ttfb ?? "-"} ms, first paint ${metrics.fcp ?? "-"} ms, largest paint ${metrics.lcp ?? "-"} ms, layout shift ${metrics.cls ?? "-"}, ${metrics.bytes ? `${(metrics.bytes / 1_000_000).toFixed(1)} MB` : "-"} transferred${metrics.thirdPartyShare !== null ? `, ${metrics.thirdPartyShare}% from other domains` : ""}`
+        : null);
+    fact("performance", mobile
+        ? `Lighthouse mobile averages${carried ? ` carried from ${measuredAt?.slice(0, 10)}` : ""}: performance ${mobile.performance ?? "-"}, accessibility ${mobile.accessibility ?? "-"}, best practices ${mobile.bestPractices ?? "-"}, SEO ${mobile.seo ?? "-"}`
+        : null);
+    fact("performance", field?.available
+        ? `Real users (origin): LCP ${field.lcp ?? "-"} ms, INP ${field.inp ?? "-"} ms, CLS ${field.cls ?? "-"}, ${field.verdict}`
+        : field
+            ? `Real-user data: ${field.note}`
+            : null);
+    fact("performance", fieldPageRows.length
+        ? `Page-level real-user data available for ${fieldPages.length} of ${fieldPageRows.length} crawled pages; the rest fall back to the origin`
+        : null);
+    fact("accessibility-usability", details.length
+        ? `axe ${details[0].data.accessibility?.engine?.version ?? ""} on ${details.length} pages: ${details.reduce((n, d) => n + (d.data.accessibility?.passes ?? 0), 0)} rule passes, ${byRule.size} violated rules, ${byReview.size} rules for manual review; ${details.filter((d) => (d.data.overflow ?? []).every((o) => o.conclusive)).length} pages with conclusive overflow measurements`
+        : null);
+    fact("business-profiles", business
+        ? `${(business.profiles ?? []).length} linked profiles on ${[...new Set((business.profiles ?? []).map((p) => p.platform))].join(", ") || "no platforms"}; ${(business.phones?.visible ?? []).length} visible phone numbers, ${(business.emails ?? []).length} email addresses, ${(business.addresses ?? []).length} structured addresses, ${(business.hours ?? []).length} opening-hours entries, ${(business.maps ?? []).length} map links`
+        : null);
+    // ---- Overview ----
+    const technologies = [
+        ...new Set(pages.flatMap((p) => (p.data.technologies ?? []).map((t) => t.name))),
+    ];
+    const pageTypes = {};
+    for (const p of htmlPages) {
+        const type = graphPages.find((g) => g.url === p.key)?.type ?? pageType(p.key);
+        pageTypes[type] = (pageTypes[type] ?? 0) + 1;
+    }
+    const languages = [
+        ...new Set(content
+            .map((p) => languageOfTag(p.data.language))
+            .filter((l) => !!l)),
+    ];
+    const structuredDataTypes = [
+        ...new Set(structured.flatMap((s) => s.types)),
+    ].slice(0, 20);
+    const characteristics = {
+        technologies,
+        languages,
+        pageTypes,
+        ecommerce: (pageTypes.product ?? 0) > 0 ||
+            technologies.some((t) => /Shopify|WooCommerce|Magento|Lightspeed/.test(t)),
+        structuredDataTypes,
+        sitemap: validSitemaps.length > 0,
+        llms: !!ai?.llms?.present,
+        markdown: markdown.some((m) => m.data.usable),
+        multilingual: languages.length > 1 || hreflangs.length > 0,
+    };
+    const summaryParts = [
+        `${pages.length} pages observed (${okPages.length} OK, ${brokenPages.length} broken)`,
+        `${counts.critical} errors, ${counts.warning} warnings and ${counts.hint} hints across ${new Set(findings.map((f) => f.topic)).size} topics`,
+        coverage.complete
+            ? "coverage complete"
+            : coverage.expired
+                ? "time limit reached, work remaining"
+                : scan.status === "partial"
+                    ? "coverage partial"
+                    : `status ${scan.status}`,
+    ];
+    const summary = summaryParts.join("; ") + ".";
+    const pending = [];
+    if (scan.status !== "completed")
+        pending.push(`Scan status: ${scan.status}`);
+    if (!pages.length || notReachedPages)
+        pending.push(`${pages.length}/${followedPages.length} followed pages observed`);
+    if (missingSlash.length)
+        pending.push(`Slash variants: ${expectedSlash.size - missingSlash.length}/${expectedSlash.size} verified`);
+    const inconclusive = [...pages, ...resources].filter((r) => ["inconclusive", "blocked"].includes(r.data.http?.outcome));
+    if (inconclusive.length)
+        pending.push(`${inconclusive.length} URLs blocked or inconclusive`);
+    if (!scan.options.browser || coverage.browser.completed < htmlPages.length)
+        pending.push(`Browser: ${coverage.browser.completed}/${htmlPages.length} pages completed${!scan.options.browser ? " (disabled)" : ""}`);
+    if (lighthouseOn && scan.options.browser) {
+        if (coverage.lighthouse.completed < coverage.lighthouse.selected)
+            pending.push(`Lighthouse: ${coverage.lighthouse.completed}/${coverage.lighthouse.selected} selected pages completed on both devices`);
+    }
+    else
+        pending.push("Lighthouse not measured in this scan; historical averages do not prove current coverage");
+    if (remainingWork.length)
+        pending.push(`Remaining work: ${remainingWork.map((w) => `${w.count} ${w.kind} ${w.status}`).join(", ")}`);
+    // ---- Changes since the previous report of the same site ----
+    const previous = input.previous;
+    let changes = null;
+    if (previous) {
+        const before = previous.report;
+        const beforeFindings = previous.findings;
+        const observedUrl = (url, code) => {
+            const page = byKey.get(url);
+            // HTML-derived checks did not run on an error response or a PDF/image.
+            // Resource availability can instead be verified by its own successful fetch.
+            if (["broken-resources", "broken-external-resources"].includes(code))
+                return resourceByKey.get(url)?.data.http?.outcome === "ok";
+            return page?.data.http?.outcome === "ok" && page.data.html !== false;
+        };
+        const checkRan = (code) => {
+            const outcome = checks.find((c) => c.code === code)?.outcome;
+            return (outcome !== undefined &&
+                !["unavailable", "not-checked"].includes(outcome));
+        };
+        // Resolution needs the evidence the rule is built on, for the affected
+        // page itself: a completed browser pass for axe and browser rules, a
+        // usable Lighthouse run for Lighthouse rules, a rendered comparison for
+        // rendered rules, real-user data for field rules, and a successful fetch
+        // for everything derived from the HTML. Anything less stays unverified.
+        const browserDone = new Set(browserStatus
+            .filter((b) => b.data.status === "completed")
+            .map((b) => b.key));
+        const lighthouseDone = new Set(lighthouse
+            .filter((l) => l.data.device === "mobile" &&
+            !l.data.runtimeError &&
+            typeof l.data.scores?.performance === "number")
+            .map((l) => l.data.url));
+        const perPage = [
+            "pages",
+            "browser",
+            "rendered",
+            "lighthouse",
+            "analysis",
+            "structured-data",
+            "field-data",
+            "sitemap",
+        ];
+        // Grouped findings need the specific rule or audit to have run again on
+        // that page: an axe rule counts only when the page's pass list names it
+        // (a rule that is now "incomplete" or absent from an older record
+        // without pass ids stays unverified); a Lighthouse audit counts only
+        // when the run did not report an error for it.
+        const groupVerified = (url, finding) => {
+            const group = finding.group ?? finding.id?.slice(finding.code.length + 1);
+            if (!group)
+                return true;
+            if (finding.code.startsWith("accessibility-")) {
+                const detail = details.find((d) => d.key === url);
+                const passed = detail?.data.accessibility?.passedRules ?? [];
+                return passed.includes(group);
+            }
+            if (finding.code.endsWith("performance-opportunities"))
+                return lighthouse.some((l) => l.data.url === url &&
+                    l.data.device === "mobile" &&
+                    !(l.data.auditErrors ?? []).some((e) => e.id === group));
+            return true;
+        };
+        const evidenceFor = (url, requires, code) => {
+            switch (requires) {
+                case "browser":
+                    return browserDone.has(url) && details.some((d) => d.key === url);
+                case "rendered":
+                    return renderedByKey.has(url);
+                case "lighthouse":
+                    return lighthouseDone.has(url);
+                case "field-data":
+                    return fieldRows.some((f) => f.key === url && f.data.available);
+                default:
+                    return observedUrl(url, code);
+            }
+        };
+        const verified = (item, finding) => {
+            const code = finding.code;
+            if (!checkRan(code))
+                return false;
+            const requires = rules[code]?.requires;
+            const text = typeof item === "string" ? item : item.text;
+            const url = (typeof item === "string" ? null : item.url) ??
+                /https?:\/\/\S+/.exec(text ?? "")?.[0]?.replace(/[),.;]+$/, "") ??
+                null;
+            // Without an affected URL only site-level rules can be rechecked.
+            if (!url)
+                return !perPage.includes(requires ?? "pages");
+            return evidenceFor(url, requires, code) && groupVerified(url, finding);
+        };
+        const diff = diffFindings(beforeFindings, findings, verified);
+        const previousPages = previous.pages;
+        const previousKeys = new Map(previousPages.map((p) => [p.key, p]));
+        const pagesAdded = pages
+            .filter((p) => p.data.http?.outcome === "ok" && !previousKeys.has(p.key))
+            .map((p) => p.key);
+        const pagesRemoved = previousPages
+            .filter((p) => p.outcome === "ok" && !byKey.has(p.key))
+            .map((p) => p.key);
+        const titleChanges = pages.flatMap((p) => {
+            const old = previousKeys.get(p.key);
+            return old && old.title && p.data.title && old.title !== p.data.title
+                ? [{ url: p.key, from: old.title, to: p.data.title }]
+                : [];
+        });
+        const changedPages = pages.flatMap((p) => {
+            const old = previousKeys.get(p.key);
+            if (!old)
+                return [];
+            const diffs = [];
+            if (old.status !== null && status(p) !== null && old.status !== status(p))
+                diffs.push(`status ${old.status} to ${status(p)}`);
+            if (old.title && p.data.title && old.title !== p.data.title)
+                diffs.push(`title "${old.title}" to "${p.data.title}"`);
+            if (typeof old.words === "number" &&
+                typeof p.data.wordCount === "number" &&
+                Math.abs(old.words - p.data.wordCount) >= Math.max(50, old.words * 0.2))
+                diffs.push(`words ${old.words} to ${p.data.wordCount}`);
+            const canonical = p.data.canonicals?.[0]?.href ?? null;
+            if (old.canonical && canonical && old.canonical !== canonical)
+                diffs.push(`canonical ${old.canonical} to ${canonical}`);
+            if (old.language && p.data.language && old.language !== p.data.language)
+                diffs.push(`language ${old.language} to ${p.data.language}`);
+            return diffs.length ? [{ url: p.key, changes: diffs }] : [];
+        });
+        // Infrastructure: nameservers, addresses, mail, certificate issuer, stack.
+        const previousDns = previous.dns;
+        const previousTls = previous.tls;
+        const previousHome = previous.home;
+        const list = (values) => (Array.isArray(values) ? values : [])
+            .map((v) => typeof v === "string" ? v : (v?.exchange ?? JSON.stringify(v)))
+            .sort()
+            .join(", ");
+        const infrastructure = [];
+        for (const [record, label] of [
+            ["ns", "Nameservers"],
+            ["a", "IP addresses"],
+            ["mx", "Mail servers"],
+        ]) {
+            const was = list(previousDns?.records?.[record]?.values), is = list(dns?.records?.[record]?.values);
+            if (was && is && was !== is)
+                infrastructure.push(`${label} changed from ${was} to ${is}`);
+        }
+        const issuerOf = (t) => t?.issuer?.O ??
+            t?.issuer?.CN ??
+            t?.certificate?.issuer?.O ??
+            t?.certificate?.issuer?.CN;
+        const wasIssuer = issuerOf(previousTls), isIssuer = issuerOf(tls);
+        if (wasIssuer && isIssuer && wasIssuer !== isIssuer)
+            infrastructure.push(`Certificate issuer changed from ${wasIssuer} to ${isIssuer}`);
+        const techs = (p) => (p?.technologies ?? p?.data?.technologies ?? [])
+            .map((t) => t.name)
+            .sort()
+            .join(", ");
+        const wasTech = techs(previousHome), isTech = techs(home);
+        if (wasTech && isTech && wasTech !== isTech)
+            infrastructure.push(`Detected technology changed from ${wasTech} to ${isTech}`);
+        const scoreChanges = ["performance", "accessibility", "bestPractices", "seo"].flatMap((category) => {
+            const from = before.scores?.mobile?.[category], to = mobile?.[category];
+            return typeof from === "number" &&
+                typeof to === "number" &&
+                from !== to &&
+                !carried
+                ? [{ category, from, to }]
+                : [];
+        });
+        const scoreDrops = scoreChanges.filter((c) => c.from - c.to >= 10);
+        // Lab and field numbers wobble; only material moves are trends.
+        const material = (metric, from, to) => Math.abs(to - from) >=
+            Math.max(0.2 * Math.abs(from), metric === "cls" ? 0.05 : 50);
+        const metricChanges = ["ttfb", "fcp", "lcp", "cls", "bytes"].flatMap((metric) => {
+            const from = before.metrics?.[metric], to = metrics?.[metric];
+            return typeof from === "number" &&
+                typeof to === "number" &&
+                material(metric, from, to)
+                ? [{ metric, from, to }]
+                : [];
+        });
+        const fieldChanges = ["lcp", "inp", "cls"].flatMap((metric) => {
+            const from = before.field?.[metric], to = field?.[metric];
+            return typeof from === "number" &&
+                typeof to === "number" &&
+                material(metric, from, to)
+                ? [{ metric, from, to }]
+                : [];
+        });
+        // Visual: this scan's screenshots against the latest earlier screenshot
+        // of the same page, since the sample rotates.
+        const visual = [];
+        for (const current of input.artifacts.filter((a) => a.kind === "screenshot")) {
+            const old = previous.screenshots?.find((s) => s.url === current.key);
+            if (!old)
+                continue;
+            const changed = screenshotDifference(old.body, current.body);
+            if (changed !== null && changed >= 5)
+                visual.push({
+                    url: current.key,
+                    changed,
+                    screenshotId: current.sha256,
+                    previousScreenshotId: old.id,
+                });
+        }
+        changes = {
+            previousScanId: previous.id,
+            previousCreatedAt: previous.createdAt,
+            newFindings: diff.newFindings.map((f) => ({
+                ...f,
+                items: f.items.slice(0, ITEM_LIMIT).map((i) => i.text),
+            })),
+            resolvedFindings: diff.resolvedFindings,
+            unverifiedFindings: diff.unverifiedFindings,
+            recurringFindings: diff.recurringFindings,
+            worsenedFindings: diff.worsenedFindings,
+            fixedFindings: diff.resolvedFindings,
+            pagesAdded,
+            pagesRemoved,
+            titleChanges,
+            changedPages,
+            infrastructure,
+            scoreDrops,
+            performance: {
+                scores: scoreChanges,
+                metrics: metricChanges,
+                field: fieldChanges,
+            },
+            visual,
+            indexability: before.indexability &&
+                before.indexability.indexable !== indexability.indexable
+                ? { from: before.indexability.indexable, to: indexability.indexable }
+                : null,
+        };
+    }
+    const collectorVersion = of("collector")[0]?.data?.version ?? null;
+    const report = {
+        version: 2,
+        scanId: scan.id,
+        siteUrl: scan.url,
+        status: scan.status,
+        createdAt: scan.createdAt,
+        finishedAt: scan.finishedAt ?? null,
+        overview: { characteristics, summary, priorities },
+        health: counts.critical
+            ? "critical"
+            : counts.warning || pending.length
+                ? "attention"
+                : "healthy",
+        pages: {
+            observed: pages.length,
+            ok: okPages.length,
+            broken: brokenPages.length,
+            tested: browserStatus.filter((b) => b.data.status === "completed").length,
+            lighthouse: new Set(lighthouse.map((l) => l.data.url)).size,
+        },
+        coverage,
+        indexability,
+        security,
+        weight: {
+            averageBytes: weights.length
+                ? Math.round(weights.reduce((a, w) => a + w.bytes, 0) / weights.length)
+                : null,
+            heaviest: weights.length
+                ? weights.reduce((a, w) => (w.bytes > a.bytes ? w : a))
+                : null,
+            // 0.81 kWh per GB transferred, 442 g CO2 per kWh (global grid average).
+            carbonGrams: weights.length
+                ? Math.round((weights.reduce((a, w) => a + w.bytes, 0) /
+                    weights.length /
+                    1073741824) *
+                    0.81 *
+                    442 *
+                    100) / 100
+                : null,
+        },
+        scores: { mobile, desktop, measuredAt, carried },
+        metrics,
+        field,
+        fieldPages,
+        domain,
+        topics,
+        checks,
+        methodology: {
+            versions: {
+                collector: collectorVersion,
+                lighthouse: lighthouse[0]?.data?.lighthouseVersion ?? null,
+                chrome: lighthouse[0]?.data?.chromeVersion ??
+                    details[0]?.data?.chromeVersion ??
+                    null,
+                axe: details[0]?.data?.accessibility?.engine?.version ?? null,
+            },
+            measuredAt: {
+                crawl: scan.createdAt,
+                lighthouse: lighthouse[0]?.data?.fetchTime ?? measuredAt,
+                chromeUxReport: field?.period?.to ?? null,
+                sslLabs: labs?.testedAt ?? null,
+            },
+            notes: [
+                "Findings describe observed conditions and their impact; confidence is separate from severity. Review findings are heuristics that need a human judgement.",
+                "Unavailable and not-checked outcomes mean the check could not run; they are not failures of the website.",
+                "Structured-data checks cover syntax, shapes and documented required properties, not rich-result eligibility.",
+                "Accessibility checks are automated axe-core rules; they cover part of WCAG and make no conformance claim.",
+                "Business and profile checks use the public website only; blocked platforms are unverifiable, not missing.",
+            ],
+        },
+        counts,
+        findings: findings.map((f) => ({
+            ...f,
+            items: f.items.slice(0, ITEM_LIMIT).map((i) => i.text),
+            urls: f.urls.slice(0, ITEM_LIMIT),
+        })),
+        changes,
+    };
+    return { report, findings };
+}
+export const areaLabels = {
+    availability: "Availability and security",
+    search: "Search",
+    performance: "Performance",
+    accessibility: "Accessibility",
+    quality: "Quality",
+};
+// Compact Markdown for agents and plain-text contexts: overview, priorities,
+// findings per topic, coverage and changes. No remediation advice.
+export function formatReport(report) {
+    report = publicReport(report);
+    const host = new URL(report.siteUrl).hostname;
+    const topicOf = (f) => f.topic ?? areaTopics[f.area ?? ""] ?? "links-navigation";
+    const sections = [`# ${host}`];
+    sections.push(`Scan ${report.createdAt.slice(0, 10)}, status ${report.status}, health ${report.health ?? "unknown"}. ${report.overview?.summary ??
+        `${report.pages.observed} pages crawled, ${report.pages.broken} broken, ${report.pages.tested ?? 0} tested in the browser.`}`);
+    if (report.overview) {
+        const c = report.overview.characteristics;
+        sections.push(`Detected: ${c.technologies.join(", ") || "no recognised technology"}; languages ${c.languages.join(", ") || "not declared"}; page types ${Object.entries(c.pageTypes)
+            .map(([k, v]) => `${v} ${k}`)
+            .join(", ")}${c.ecommerce ? "; e-commerce" : ""}${c.multilingual ? "; multilingual" : ""}.`);
+        const priorities = report.overview.priorities
+            .map((id) => report.findings.find((f) => f.id === id))
+            .filter((f) => !!f);
+        if (priorities.length)
+            sections.push(`## Priority problems\n\n${priorities.map((f) => `- ${f.title} (${f.severity}, ${f.confidence}, ${f.count} items on ${f.pages} pages): ${f.impact}`).join("\n")}`);
+    }
+    if (report.coverage) {
+        const cov = report.coverage;
+        sections.push(`Coverage: ${cov.crawled} of ${cov.discovered} discovered pages observed${cov.pages ? `, ${cov.pages.notReached} not reached` : ""}${cov.browser
+            ? `; browser pass on ${cov.browser.completed} of ${cov.browser.eligible} pages`
+            : ""}${cov.lighthouse ? `; Lighthouse on ${cov.lighthouse.completed} of ${cov.lighthouse.selected} selected pages${cov.lighthouse.omitted ? ` (${cov.lighthouse.omitted} of ${cov.lighthouse.eligible} eligible pages left out by the page limit)` : ""}` : ""}${cov.remainingWork?.length
+            ? `; remaining work: ${cov.remainingWork.map((w) => `${w.count} ${w.kind} ${w.status}`).join(", ")}`
+            : ""}. ${cov.complete === false ? "Coverage is incomplete; absent findings for unchecked pages are not evidence of health." : ""}`);
+        if (cov.slashVariants)
+            sections.push(`Trailing-slash pairs: ${cov.slashVariants.verified}/${cov.slashVariants.expected} verified.`);
+    }
+    if (report.indexability)
+        sections.push(`Indexability: ${report.indexability.indexable} indexable, ${report.indexability.noindex} noindex, ${report.indexability.canonicalElsewhere} canonical elsewhere, ${report.indexability.broken} broken.`);
+    const score = (s, key) => s?.[key] === null || s?.[key] === undefined ? "-" : String(s[key]);
+    sections.push(`Lighthouse averages mobile / desktop${report.scores.carried ? ` (carried from ${report.scores.measuredAt?.slice(0, 10)})` : ""}: performance ${score(report.scores.mobile, "performance")} / ${score(report.scores.desktop, "performance")}, accessibility ${score(report.scores.mobile, "accessibility")} / ${score(report.scores.desktop, "accessibility")}, best practices ${score(report.scores.mobile, "bestPractices")} / ${score(report.scores.desktop, "bestPractices")}, SEO ${score(report.scores.mobile, "seo")} / ${score(report.scores.desktop, "seo")}.`);
+    if (report.field)
+        sections.push(report.field.available
+            ? `Real-user vitals (${report.field.note}): LCP ${report.field.lcp ?? "-"} ms, INP ${report.field.inp ?? "-"} ms, CLS ${report.field.cls ?? "-"}, verdict ${report.field.verdict ?? "unknown"}.`
+            : `Real-user vitals: ${report.field.note}.`);
+    if (report.domain)
+        sections.push(`Domain ${report.domain.name} expires ${String(report.domain.expiresAt ?? "unknown").slice(0, 10)}${report.domain.daysRemaining !== null ? ` (${report.domain.daysRemaining} days)` : ""}.`);
+    const findingLine = (f) => `- ${f.title} (${f.severity}, ${f.confidence ?? "confirmed"}, ${f.count}${f.pages ? ` on ${f.pages} pages` : ""}). ${f.problem ?? ""} ${f.impact ?? ""}${f.items.length
+        ? `\n  Evidence: ${f.items.slice(0, 5).join("; ")}${f.count > 5 ? ` (and ${f.count - 5} more)` : ""}`
+        : ""}`;
+    for (const topic of topicOrder) {
+        const items = report.findings.filter((f) => topicOf(f) === topic);
+        const summary = report.topics?.[topic];
+        if (!items.length && !summary?.facts?.length)
+            continue;
+        sections.push(`## ${topicLabels[topic]}${summary ? ` (${summary.status})` : ""}\n\n${[
+            ...(summary?.facts ?? []).map((fact) => `${fact}.`),
+            ...items.map(findingLine),
+        ].join("\n")}`);
+    }
+    if (!report.findings.length)
+        sections.push("## Findings\n\nNone within the checks that ran.");
+    if (report.checks) {
+        const grouped = new Map();
+        for (const c of report.checks)
+            grouped.set(c.outcome, (grouped.get(c.outcome) ?? 0) + 1);
+        sections.push(`## Checks\n\n${[...grouped].map(([outcome, n]) => `${n} ${outcome}`).join(", ")}. Not checked or unavailable: ${report.checks
+            .filter((c) => ["unavailable", "not-checked"].includes(c.outcome))
+            .map((c) => `${c.title}${c.detail ? ` (${c.detail})` : ""}`)
+            .join("; ") || "none"}.`);
+    }
+    if (report.changes) {
+        const c = report.changes;
+        const lines = [
+            ...(c.infrastructure ?? []).map((l) => `- ${l}`),
+            ...(c.scoreDrops ?? []).map((d) => `- ${d.category} dropped from ${d.from} to ${d.to}`),
+            ...(c.performance?.metrics ?? []).map((m) => `- Own browser ${m.metric} ${m.from} to ${m.to}`),
+            ...(c.visual ?? []).map((v) => `- ${v.url} looks ${v.changed}% different`),
+            ...(c.indexability
+                ? [
+                    `- Indexable pages went from ${c.indexability.from} to ${c.indexability.to}`,
+                ]
+                : []),
+            ...c.newFindings.map((f) => `- New: ${f.title} (${f.count})`),
+            ...(c.worsenedFindings ?? []).map((f) => `- Worsened: ${f.title} (${f.from} to ${f.to})`),
+            ...(c.resolvedFindings ?? []).map((f) => `- Resolved after recheck: ${f.title} (${f.count})`),
+            ...unverifiedChanges(c).map((f) => `- No longer listed, not rechecked: ${f.title} (${f.count})`),
+            ...(c.pagesAdded.length ? [`- Pages added: ${c.pagesAdded.length}`] : []),
+            ...(c.pagesRemoved.length
+                ? [`- Pages removed: ${c.pagesRemoved.length}`]
+                : []),
+            ...((c.changedPages ?? []).length
+                ? [`- Pages changed: ${c.changedPages.length}`]
+                : []),
+        ];
+        sections.push(`## Since ${c.previousCreatedAt.slice(0, 10)}\n\n${lines.length ? lines.join("\n") : "No changes."}`);
+    }
+    return sections.join("\n\n");
+}