@rivi-software/agentic-seo-check 0.3.0 → 0.5.0

package/dist/core/site-rules.js

@@ -1,8 +1,11 @@
 import { normalizeForComparison, shingles, jaccard } from "./html/text.js";
 import { agentMatcher } from "./robots.js";
+import { escapeAttribute, removeEdit, setAttributeEdit, slot, } from "./rules/fix.js";
 import { robotsDirectives } from "./rules/indexing.js";
 import { finding, GOOGLE_DOCS, cap } from "./rules/rule.js";
+import { addLinkEdit, addToSitemapFix, blockedResourcesFix, canonicalEdit, imagesOf, blockingRule, lastmodFix, locationOf, linkSelector, linksTo, nestedIndexFix, hrefLike, onUrl, otherHostFix, redirectTo, redescribeEdit, removeNoindexEdits, returnLinkEdit, reheadEdit, relinkEdit, linesOf, retitleEdit, statusLine, removeFromSitemap, replaceInSitemap, robotsBlocksAllFix, robotsErrorFix, robotsMissingFix, robotsTooLargeFix, robotsUnsupportedFix, MAX_EDITS, sitemapErrorFix, sitemapMissingFix, splitSitemapFix, } from "./site-fixes.js";
 import { MIN_COMPARABLE_WORDS, SAME_TEXT } from "./site-probes.js";
+import { sitemapLayout } from "./sitemap.js";
 import { normalizeUrl, normalizePath, trimTrailingSlashes } from "./url.js";
 const meta = (id, severity, description, recommendation, docs) => ({
     id,
@@ -85,8 +88,24 @@ const pathKey = (url) => {
         return url;
     }
 };
-const pushDuplicates = (out, rule, pages, pick, label) => {
+/** The URL with its path lower-cased and trailing slashes dropped: one key for every spelling. */
+const spellingKey = (url) => {
+    try {
+        const u = new URL(url);
+        const pathname = trimTrailingSlashes(u.pathname.toLowerCase()) || "/";
+        return `${u.origin}${pathname}${u.search}`;
+    }
+    catch {
+        return url;
+    }
+};
+const pushDuplicates = (out, rule, pages, pick, label, fixFor) => {
     const groups = new Map();
+    // Every page but the first of a group gets a value of its own; the first keeps what it has.
+    const others = [];
+    // Pages are grouped by a lowercased key, but the evidence quotes the value as the first page
+    // wrote it, so a report or pull request shows the text a reviewer would find on the site.
+    const written = new Map();
     for (const p of pages) {
         const value = pick(p);
         if (!value) {
@@ -94,6 +113,12 @@ const pushDuplicates = (out, rule, pages, pick, label) => {
         }
         const k = normalizeForComparison(value);
         pushTo(groups, k, p.url);
+        if (written.has(k)) {
+            others.push(p);
+        }
+        else {
+            written.set(k, value);
+        }
     }
     const dupes = [...groups.entries()].filter(([, urls]) => urls.length > 1);
     if (!dupes.length) {
@@ -101,15 +126,44 @@ const pushDuplicates = (out, rule, pages, pick, label) => {
     }
     const pagesAffected = dupes.reduce((n, [, urls]) => n + urls.length, 0);
     out.push(finding(rule, `${dupes.length} ${label}(s) are shared by ${pagesAffected} pages.`, {
+        fix: others.flatMap((p) => fixFor(p) ?? []).slice(0, MAX_EDITS),
         evidence: {
-            groups: cap(dupes.map(([value, urls]) => ({
-                value: value.slice(0, 120),
+            groups: cap(dupes.map(([k, urls]) => ({
+                value: (written.get(k) ?? k).slice(0, 120),
                 pages: cap(urls, 5),
                 count: urls.length,
             }))),
         },
     }));
 };
+/**
+ * The canonical each duplicate should name. The first page of a group is the shallowest the crawl
+ * reached: the others name it as canonical. Near-duplicates come in pairs, so a page can be in two
+ * groups (a~b and b~c, or a~c and b~c): each page gets one canonical, to a page that keeps its
+ * own, so the fix makes no chain and gives no page two.
+ */
+const duplicateCanonicalEdits = (groups, byUrl) => {
+    const canonicalOf = new Map();
+    const roots = new Set();
+    const fix = [];
+    for (const { pages: [first, ...rest], } of groups) {
+        const root = first ? (canonicalOf.get(first) ?? first) : undefined;
+        for (const u of rest) {
+            const record = byUrl.get(u);
+            if (!root ||
+                !record ||
+                u === root ||
+                canonicalOf.has(u) ||
+                roots.has(u)) {
+                continue;
+            }
+            canonicalOf.set(u, root);
+            roots.add(root);
+            fix.push(canonicalEdit(record, root, `If ${u} is meant to be a page of its own, make its text distinct instead.`));
+        }
+    }
+    return fix;
+};
 const pushDuplicateContent = (out, pages) => {
     const candidates = pages.filter((p) => p.page.wordCount >= 50);
     const groups = [];
@@ -150,7 +204,9 @@ const pushDuplicateContent = (out, pages) => {
         }
     }
     if (groups.length) {
-        out.push(finding(m("site.duplicate-content"), `${groups.length} group(s) of pages have (near-)identical body text.`, { evidence: { groups: cap(groups) } }));
+        const byUrl = new Map(candidates.map((p) => [p.url, p]));
+        const fix = duplicateCanonicalEdits(groups, byUrl);
+        out.push(finding(m("site.duplicate-content"), `${groups.length} group(s) of pages have (near-)identical body text.`, { fix: fix.slice(0, MAX_EDITS), evidence: { groups: cap(groups) } }));
     }
 };
 /** Google reads the first 500 KiB of robots.txt and ignores the rest. */
@@ -158,7 +214,7 @@ const ROBOTS_MAX_BYTES = 512_000;
 const unsupportedRobotsLines = (text) => {
     const retired = [];
     const crawlDelay = [];
-    for (const [i, raw] of text.split(/\r?\n/u).slice(0, 50_000).entries()) {
+    for (const [i, raw] of linesOf(text).slice(0, 50_000).entries()) {
         const line = raw.replace(/#.*$/u, "").trim();
         const field = /^(?<field>[a-z-]+)\s*:/iu
             .exec(line)
@@ -176,10 +232,14 @@ const unsupportedRobotsLines = (text) => {
 const robotsContentFindings = (ctx) => {
     const out = [];
     const bytes = ctx.robots?.bytes ?? 0;
+    const text = ctx.robotsText ?? ctx.robots?.text;
+    const robotsUrl = ctx.robots?.url ?? new URL("/robots.txt", ctx.startUrl).href;
     if (bytes > ROBOTS_MAX_BYTES) {
-        out.push(finding(m("site.robots-txt-too-large"), `robots.txt is ${Math.round(bytes / 1024)} KiB; Google reads only the first 500 KiB.`, { evidence: { url: ctx.robots?.url, bytes } }));
+        out.push(finding(m("site.robots-txt-too-large"), `robots.txt is ${Math.round(bytes / 1024)} KiB; Google reads only the first 500 KiB.`, {
+            fix: robotsTooLargeFix(robotsUrl, text ?? "", bytes),
+            evidence: { url: ctx.robots?.url, bytes },
+        }));
     }
-    const text = ctx.robotsText ?? ctx.robots?.text;
     if (!text) {
         return out;
     }
@@ -189,6 +249,7 @@ const robotsContentFindings = (ctx) => {
             ? `robots.txt has ${retired.length} noindex or nofollow line(s), which Google stopped reading in 2019.`
             : `robots.txt sets crawl-delay, which Google ignores.`, {
             severity: retired.length > 0 ? "warning" : "info",
+            fix: robotsUnsupportedFix(robotsUrl, text),
             evidence: {
                 url: ctx.robots?.url,
                 retired: cap(retired),
@@ -246,28 +307,44 @@ const blockedResourceFindings = ({ ctx, okPages, isIndexable, }) => {
         .toSorted((a, b) => b.pages - a.pages);
     return list.length > 0
         ? [
-            finding(m("site.robots-blocks-resources"), `robots.txt keeps Googlebot from ${list.length} script(s) or stylesheet(s) the pages load.`, { evidence: { count: list.length, examples: cap(list) } }),
+            finding(m("site.robots-blocks-resources"), `robots.txt keeps Googlebot from ${list.length} script(s) or stylesheet(s) the pages load.`, {
+                fix: blockedResourcesFix(robots.url, text, list.map((r) => r.url)),
+                evidence: { count: list.length, examples: cap(list) },
+            }),
         ]
         : [];
 };
 /** Sitemaps over the protocol's limits, nested indexes, bad lastmod values and other hosts. */
+/** Parts of at most 45,000 URLs or 45 MB, and at least two. */
+const partsFor = (urls, bytes, perPart) => Math.max(2, Math.ceil((urls ?? 0) / 45_000), Math.ceil((bytes ?? 0) / perPart));
 const sitemapProtocolFindings = (ctx) => {
     const { problems } = ctx.sitemaps;
+    const layout = sitemapLayout(problems);
+    const today = new Date().toISOString().slice(0, 10);
     const out = [];
     const over = problems.oversized.filter((o) => o.overLimit);
     const unread = problems.oversized.filter((o) => !o.overLimit);
     if (over.length > 0) {
-        out.push(finding(m("site.sitemap-too-large"), `${over.length} sitemap(s) exceed 50,000 URLs or 50 MB.`, { evidence: { sitemaps: cap(over) } }));
+        out.push(finding(m("site.sitemap-too-large"), `${over.length} sitemap(s) exceed 50,000 URLs or 50 MB.`, {
+            fix: over.map((o) => splitSitemapFix(o.sitemap, partsFor(o.urls, o.bytes, 45_000_000), "Serve this sitemap index where the large sitemap was, and move its URLs into the files it lists, each under 50,000 URLs and 50 MB.")),
+            key: "over-limit",
+            evidence: { sitemaps: cap(over) },
+        }));
     }
     if (unread.length > 0) {
         out.push(finding(m("site.sitemap-too-large"), `${unread.length} sitemap(s) are larger than the 15 MB this audit reads, so their URLs were not checked.`, {
             severity: "info",
             recommendation: "Check that each stays under 50 MB and 50,000 URLs; smaller sitemaps (10,000 URLs or fewer) are also quicker for search engines to fetch again.",
+            fix: unread.map((o) => splitSitemapFix(o.sitemap, partsFor(o.urls, o.bytes, 10_000_000), "Serve this sitemap index where the large sitemap was, and move its URLs into the files it lists, 10,000 URLs or fewer each, so search engines (and this audit) can read each one quickly.")),
+            key: "unread",
             evidence: { sitemaps: cap(unread) },
         }));
     }
     if (problems.nestedIndexes.length > 0) {
-        out.push(finding(m("site.sitemap-index-nested"), `${problems.nestedIndexes.length} sitemap index(es) are listed by another sitemap index.`, { evidence: { indexes: cap(problems.nestedIndexes) } }));
+        out.push(finding(m("site.sitemap-index-nested"), `${problems.nestedIndexes.length} sitemap index(es) are listed by another sitemap index.`, {
+            fix: problems.nestedIndexes.map((n) => nestedIndexFix(layout, n)),
+            evidence: { indexes: cap(problems.nestedIndexes) },
+        }));
     }
     const examples = [
         [
@@ -286,22 +363,69 @@ const sitemapProtocolFindings = (ctx) => {
             "are on another host than the site",
         ],
     ];
+    const fixes = {
+        "site.sitemap-lastmod-invalid": (list) => lastmodFix(layout, list, "invalid", today),
+        "site.sitemap-lastmod-future": (list) => lastmodFix(layout, list, "future", today),
+        "site.sitemap-other-host": (list) => otherHostFix(layout, list, new URL(ctx.startUrl).origin),
+    };
     for (const [id, list, label] of examples) {
         if (list.count > 0) {
             out.push(finding(m(id), `${list.count} sitemap URL(s) ${label}.`, {
+                fix: fixes[id](list.examples),
                 evidence: { count: list.count, examples: list.examples },
             }));
         }
     }
     return out;
 };
-const robotsFindings = (ctx) => {
+/** The sitemap URL a robots.txt should name: the one found, else /sitemap.xml. */
+const sitemapUrlOf = (ctx) => ctx.sitemaps.sources[0] ?? new URL("/sitemap.xml", ctx.startUrl).href;
+/**
+ * Keeps blocked pages out of the sitemap and stops crawlers following links to them; unblocking
+ * them could expose pages kept private on purpose, so the write names that rule instead.
+ */
+const blockedPageEdits = (scope, blocked) => {
+    const { ctx, key, pagesByKey } = scope;
+    const k = key(blocked);
+    const rule = ctx.robots && ctx.robotsText
+        ? blockingRule(ctx.robots.url, ctx.robotsText, blocked)
+        : null;
+    const unblock = `If the page belongs in search results, remove ${rule ? `"${rule}"` : "the rule that blocks it"} from robots.txt instead.`;
+    const listed = ctx.sitemaps.urls.find((u) => key(u) === k);
+    if (listed) {
+        return [
+            removeFromSitemap(sitemapLayout(ctx.sitemaps.problems), listed, `robots.txt blocks it, so search engines cannot crawl it. ${unblock}`),
+        ];
+    }
+    const sources = [...ctx.linkSources].flatMap(([target, from]) => key(target) === k ? [...from] : []);
+    const edits = sources.flatMap((source) => {
+        const record = pagesByKey.get(key(source));
+        return record
+            ? linksTo(record, k, key).map((link) => onUrl(setAttributeEdit(link.tag, linkSelector(link), "rel", link.rel ? `${link.rel} nofollow` : "nofollow", `So crawlers do not follow it to a page robots.txt blocks. ${unblock}`), locationOf(record)))
+            : [];
+    });
+    if (edits.length > 0 || !rule || !ctx.robots) {
+        return edits;
+    }
+    return [
+        {
+            in: "robots.txt",
+            action: "remove",
+            url: ctx.robots.url,
+            current: rule,
+            write: `Only if ${blocked} belongs in search results; if it is kept out on purpose, leave robots.txt as it is.`,
+        },
+    ];
+};
+const robotsFindings = (scope) => {
+    const { ctx } = scope;
     const out = [];
     /* robots.txt */
     if (ctx.robots) {
         if (ctx.robots.error ||
             (ctx.robots.status !== null && ctx.robots.status >= 500)) {
             out.push(finding(m("site.robots-txt-error"), `robots.txt at ${ctx.robots.url} could not be read (${ctx.robots.error ?? `HTTP ${ctx.robots.status}`}).`, {
+                fix: robotsErrorFix(ctx.robots.url, ctx.robots.status, ctx.robots.error),
                 evidence: {
                     url: ctx.robots.url,
                     status: ctx.robots.status,
@@ -312,11 +436,13 @@ const robotsFindings = (ctx) => {
         else if (!ctx.robots.found) {
             out.push(finding(m("site.robots-txt-missing"), `No robots.txt at ${ctx.robots.url}.`, {
                 severity: ctx.source === "directory" ? "info" : "warning",
+                fix: robotsMissingFix(ctx.robots.url, sitemapUrlOf(ctx)),
                 evidence: { url: ctx.robots.url, status: ctx.robots.status },
             }));
         }
         else if (ctx.robotsAllows && !ctx.robotsAllows(ctx.startUrl)) {
             out.push(finding(m("site.robots-txt-blocks-all"), "robots.txt blocks the start URL for the crawler user agent.", {
+                fix: robotsBlocksAllFix(ctx.robots.url, ctx.robotsText ?? ctx.robots.text ?? "", ctx.startUrl),
                 evidence: {
                     url: ctx.robots.url,
                     robotsTxt: ctx.robots.text?.slice(0, 500),
@@ -326,6 +452,10 @@ const robotsFindings = (ctx) => {
     }
     if (ctx.blockedByRobots.length) {
         out.push(finding(m("site.robots-blocked-pages"), `${ctx.blockedByRobots.length} linked/sitemap URL(s) are disallowed by robots.txt.`, {
+            fix: ctx.blockedByRobots
+                .slice(0, MAX_EDITS)
+                .flatMap((u) => blockedPageEdits(scope, u))
+                .slice(0, MAX_EDITS),
             evidence: {
                 count: ctx.blockedByRobots.length,
                 examples: cap(ctx.blockedByRobots),
@@ -337,6 +467,12 @@ const robotsFindings = (ctx) => {
 /** Noindex, non-canonical, broken and redirecting URLs listed in the sitemap. */
 const sitemapUrlFindings = ({ ctx, key, pagesByKey, checksByKey, }) => {
     const out = [];
+    const layout = sitemapLayout(ctx.sitemaps.problems);
+    const listed = new Set(ctx.sitemaps.urls.map(key));
+    /** Points an entry at `to`, or removes it when the sitemap lists `to` already. */
+    const repoint = (loc, to) => listed.has(key(to))
+        ? removeFromSitemap(layout, loc, `the sitemap lists ${to} already.`)
+        : replaceInSitemap(layout, loc, to);
     const noindex = [];
     const nonCanonical = [];
     const broken = [];
@@ -364,10 +500,14 @@ const sitemapUrlFindings = ({ ctx, key, pagesByKey, checksByKey, }) => {
         }
     }
     if (noindex.length) {
-        out.push(finding(m("site.sitemap-noindex-page"), `${noindex.length} sitemap URL(s) are noindex.`, { evidence: { count: noindex.length, examples: cap(noindex) } }));
+        out.push(finding(m("site.sitemap-noindex-page"), `${noindex.length} sitemap URL(s) are noindex.`, {
+            fix: noindex.map((u) => removeFromSitemap(layout, u, "the page is noindex, which may be on purpose. If it belongs in search results, remove its noindex instead.")),
+            evidence: { count: noindex.length, examples: cap(noindex) },
+        }));
     }
     if (nonCanonical.length) {
         out.push(finding(m("site.sitemap-non-canonical"), `${nonCanonical.length} sitemap URL(s) canonicalise to another URL.`, {
+            fix: nonCanonical.map((n) => repoint(n.url, n.canonical)),
             evidence: {
                 count: nonCanonical.length,
                 examples: cap(nonCanonical),
@@ -375,18 +515,36 @@ const sitemapUrlFindings = ({ ctx, key, pagesByKey, checksByKey, }) => {
         }));
     }
     if (broken.length) {
-        out.push(finding(m("site.sitemap-broken-url"), `${broken.length} sitemap URL(s) return errors.`, { evidence: { count: broken.length, examples: cap(broken) } }));
+        out.push(finding(m("site.sitemap-broken-url"), `${broken.length} sitemap URL(s) return errors.`, {
+            fix: broken.map((b) => removeFromSitemap(layout, b.url, `it answers ${b.status === null ? "with no response" : `HTTP ${b.status}`}. If the page should exist, restore it instead.`)),
+            evidence: { count: broken.length, examples: cap(broken) },
+        }));
     }
     if (redirecting.length) {
         out.push(finding(m("site.sitemap-redirecting-url"), `${redirecting.length} sitemap URL(s) redirect.`, {
+            fix: redirecting.map((r) => repoint(r.url, r.finalUrl)),
             evidence: { count: redirecting.length, examples: cap(redirecting) },
         }));
     }
     return out;
 };
 /** Indexable pages missing from the sitemap, and sitemap URLs nothing links to. */
-const sitemapCoverageFindings = ({ ctx, key, okPages, isIndexable, }) => {
+/**
+ * Links an orphan from the home page, or takes it out of the sitemap when it does not load: a link
+ * to a broken page would only add a broken link.
+ */
+const orphanEdit = (scope, home, url) => {
+    const check = scope.checksByKey.get(scope.key(url));
+    if (check && (check.error || (check.status ?? 0) >= 400)) {
+        return removeFromSitemap(sitemapLayout(scope.ctx.sitemaps.problems), url, `it answers ${check.status === null ? "with no response" : `HTTP ${check.status}`}, and no page links to it.`);
+    }
+    return addLinkEdit(home, url, `Words that say what ${url} is about. Put the link on the page closest in topic, or in the navigation; if the page is obsolete, remove it from the sitemap instead.`);
+};
+const sitemapCoverageFindings = (scope) => {
+    const { ctx, key, pagesByKey, okPages, isIndexable } = scope;
     const out = [];
+    const start = pagesByKey.get(key(ctx.startUrl));
+    const home = start ? locationOf(start) : ctx.startUrl;
     const sitemapKeys = new Set(ctx.sitemaps.urls.map(key));
     const notInSitemap = okPages
         .filter((p) => isIndexable(p) &&
@@ -395,6 +553,7 @@ const sitemapCoverageFindings = ({ ctx, key, okPages, isIndexable, }) => {
         .map((p) => p.url);
     if (notInSitemap.length) {
         out.push(finding(m("site.not-in-sitemap"), `${notInSitemap.length} crawled indexable page(s) are missing from the sitemap.`, {
+            fix: addToSitemapFix(sitemapLayout(ctx.sitemaps.problems), notInSitemap),
             evidence: {
                 count: notInSitemap.length,
                 examples: cap(notInSitemap),
@@ -409,7 +568,12 @@ const sitemapCoverageFindings = ({ ctx, key, okPages, isIndexable, }) => {
         linked.add(key(ctx.startUrl));
         const orphans = ctx.sitemaps.urls.filter((u) => !linked.has(key(u)));
         if (orphans.length) {
-            out.push(finding(m("site.orphan-pages"), `${orphans.length} sitemap URL(s) are not linked from any crawled page.`, { evidence: { count: orphans.length, examples: cap(orphans) } }));
+            out.push(finding(m("site.orphan-pages"), `${orphans.length} sitemap URL(s) are not linked from any crawled page.`, {
+                fix: orphans
+                    .slice(0, MAX_EDITS)
+                    .map((u) => orphanEdit(scope, home, u)),
+                evidence: { count: orphans.length, examples: cap(orphans) },
+            }));
         }
     }
     return out;
@@ -418,7 +582,10 @@ const sitemapFindings = (scope) => {
     const { ctx } = scope;
     const out = [];
     if (ctx.sitemaps.errors.length) {
-        out.push(finding(m("site.sitemap-error"), `${ctx.sitemaps.errors.length} sitemap problem(s).`, { evidence: { errors: cap(ctx.sitemaps.errors) } }));
+        out.push(finding(m("site.sitemap-error"), `${ctx.sitemaps.errors.length} sitemap problem(s).`, {
+            fix: sitemapErrorFix(ctx.sitemaps.errors.slice(0, 10), new URL(ctx.startUrl).origin),
+            evidence: { errors: cap(ctx.sitemaps.errors) },
+        }));
     }
     // A sitemap too large to read was still found.
     if (ctx.sitemaps.sources.length === 0 &&
@@ -426,6 +593,11 @@ const sitemapFindings = (scope) => {
         ctx.sitemaps.problems.oversized.length === 0) {
         out.push(finding(m("site.sitemap-missing"), "No sitemap was found.", {
             severity: ctx.source === "directory" ? "info" : "warning",
+            fix: sitemapMissingFix(sitemapUrlOf(ctx), scope.okPages
+                .filter((p) => scope.isIndexable(p) &&
+                (!p.page.canonical ||
+                    scope.key(p.page.canonical) === scope.key(p.url)))
+                .map((p) => p.url), ctx.robots?.found ? ctx.robots.url : null),
         }));
     }
     if (ctx.sitemaps.urlCount > 0) {
@@ -433,9 +605,54 @@ const sitemapFindings = (scope) => {
     }
     return out;
 };
+/**
+ * Points every link to `targetKey` on the pages in `sources` at `hrefFor(link, page)`, up to
+ * `MAX_EDITS` edits.
+ */
+const relinkSources = (scope, sources, targetKey, hrefFor, write) => {
+    const edits = [];
+    for (const source of sources) {
+        const record = scope.pagesByKey.get(scope.key(source));
+        for (const link of record ? scope.linksTo(record, targetKey) : []) {
+            if (record && edits.length < MAX_EDITS) {
+                edits.push(relinkEdit(locationOf(record), link, hrefFor(link.href, record.url), write));
+            }
+        }
+    }
+    return edits;
+};
+/** A live page whose URL differs from `url` only in a trailing slash or letter case. */
+const liveSpelling = (scope, url) => {
+    const match = scope.okPages.find((p) => spellingKey(p.url) === spellingKey(url) &&
+        scope.key(p.url) !== scope.key(url));
+    return match?.url ?? null;
+};
+/** Edits for broken internal links: the live spelling of the URL when there is one, else a slot. */
+const brokenLinkEdits = (scope, broken) => broken
+    .flatMap((b) => {
+    const live = liveSpelling(scope, b.url);
+    return relinkSources(scope, scope.ctx.linkSources.get(b.key) ?? [], scope.key(b.url), (href, pageUrl) => live
+        ? hrefLike(href, live, pageUrl)
+        : slot("URL of the live page this link meant"), live
+        ? undefined
+        : `The URL of the page the link was meant for; remove the link if that page is gone. ${b.url} does not answer.`);
+})
+    .slice(0, MAX_EDITS);
+/** Points each hop of a redirect chain straight at where the chain ends. */
+const chainEdits = (check) => check.redirectChain.slice(0, -1).map((hop, i) => ({
+    in: "http",
+    action: "replace",
+    url: hop.url,
+    current: `${statusLine(hop.status)}\nLocation: ${check.redirectChain[i + 1]?.url ?? check.finalUrl}`,
+    code: redirectTo(check.finalUrl, hop.status === 307 || hop.status === 308),
+}));
 /** Internal link targets that are broken, redirect once, or redirect in a chain. */
-const linkHealthFindings = (ctx) => {
+const linkHealthFindings = (scope) => {
+    const { ctx } = scope;
     const out = [];
+    const brokenKeys = [];
+    const redirectedKeys = [];
+    const chainChecks = [];
     /* link health */
     const broken = [];
     const redirected = [];
@@ -448,6 +665,7 @@ const linkHealthFindings = (ctx) => {
         // Chains of two or more hops are handled first, so a first hop here is the only one.
         const [firstHop] = check.redirectChain;
         if (check.error || (check.status ?? 0) >= 400) {
+            brokenKeys.push({ url: check.url, key: k });
             broken.push({
                 url: check.url,
                 status: check.status,
@@ -456,6 +674,7 @@ const linkHealthFindings = (ctx) => {
             });
         }
         else if (check.redirectChain.length >= 2) {
+            chainChecks.push(check);
             chains.push({
                 url: check.url,
                 hops: check.redirectChain.length,
@@ -463,6 +682,7 @@ const linkHealthFindings = (ctx) => {
             });
         }
         else if (firstHop) {
+            redirectedKeys.push({ key: k, finalUrl: check.finalUrl });
             redirected.push({
                 url: check.url,
                 finalUrl: check.finalUrl,
@@ -472,21 +692,32 @@ const linkHealthFindings = (ctx) => {
         }
     }
     if (broken.length) {
-        out.push(finding(m("site.broken-internal-links"), `${broken.length} internal link target(s) are broken.`, { evidence: { count: broken.length, examples: cap(broken, 20) } }));
+        out.push(finding(m("site.broken-internal-links"), `${broken.length} internal link target(s) are broken.`, {
+            fix: brokenLinkEdits(scope, brokenKeys),
+            evidence: { count: broken.length, examples: cap(broken, 20) },
+        }));
     }
     if (redirected.length) {
         out.push(finding(m("site.redirected-internal-links"), `${redirected.length} internal link target(s) redirect.`, {
+            fix: redirectedKeys
+                .flatMap((r) => relinkSources(scope, ctx.linkSources.get(r.key) ?? [], scope.key(r.key), (href, pageUrl) => hrefLike(href, r.finalUrl, pageUrl)))
+                .slice(0, MAX_EDITS),
             evidence: { count: redirected.length, examples: cap(redirected, 20) },
         }));
     }
     if (chains.length) {
-        out.push(finding(m("site.redirect-chains"), `${chains.length} internal URL(s) have redirect chains.`, { evidence: { count: chains.length, examples: cap(chains) } }));
+        out.push(finding(m("site.redirect-chains"), `${chains.length} internal URL(s) have redirect chains.`, {
+            fix: chainChecks.flatMap(chainEdits).slice(0, MAX_EDITS),
+            evidence: { count: chains.length, examples: cap(chains) },
+        }));
     }
     return out;
 };
 /** Broken external links (when they were probed) and HTML files nothing links to. */
-const unreachedFindings = (ctx) => {
+const unreachedFindings = (scope) => {
+    const { ctx } = scope;
     const out = [];
+    const start = scope.pagesByKey.get(scope.key(ctx.startUrl));
     if (ctx.externalChecks) {
         const dead = [];
         for (const [u, check] of ctx.externalChecks) {
@@ -500,11 +731,19 @@ const unreachedFindings = (ctx) => {
             }
         }
         if (dead.length) {
-            out.push(finding(m("site.broken-external-links"), `${dead.length} external link target(s) are broken.`, { evidence: { count: dead.length, examples: cap(dead, 20) } }));
+            out.push(finding(m("site.broken-external-links"), `${dead.length} external link target(s) are broken.`, {
+                fix: dead
+                    .flatMap((d) => relinkSources(scope, ctx.externalSources?.get(d.url) ?? [], scope.key(d.url), () => slot("current URL of the linked page"), `Where ${d.url} lives now: search for the page, or link a web archive copy; remove the link if the page is gone.`))
+                    .slice(0, MAX_EDITS),
+                evidence: { count: dead.length, examples: cap(dead, 20) },
+            }));
         }
     }
     if (ctx.unlinkedPages?.length) {
         out.push(finding(m("site.unlinked-pages"), `${ctx.unlinkedPages.length} HTML file(s) are not linked from any other page.`, {
+            fix: ctx.unlinkedPages
+                .slice(0, MAX_EDITS)
+                .map((file) => addLinkEdit(start ? locationOf(start) : ctx.startUrl, ctx.pages.find((p) => (p.file ?? p.url) === file)?.url ?? file, `Words that say what ${file} is about. Link it from the page closest in topic or the navigation; if the file is obsolete, delete it from the build instead.`)),
             evidence: {
                 count: ctx.unlinkedPages.length,
                 examples: cap(ctx.unlinkedPages),
@@ -518,19 +757,36 @@ const duplicateFindings = ({ key, okPages, isIndexable, }) => {
     // Pages that name another URL as canonical are consolidated already; only the canonical ones compete.
     const indexable = okPages.filter((p) => isIndexable(p) &&
         (!p.page.canonical || key(p.page.canonical) === key(p.url)));
-    pushDuplicates(out, m("site.duplicate-titles"), indexable, (p) => p.page.title, "title");
-    pushDuplicates(out, m("site.duplicate-descriptions"), indexable, (p) => p.page.metaDescription, "meta description");
-    pushDuplicates(out, m("site.duplicate-h1"), indexable, (p) => p.page.h1s[0] ?? null, "H1");
+    pushDuplicates(out, m("site.duplicate-titles"), indexable, (p) => p.page.title, "title", retitleEdit);
+    pushDuplicates(out, m("site.duplicate-descriptions"), indexable, (p) => p.page.metaDescription, "meta description", redescribeEdit);
+    pushDuplicates(out, m("site.duplicate-h1"), indexable, (p) => p.page.h1s[0] ?? null, "H1", reheadEdit);
     pushDuplicateContent(out, indexable);
     return out;
 };
 /** Pages deep in the site, and how the server answers a made-up URL and the other host names. */
-const architectureFindings = ({ ctx, okPages }) => {
+/** The same URL on `origin`, for a redirect to the site's main host or to https. */
+const onOrigin = (url, origin) => {
+    try {
+        const u = new URL(url);
+        // Appended, not resolved: a "//x" path resolved against the origin would name a host.
+        return new URL(`${origin}${u.pathname}${u.search}`).href;
+    }
+    catch {
+        return origin;
+    }
+};
+const architectureFindings = ({ ctx, key, pagesByKey, okPages, }) => {
     const out = [];
+    const start = pagesByKey.get(key(ctx.startUrl));
+    const home = start ? locationOf(start) : ctx.startUrl;
+    const { origin } = new URL(ctx.startUrl);
     /* architecture */
     const deep = okPages.filter((p) => p.depth > ctx.thresholds.deepPageDepth);
     if (deep.length) {
         out.push(finding(m("site.deep-pages"), `${deep.length} page(s) are more than ${ctx.thresholds.deepPageDepth} clicks from the start URL.`, {
+            fix: deep
+                .slice(0, MAX_EDITS)
+                .map((p) => addLinkEdit(home, p.url, `Words that say what ${p.url} is about. Or link it from a category or hub page one or two clicks from the home page.`)),
             evidence: {
                 count: deep.length,
                 examples: cap(deep.map((p) => ({ url: p.url, depth: p.depth }))),
@@ -541,17 +797,53 @@ const architectureFindings = ({ ctx, okPages }) => {
     if (ctx.probes.soft404 &&
         ctx.probes.soft404.status !== null &&
         ctx.probes.soft404.status < 400) {
-        out.push(finding(m("site.soft-404"), `${ctx.probes.soft404.url} returned HTTP ${ctx.probes.soft404.status}.`, { evidence: ctx.probes.soft404 }));
+        out.push(finding(m("site.soft-404"), `${ctx.probes.soft404.url} returned HTTP ${ctx.probes.soft404.status}.`, {
+            fix: [
+                {
+                    in: "http",
+                    action: "replace",
+                    url: ctx.probes.soft404.url,
+                    current: statusLine(ctx.probes.soft404.status),
+                    code: statusLine(404),
+                    write: "For every URL no route matches: the catch-all route or the single-page app's fallback should answer 404 (it may keep showing its not-found page).",
+                },
+            ],
+            evidence: ctx.probes.soft404,
+        }));
     }
     if (ctx.probes.httpRedirect &&
         ctx.probes.httpRedirect.status !== null &&
         !ctx.probes.httpRedirect.redirectsToHttps) {
-        out.push(finding(m("site.http-not-redirected"), `${ctx.probes.httpRedirect.url} returned HTTP ${ctx.probes.httpRedirect.status} without redirecting to https.`, { evidence: ctx.probes.httpRedirect }));
+        out.push(finding(m("site.http-not-redirected"), `${ctx.probes.httpRedirect.url} returned HTTP ${ctx.probes.httpRedirect.status} without redirecting to https.`, {
+            fix: [
+                {
+                    in: "http",
+                    action: "replace",
+                    url: ctx.probes.httpRedirect.url,
+                    current: statusLine(ctx.probes.httpRedirect.status),
+                    code: redirectTo(ctx.probes.httpRedirect.url.replace(/^http:/iu, "https:")),
+                    write: "For every http:// URL, to the same path on https://, at the server or CDN.",
+                },
+            ],
+            evidence: ctx.probes.httpRedirect,
+        }));
     }
     if (ctx.probes.hostVariant &&
         ctx.probes.hostVariant.status !== null &&
         !ctx.probes.hostVariant.redirectsToMain) {
-        out.push(finding(m("site.host-variant-not-redirected"), `${ctx.probes.hostVariant.url} returned HTTP ${ctx.probes.hostVariant.status} without redirecting to the main host.`, { evidence: ctx.probes.hostVariant }));
+        out.push(finding(m("site.host-variant-not-redirected"), `${ctx.probes.hostVariant.url} returned HTTP ${ctx.probes.hostVariant.status} without redirecting to the main host.`, {
+            fix: [
+                {
+                    in: "http",
+                    action: "replace",
+                    url: ctx.probes.hostVariant.url,
+                    current: statusLine(ctx.probes.hostVariant.status),
+                    code: redirectTo(onOrigin(ctx.probes.hostVariant.url, origin)),
+                    write: `For every URL on this host, to the same path on ${origin}, at the DNS host, server or CDN.`,
+                },
+            ],
+            evidence: ctx.probes.hostVariant,
+        }));
     }
     return out;
 };
@@ -559,23 +851,34 @@ const hreflangFindings = ({ ctx, key, pagesByKey }) => {
     const out = [];
     /* hreflang return links */
     const missingReturn = [];
+    const returnLinks = [];
     for (const p of ctx.pages) {
+        // A page whose canonical names another URL (a parameter or tracking variant) is folded into
+        // that URL, so its hreflang links do not count and nothing should link back to it.
+        if (p.page.canonical && key(p.page.canonical) !== key(p.url)) {
+            continue;
+        }
+        // en and x-default often name the same page: one missing return link, not two.
+        const seen = new Set();
         for (const alt of p.page.hreflang) {
             if (!alt.url) {
                 continue;
             }
             const target = pagesByKey.get(key(alt.url));
-            if (!target || target === p) {
+            if (!target || target === p || seen.has(target)) {
                 continue;
             }
+            seen.add(target);
             const linksBack = target.page.hreflang.some((h) => h.url && key(h.url) === key(p.url));
             if (!linksBack) {
                 missingReturn.push({ page: p.url, alternate: alt.url });
+                returnLinks.push(returnLinkEdit(target, p, key));
             }
         }
     }
     if (missingReturn.length) {
         out.push(finding(m("site.hreflang-no-return-link"), `${missingReturn.length} hreflang alternate(s) do not link back.`, {
+            fix: returnLinks.slice(0, MAX_EDITS),
             evidence: {
                 count: missingReturn.length,
                 examples: cap(missingReturn),
@@ -584,6 +887,8 @@ const hreflangFindings = ({ ctx, key, pagesByKey }) => {
     }
     if (ctx.crawl.hitPageLimit) {
         out.push(finding(m("site.crawl-limit-reached"), `Crawl stopped after ${ctx.crawl.pagesCrawled} pages (limit ${ctx.crawl.maxPages}); ${ctx.crawl.pagesDiscovered} URLs were discovered.`, {
+            // About the audit, not the site: the change is a larger --max-pages, not an edit.
+            fix: [],
             evidence: {
                 pagesCrawled: ctx.crawl.pagesCrawled,
                 pagesDiscovered: ctx.crawl.pagesDiscovered,
@@ -593,8 +898,39 @@ const hreflangFindings = ({ ctx, key, pagesByKey }) => {
     }
     return out;
 };
+/** The canonical a page should name instead of a broken, redirecting, noindex or chained one. */
+const canonicalRepair = (scope, p, problem) => {
+    if (problem.kind === "redirects" || problem.kind === "canonical") {
+        return canonicalEdit(p, problem.to ?? p.url);
+    }
+    if (problem.kind === "noindex") {
+        return canonicalEdit(p, p.url, "The page's own URL. If the noindex page is the one meant to rank, remove its noindex and keep this canonical instead.");
+    }
+    const live = p.page.canonical ? liveSpelling(scope, p.page.canonical) : null;
+    return canonicalEdit(p, live ?? p.url, live
+        ? undefined
+        : "The page's own URL. If another page is the preferred one, use its live URL.");
+};
 /** What is wrong with a URL that metadata (a canonical, an hreflang link) points to, or null. */
-const targetProblem = ({ key, pagesByKey, checksByKey, isIndexable }, url) => {
+/**
+ * Where a chain of canonicals ends: the first page that names itself (or nothing), or the last URL
+ * before the chain loops or leaves the crawled pages.
+ */
+const finalCanonical = ({ key, pagesByKey }, url) => {
+    let current = url;
+    const seen = new Set([key(url)]);
+    for (let hops = 0; hops < 10; hops += 1) {
+        const next = pagesByKey.get(key(current))?.page.canonical;
+        if (!next || seen.has(key(next))) {
+            return current;
+        }
+        seen.add(key(next));
+        current = next;
+    }
+    return current;
+};
+const targetProblem = (scope, url) => {
+    const { key, pagesByKey, checksByKey, isIndexable } = scope;
     const check = checksByKey.get(key(url));
     if (check && (check.error || (check.status ?? 0) >= 400)) {
         return {
@@ -603,7 +939,11 @@ const targetProblem = ({ key, pagesByKey, checksByKey, isIndexable }, url) => {
         };
     }
     if (check && check.redirectChain.length > 0) {
-        return { kind: "redirects", detail: `redirects to ${check.finalUrl}` };
+        return {
+            kind: "redirects",
+            detail: `redirects to ${check.finalUrl}`,
+            to: check.finalUrl,
+        };
     }
     const target = pagesByKey.get(key(url));
     if (!target) {
@@ -614,7 +954,11 @@ const targetProblem = ({ key, pagesByKey, checksByKey, isIndexable }, url) => {
     }
     const { canonical } = target.page;
     return canonical && key(canonical) !== key(target.url)
-        ? { kind: "canonical", detail: `names ${canonical} as canonical` }
+        ? {
+            kind: "canonical",
+            detail: `names ${canonical} as canonical`,
+            to: finalCanonical(scope, canonical),
+        }
         : null;
 };
 /** Canonicals that point at broken, redirecting, noindex or re-canonicalized URLs. */
@@ -626,6 +970,12 @@ const canonicalGraphFindings = (scope) => {
         noindex: [],
         canonical: [],
     };
+    const repairs = {
+        broken: [],
+        redirects: [],
+        noindex: [],
+        canonical: [],
+    };
     for (const p of okPages) {
         const { canonical } = p.page;
         // A noindex page's canonical carries no weight; the noindex wins.
@@ -639,6 +989,7 @@ const canonicalGraphFindings = (scope) => {
                 canonical,
                 problem: problem.detail,
             });
+            repairs[problem.kind].push(canonicalRepair(scope, p, problem));
         }
     }
     const rules = [
@@ -668,6 +1019,7 @@ const canonicalGraphFindings = (scope) => {
         return list.length > 0
             ? [
                 finding(m(id), `${list.length} page(s) ${label}.`, {
+                    fix: repairs[kind].slice(0, MAX_EDITS),
                     evidence: { count: list.length, examples: cap(list) },
                 }),
             ]
@@ -685,7 +1037,7 @@ const isUtilityPage = (url) => {
     }
 };
 /** Noindex pages that other pages of the site link to, most linked first. */
-const noindexLinkFindings = ({ ctx, key, okPages, isIndexable, }) => {
+const noindexLinkFindings = ({ ctx, key, pagesByKey, okPages, isIndexable, }) => {
     const linkedFrom = new Map();
     for (const [target, sources] of ctx.linkSources) {
         const k = key(target);
@@ -707,15 +1059,42 @@ const noindexLinkFindings = ({ ctx, key, okPages, isIndexable, }) => {
         .toSorted((a, b) => b.linkedFrom - a.linkedFrom);
     return linked.length > 0
         ? [
-            finding(m("site.links-to-noindex"), `${linked.length} noindex page(s) are linked from other pages; the most linked: ${linked[0]?.url} (${linked[0]?.linkedFrom} pages).`, { evidence: { count: linked.length, pages: cap(linked) } }),
+            finding(m("site.links-to-noindex"), `${linked.length} noindex page(s) are linked from other pages; the most linked: ${linked[0]?.url} (${linked[0]?.linkedFrom} pages).`, {
+                fix: linked
+                    .flatMap((l) => {
+                    const record = pagesByKey.get(key(l.url));
+                    return record
+                        ? removeNoindexEdits(record, `Only if ${l.url} belongs in search results; leave the noindex on a page kept out on purpose.`)
+                        : [];
+                })
+                    .slice(0, MAX_EDITS),
+                evidence: { count: linked.length, pages: cap(linked) },
+            }),
         ]
         : [];
 };
+/**
+ * Points an hreflang link at the canonical, live URL its alternate leads to, or removes it when the
+ * alternate is broken or noindex: an annotation to such a page is ignored anyway.
+ */
+const hreflangRepair = (p, alt, problem) => {
+    const at = `link[rel="alternate"][hreflang="${alt.lang}"]`;
+    if ((problem.kind === "redirects" || problem.kind === "canonical") &&
+        problem.to) {
+        return onUrl(setAttributeEdit(alt.tag, at, "href", escapeAttribute(problem.to)), locationOf(p));
+    }
+    return removeEdit("html", alt.tag, {
+        url: locationOf(p),
+        at,
+        write: `${alt.url} ${problem.detail}. If that language version should exist, list its live, indexable URL here instead.`,
+    });
+};
 /** hreflang alternates that are broken, redirect, are noindex or canonicalize elsewhere. */
 const hreflangTargetFindings = (scope) => {
     const { key, okPages } = scope;
     const invalid = [];
     const seen = new Set();
+    const fix = [];
     for (const p of okPages) {
         for (const alt of p.page.hreflang) {
             if (!alt.url || key(alt.url) === key(p.url)) {
@@ -733,26 +1112,19 @@ const hreflangTargetFindings = (scope) => {
                     alternate: alt.url,
                     problem: problem.detail,
                 });
+                fix.push(hreflangRepair(p, alt, problem));
             }
         }
     }
     return invalid.length > 0
         ? [
-            finding(m("site.hreflang-target-invalid"), `${invalid.length} hreflang alternate(s) point to URLs that are broken, redirect, are noindex or are not canonical.`, { evidence: { count: invalid.length, examples: cap(invalid) } }),
+            finding(m("site.hreflang-target-invalid"), `${invalid.length} hreflang alternate(s) point to URLs that are broken, redirect, are noindex or are not canonical.`, {
+                fix: fix.slice(0, MAX_EDITS),
+                evidence: { count: invalid.length, examples: cap(invalid) },
+            }),
         ]
         : [];
 };
-/** The URL with its path lower-cased and trailing slashes dropped: one key for every spelling. */
-const spellingKey = (url) => {
-    try {
-        const u = new URL(url);
-        const pathname = trimTrailingSlashes(u.pathname.toLowerCase()) || "/";
-        return `${u.origin}${pathname}${u.search}`;
-    }
-    catch {
-        return url;
-    }
-};
 const pathnameOf = (url) => {
     try {
         return new URL(url).pathname;
@@ -805,8 +1177,19 @@ const urlVariantFindings = (scope) => {
         return [];
     }
     const kinds = [...new Set(duplicates.map((d) => d.kind))];
+    const fix = duplicates.slice(0, MAX_EDITS).map((d) => ({
+        in: "http",
+        action: "replace",
+        url: d.variant,
+        current: statusLine(d.status ?? 200),
+        code: redirectTo(d.url),
+        write: d.kind === "trailing-slash"
+            ? "For every URL of the site, to the one spelling with or without the trailing slash: the trailingSlash setting in Next.js, Nuxt or Astro, or a redirect rule at the server or CDN."
+            : "For every URL spelled in another case, to the spelling the site links to: a redirect rule at the server or CDN.",
+    }));
     return [
         finding(m("site.url-variant-duplicate"), `${duplicates.length} page(s) also answer at a ${kinds.join(" and a ")} variant of their URL.`, {
+            fix,
             evidence: {
                 count: duplicates.length,
                 examples: cap(duplicates.map(({ kind, url, variant, canonical }) => ({
@@ -829,7 +1212,16 @@ const withoutQuery = (url) => {
     }
 };
 /** Pages that differ only in their query string, show the same text and do not consolidate. */
-const parameterDuplicateFindings = ({ key, okPages, isIndexable, }) => {
+/** Canonicals from each parameter version to the URL without the parameter, or the first URL. */
+const parameterCanonicals = ({ key, pagesByKey }, group) => {
+    const target = group.urls.find((u) => !u.includes("?")) ?? group.urls[0] ?? group.path;
+    return group.urls.flatMap((u) => {
+        const record = key(u) === key(target) ? undefined : pagesByKey.get(key(u));
+        return record ? [canonicalEdit(record, target)] : [];
+    });
+};
+const parameterDuplicateFindings = (scope) => {
+    const { key, okPages, isIndexable } = scope;
     const byPath = new Map();
     for (const p of okPages) {
         const { canonical } = p.page;
@@ -867,12 +1259,41 @@ const parameterDuplicateFindings = ({ key, okPages, isIndexable, }) => {
     }
     return groups.length > 0
         ? [
-            finding(m("site.parameter-duplicates"), `${groups.length} path(s) are crawled under several query strings with the same text.`, { evidence: { count: groups.length, groups: cap(groups) } }),
+            finding(m("site.parameter-duplicates"), `${groups.length} path(s) are crawled under several query strings with the same text.`, {
+                fix: groups
+                    .flatMap((g) => parameterCanonicals(scope, g))
+                    .slice(0, MAX_EDITS),
+                evidence: { count: groups.length, groups: cap(groups) },
+            }),
         ]
         : [];
 };
+/** Points each <img> that shows a broken image at a slot for the image's working URL. */
+const brokenImageEdits = ({ key, pagesByKey }, image, pages) => {
+    const write = `The URL the image file is deployed at; or upload the missing file to ${image.url}.`;
+    const edits = [...pages].flatMap((u) => {
+        const record = pagesByKey.get(key(u));
+        return record
+            ? imagesOf(record, image.url).map((img) => onUrl(setAttributeEdit(img.tag, "img", "src", slot("working URL of the image"), write), locationOf(record)))
+            : [];
+    });
+    // An image from srcset or a <picture> source has no <img src> to quote: upload the file instead.
+    return edits.length > 0
+        ? edits
+        : [
+            {
+                in: "asset",
+                action: "add",
+                url: image.url,
+                at: "new file",
+                code: slot("the image file"),
+                write: `Upload the image the pages show here, or change the pages that point to ${image.url}.`,
+            },
+        ];
+};
 /** Images that answer 4xx/5xx or do not load, with the pages that show them. */
-const brokenImageFindings = (ctx) => {
+const brokenImageFindings = (scope) => {
+    const { ctx } = scope;
     const broken = [];
     for (const [url, check] of ctx.imageChecks ?? []) {
         if (check.error || (check.status ?? 0) >= 400) {
@@ -889,7 +1310,12 @@ const brokenImageFindings = (ctx) => {
     }
     return broken.length > 0
         ? [
-            finding(m("site.broken-images"), `${broken.length} image URL(s) are broken.`, { evidence: { count: broken.length, examples: cap(broken, 20) } }),
+            finding(m("site.broken-images"), `${broken.length} image URL(s) are broken.`, {
+                fix: broken
+                    .flatMap((b) => brokenImageEdits(scope, b, ctx.imageSources?.get(b.url) ?? []))
+                    .slice(0, MAX_EDITS),
+                evidence: { count: broken.length, examples: cap(broken, 20) },
+            }),
         ]
         : [];
 };
@@ -913,20 +1339,21 @@ export const runSiteRules = (ctx) => {
         okPages: ctx.pages.filter((p) => (p.response?.status ?? 200) < 400),
         isIndexable: (p) => !robotsDirectives(p.page, p.response).noindex &&
             (p.response?.status ?? 200) < 400,
+        linksTo: (p, targetKey) => linksTo(p, targetKey, key),
     };
     return [
-        ...robotsFindings(ctx),
+        ...robotsFindings(scope),
         ...robotsContentFindings(ctx),
         ...blockedResourceFindings(scope),
         ...sitemapFindings(scope),
         ...sitemapProtocolFindings(ctx),
-        ...linkHealthFindings(ctx),
-        ...unreachedFindings(ctx),
+        ...linkHealthFindings(scope),
+        ...unreachedFindings(scope),
         ...duplicateFindings(scope),
         ...architectureFindings(scope),
         ...urlVariantFindings(scope),
         ...parameterDuplicateFindings(scope),
-        ...brokenImageFindings(ctx),
+        ...brokenImageFindings(scope),
         ...canonicalGraphFindings(scope),
         ...noindexLinkFindings(scope),
         ...hreflangTargetFindings(scope),