search-auditor 0.1.0 → 0.2.0

package/dist/trace.js

@@ -0,0 +1,77 @@
+import tls from "node:tls";
+import { DEFAULT_UA, toPublic, toTarget } from "auditor-engine";
+const REDIRECT = new Set([301, 302, 303, 307, 308]);
+const MAX_HOPS = 10;
+/**
+ * Follows redirects one at a time, the way a crawler counts them: fetch with redirect: "follow" hides the steps.
+ * Returns the public URL of every hop after the first, whether it looped, and the final status.
+ */
+export async function trace(url, o, timeoutMs = 10_000) {
+    const seen = new Set([url]);
+    const hops = [];
+    let current = url;
+    for (let i = 0; i < MAX_HOPS; i++) {
+        let res;
+        try {
+            res = await fetch(toTarget(current, o), { redirect: "manual", headers: { "user-agent": DEFAULT_UA }, signal: AbortSignal.timeout(timeoutMs) });
+            await res.body?.cancel();
+        }
+        catch {
+            return { hops, loop: false, status: 0 };
+        }
+        const location = res.headers.get("location");
+        if (!REDIRECT.has(res.status) || !location)
+            return { hops, loop: false, status: res.status };
+        const next = toPublic(new URL(location, toTarget(current, o)).href, o);
+        hops.push(next);
+        if (seen.has(next))
+            return { hops, loop: true, status: res.status };
+        seen.add(next);
+        current = next;
+    }
+    return { hops, loop: false, status: 0 };
+}
+/** Time to the response headers, in ms: what a crawler waits before the page starts to arrive. */
+export async function timeToFirstByte(url, o, timeoutMs = 10_000) {
+    const start = performance.now();
+    try {
+        const res = await fetch(toTarget(url, o), { headers: { "user-agent": DEFAULT_UA }, signal: AbortSignal.timeout(timeoutMs) });
+        const ms = performance.now() - start;
+        await res.body?.cancel();
+        return res.ok ? Math.round(ms) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The first answer to a URL without following redirects: its status and Location. */
+export async function firstHop(url, timeoutMs = 10_000) {
+    try {
+        const res = await fetch(url, { redirect: "manual", headers: { "user-agent": DEFAULT_UA }, signal: AbortSignal.timeout(timeoutMs) });
+        await res.body?.cancel();
+        return { status: res.status, location: res.headers.get("location") ?? "" };
+    }
+    catch {
+        return null;
+    }
+}
+/** Opens a TLS connection to the host and reads its certificate: trusted or not, and how long it has left. */
+export function certificateOf(host, timeoutMs = 10_000) {
+    return new Promise((resolve) => {
+        // rejectUnauthorized: false so an expired or self-signed certificate is reported, not thrown away.
+        const socket = tls.connect({ host, port: 443, servername: host, rejectUnauthorized: false, timeout: timeoutMs }, () => {
+            const cert = socket.getPeerCertificate();
+            socket.end();
+            if (!cert?.valid_to)
+                return resolve(null);
+            const daysLeft = Math.floor((new Date(cert.valid_to).getTime() - Date.now()) / 86_400_000);
+            const error = socket.authorizationError ? String(socket.authorizationError) : undefined;
+            resolve({ valid: socket.authorized, ...(error ? { error } : {}), daysLeft, validTo: new Date(cert.valid_to).toISOString().slice(0, 10) });
+        });
+        socket.on("error", () => resolve(null));
+        socket.on("timeout", () => {
+            socket.destroy();
+            resolve(null);
+        });
+    });
+}

package/dist/types.d.ts

@@ -1,12 +1,20 @@
-import type { Config as AiConfig, Fetched, Lang, Site } from "ai-search-auditor";
+import type { Config as EngineConfig, Fetched, Lang, Site } from "auditor-engine";
 /** One extra request made for the SEO checks: what it answered and where it ended. */
 export interface Probe {
     status: number;
     redirected: boolean;
     finalUrl: string;
     error?: string;
-    /** The audited page where the URL was found (internal links). */
-    from?: string;
+    /** The audited pages that link to the URL (internal links), in crawl order. */
+    from?: string[];
+    /** The canonical the page declares, absolute; for canonical targets that answered 200. */
+    canonical?: string;
+    /** An HTML page, as its Content-Type says: feeds, PDFs and other files are not pages to list. */
+    html?: boolean;
+    /** The page is closed with noindex (meta robots or X-Robots-Tag). */
+    noindex?: boolean;
+    /** Size from Content-Length, in bytes, when the server sends it. */
+    bytes?: number;
 }
 /** Data the SEO checks need beyond the shared crawl, collected in the same run (collect.ts). */
 export interface SeoExtras {
@@ -23,15 +31,87 @@ export interface SeoExtras {
     /** Unique internal links found, and how many were requested (capped by maxLinks). */
     linksFound: number;
     linksChecked: number;
+    /** robots.txt as the server answered it, whatever the status: the crawl keeps it only on 200. */
+    robotsRaw: Fetched;
+    /** The home page on the other host, www. added or removed; live sites only, null when there is no such host. */
+    otherHost: Fetched | null;
+    /** A sampled page requested with the trailing slash toggled, and the canonical it declares. */
+    slashVariant: {
+        main: string;
+        mainCanonical: string;
+        variant: string;
+        fetched: Fetched;
+        canonical: string;
+    } | null;
+    /** Addresses that redirect, followed hop by hop. */
+    chains: Chain[];
+    /** Time to the first byte of the home page, in ms, over a few requests; null on a local build. */
+    ttfb: number[] | null;
+    /** First answer of http://host/ without following it: the redirect code and where it points. Live https sites only. */
+    httpHop: {
+        status: number;
+        location: string;
+    } | null;
+    /** The TLS certificate of the live site; null on a local build or when the site is not on https. */
+    cert: Certificate | null;
+    /** A sampled page requested with UTM parameters, and the canonical it then declares. */
+    utm: {
+        page: string;
+        url: string;
+        status: number;
+        canonical: string;
+    } | null;
+    /** The sitemap files as served: those robots.txt declares (or /sitemap.xml), and the children of an index. */
+    sitemapFiles: SitemapFile[];
+    /** Sitemap addresses outside the sample, requested to see that they answer 200 (capped). */
+    sitemapExtra: Map<string, Probe>;
+    /** /favicon.ico, requested only when the home page declares no icon. */
+    favicon: Fetched | null;
+    /** Links to other sites found on the audited pages, requested to see that they still exist (capped). */
+    external: Map<string, Probe>;
+    /** Images of this site used on the audited pages: do they open, and how heavy are they (capped). */
+    images: Map<string, Probe>;
+}
+/** One sitemap file: what it answered, what it is, and what is wrong with its format. */
+export interface SitemapFile {
+    url: string;
+    /** Where it came from: robots.txt, the default /sitemap.xml, or a sitemap index. */
+    source: "robots" | "default" | "index";
+    status: number;
+    error?: string;
+    kind: "urlset" | "index" | "html" | "other" | "gzip";
+    bytes: number;
+    /** <url> or <sitemap> entries. */
+    count: number;
+    /** <loc> values with a bare & that breaks the XML. */
+    badAmpersands: number;
+}
+/** What the TLS handshake said about the certificate. */
+export interface Certificate {
+    /** The certificate is trusted and matches the host. */
+    valid: boolean;
+    /** Why it is not trusted: expired, self-signed, wrong host… */
+    error?: string;
+    /** Days until it expires; negative when it already has. */
+    daysLeft: number;
+    validTo: string;
+}
+/** A redirect followed one hop at a time: every address on the way, and whether it came back to one of them. */
+export interface Chain {
+    url: string;
+    hops: string[];
+    loop: boolean;
+    /** Status at the end of the chain (0 when it did not end). */
+    status: number;
+    /** The audited pages where the address was found: links, sitemap, canonical. */
+    from: string[];
 }
 /** A crawled site with the SEO extras attached. */
 export type SeoSite = Site & {
     seo: SeoExtras;
 };
-export interface SearchConfig extends AiConfig {
+export interface SearchConfig extends EngineConfig {
     /** Internal links to request per run (default 100). */
     maxLinks: number;
-    /** Run the AI search checks too (default true). */
-    ai: boolean;
 }
 export type { Lang };

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "search-auditor",
-  "version": "0.1.0",
-  "description": "SEO and AI search audit in one report: classic technical SEO (indexing, canonical, meta, links, sitemap, hreflang, HTTPS) plus whether ChatGPT, Claude and Perplexity can read and cite the site. One crawl, one score, CI-ready.",
+  "version": "0.2.0",
+  "description": "Technical SEO audit from the command line: indexing, robots.txt, redirects, canonical, sitemap, meta tags, headings, links, images, structured data, hreflang, HTTPS. One score, CI-ready.",
   "keywords": [
     "seo audit",
     "search audit",
     "technical seo",
     "seo checker",
-    "geo",
-    "ai search",
-    "ai seo",
-    "aeo",
     "canonical",
     "hreflang",
     "sitemap",
@@ -49,12 +45,11 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
-  "peerDependencies": {
-    "ai-search-auditor": "^0.3.0"
+  "dependencies": {
+    "auditor-engine": "^0.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.18.0",
-    "ai-search-auditor": "^0.3.0",
     "typescript": "^5.9.0"
   }
 }

package/dist/rules/links.d.ts

@@ -1,2 +0,0 @@
-import { type SeoRule } from "./util.ts";
-export declare const linkRules: SeoRule[];

package/dist/rules/links.js

@@ -1,95 +0,0 @@
-import { finder, isSameSite } from "ai-search-auditor";
-import { seoOf } from "../collect.js";
-import { absolute, norm, rel, statusOf } from "./util.js";
-const lnk1 = {
-    id: "LNK-1",
-    group: "LNK",
-    level: "error",
-    applies: (site, t) => (seoOf(site).linksFound ? null : t.skipNoLinks),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const { links, linksFound, linksChecked } = seoOf(site);
-        for (const [url, p] of links)
-            if (p.status === 0 || p.status >= 400)
-                add(url, t.brokenLink(statusOf(p), rel(p.from ?? site.base, site.base)));
-        if (linksChecked < linksFound)
-            add("site", t.linksNotChecked(linksChecked, linksFound), "info");
-        return out;
-    },
-};
-const lnk2 = {
-    id: "LNK-2",
-    group: "LNK",
-    level: "warn",
-    applies: (site, t) => (seoOf(site).linksFound ? null : t.skipNoLinks),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const [url, p] of seoOf(site).links)
-            if (p.status > 0 && p.status < 400 && p.redirected && norm(p.finalUrl) !== norm(url))
-                add(url, t.redirectLink(rel(p.finalUrl, site.base), rel(p.from ?? site.base, site.base)));
-        return out;
-    },
-};
-/** ISO 639-1 language, optional ISO 15924 script and region (ISO 3166-1 or UN M.49), or x-default. */
-const HREFLANG = /^(x-default|[a-z]{2,3}(-[a-z]{4})?(-([a-z]{2}|\d{3}))?)$/i;
-const hasHreflang = (site) => site.pages.some((p) => p.hreflang.length);
-const lang1 = {
-    id: "LANG-1",
-    group: "LANG",
-    level: "warn",
-    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages)
-            for (const h of p.hreflang)
-                if (!HREFLANG.test(h.lang))
-                    add(p.fetched.publicUrl, t.badHreflang(h.lang));
-        return out;
-    },
-};
-const lang2 = {
-    id: "LANG-2",
-    group: "LANG",
-    level: "warn",
-    applies: (site, t) => (hasHreflang(site) ? null : t.skipNoHreflang),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const o = { target: site.target, base: site.base };
-        // Only pairs where both pages were audited: a translation outside the sample is not known to be one-way.
-        const audited = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
-        for (const p of site.pages) {
-            const self = norm(p.fetched.publicUrl);
-            for (const h of p.hreflang) {
-                if (h.lang.toLowerCase() === "x-default")
-                    continue;
-                const href = absolute(h.href, p.fetched.publicUrl);
-                if (!href || !isSameSite(href, o) || norm(href) === self)
-                    continue;
-                const other = audited.get(norm(href));
-                if (other && !other.hreflang.some((b) => norm(absolute(b.href, other.fetched.publicUrl)) === self))
-                    add(p.fetched.publicUrl, t.oneWayHreflang(h.lang, rel(href, site.base)));
-            }
-        }
-        return out;
-    },
-};
-const lang3 = {
-    id: "LANG-3",
-    group: "LANG",
-    level: "info",
-    applies(site, t) {
-        if (!hasHreflang(site))
-            return t.skipNoHreflang;
-        return site.pages.some((p) => new Set(p.hreflang.filter((h) => h.lang.toLowerCase() !== "x-default").map((h) => h.lang.toLowerCase())).size > 1) ? null : t.skipOneLanguage;
-    },
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            const langs = [...new Set(p.hreflang.map((h) => h.lang.toLowerCase()))];
-            if (langs.length > 1 && !langs.includes("x-default"))
-                add(p.fetched.publicUrl, t.noXDefault(langs.join(", ")));
-        }
-        return out;
-    },
-};
-export const linkRules = [lnk1, lnk2, lang1, lang2, lang3];

package/dist/rules/page.d.ts

@@ -1,2 +0,0 @@
-import { type SeoRule } from "./util.ts";
-export declare const pageRules: SeoRule[];

package/dist/rules/page.js

@@ -1,145 +0,0 @@
-import { finder } from "ai-search-auditor";
-import { rel, short } from "./util.js";
-const TITLE = { min: 10, max: 60 };
-const DESCRIPTION = { min: 50, max: 160 };
-/** Characters as a person counts them: emoji and letters with marks are one each. */
-const len = (s) => [...s.trim()].length;
-const meta1 = {
-    id: "META-1",
-    group: "META",
-    level: "error",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            const n = len(p.title);
-            if (!n)
-                add(p.fetched.publicUrl, t.noTitle);
-            else if (n < TITLE.min || n > TITLE.max)
-                add(p.fetched.publicUrl, t.titleLength(n, short(p.title)), "warn");
-        }
-        return out;
-    },
-};
-const meta2 = {
-    id: "META-2",
-    group: "META",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            const n = len(p.description);
-            if (!n)
-                add(p.fetched.publicUrl, t.noDescription);
-            else if (n < DESCRIPTION.min || n > DESCRIPTION.max)
-                add(p.fetched.publicUrl, t.descriptionLength(n), "info");
-        }
-        return out;
-    },
-};
-const meta3 = {
-    id: "META-3",
-    group: "META",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const repeated = (pick, message) => {
-            const by = new Map();
-            for (const p of site.pages) {
-                const v = pick(p).trim();
-                if (v)
-                    by.set(v, [...(by.get(v) ?? []), p.fetched.publicUrl]);
-            }
-            for (const [text, urls] of by)
-                if (urls.length > 1)
-                    for (const u of urls)
-                        add(u, message(urls.length, short(text)));
-        };
-        repeated((p) => p.title, t.sameTitle);
-        repeated((p) => p.description, t.sameDescription);
-        return out;
-    },
-};
-const str1 = {
-    id: "STR-1",
-    group: "STR",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            if (!p.h1.length)
-                add(p.fetched.publicUrl, t.noH1);
-            else if (p.h1.length > 1)
-                add(p.fetched.publicUrl, t.manyH1(p.h1.length));
-        }
-        return out;
-    },
-};
-const str2 = {
-    id: "STR-2",
-    group: "STR",
-    level: "info",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            // One finding per page: the first skip is enough to show the pattern.
-            const hs = p.headingsAll;
-            const i = hs.findIndex((h, k) => k > 0 && h.level > hs[k - 1].level + 1);
-            if (i > 0)
-                add(p.fetched.publicUrl, t.skippedLevel(hs[i - 1].level, hs[i].level, short(hs[i].text, 50)));
-        }
-        return out;
-    },
-};
-const str3 = {
-    id: "STR-3",
-    group: "STR",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages)
-            if (!p.htmlLang.trim())
-                add(p.fetched.publicUrl, t.noLang);
-        return out;
-    },
-};
-const str4 = {
-    id: "STR-4",
-    group: "STR",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages)
-            if (!/width\s*=\s*device-width/i.test(p.viewport))
-                add(p.fetched.publicUrl, t.noViewport);
-        return out;
-    },
-};
-const img1 = {
-    id: "IMG-1",
-    group: "IMG",
-    level: "warn",
-    applies: (site, t) => (site.pages.some((p) => p.images.length) ? null : t.skipNoImages),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            const missing = p.images.filter((i) => i.alt === null);
-            if (missing.length)
-                add(p.fetched.publicUrl, t.imagesNoAlt(missing.length, p.images.length, rel(missing[0].src, site.base)));
-        }
-        return out;
-    },
-};
-const data1 = {
-    id: "DATA-1",
-    group: "DATA",
-    level: "error",
-    applies: (site, t) => (site.pages.some((p) => p.jsonLd.length || p.jsonLdErrors.length) ? null : t.skipNoJsonLd),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages)
-            for (const e of p.jsonLdErrors)
-                add(p.fetched.publicUrl, t.jsonLdError(short(e, 100)));
-        return out;
-    },
-};
-export const pageRules = [meta1, meta2, meta3, str1, str2, str3, str4, img1, data1];

package/dist/rules/site.d.ts

@@ -1,2 +0,0 @@
-import { type SeoRule } from "./util.ts";
-export declare const siteRules: SeoRule[];

package/dist/rules/site.js

@@ -1,177 +0,0 @@
-import { finder, isSameSite } from "ai-search-auditor";
-import { seoOf } from "../collect.js";
-import { absolute, norm, rel, short, statusOf } from "./util.js";
-/** Titles and H1s of «not found» pages that still answer 200. */
-const NOT_FOUND = /\b(404|not found|page not found|doesn.t exist)\b|не найден|страница не существует|ничего не найдено/i;
-const idx1 = {
-    id: "IDX-1",
-    group: "IDX",
-    level: "error",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const f of site.failed)
-            if (f.status !== 200)
-                add(f.publicUrl, t.status(statusOf(f)));
-        return out;
-    },
-};
-const idx2 = {
-    id: "IDX-2",
-    group: "IDX",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const probe = seoOf(site).probe404;
-        if (probe && probe.status === 200)
-            add("site", t.soft404Probe(rel(probe.publicUrl, site.base)));
-        for (const p of site.pages) {
-            const head = p.h1[0] ?? "";
-            if (NOT_FOUND.test(p.title) || NOT_FOUND.test(head))
-                add(p.fetched.publicUrl, t.soft404Page(short(p.title || head)));
-        }
-        return out;
-    },
-};
-const sec1 = {
-    id: "SEC-1",
-    group: "SEC",
-    level: "error",
-    applies: (site, t) => (seoOf(site).local ? t.skipLocal : null),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        if (!site.base.startsWith("https://")) {
-            add("site", t.notHttps);
-            return out;
-        }
-        // Only an http:// answer that stays on http:// is a problem; a closed port 80 is not.
-        const home = seoOf(site).httpHome;
-        if (home && home.status > 0 && !(home.finalUrl ?? "").startsWith("https://"))
-            add(home.publicUrl, t.httpNoRedirect(home.finalUrl ?? home.publicUrl));
-        return out;
-    },
-};
-const sec2 = {
-    id: "SEC-2",
-    group: "SEC",
-    level: "warn",
-    applies: (site, t) => (site.base.startsWith("https://") ? null : t.skipNotHttps),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages) {
-            const insecure = p.resources.filter((r) => r.startsWith("http://"));
-            if (insecure.length)
-                add(p.fetched.publicUrl, t.mixedContent(insecure.length, insecure[0]));
-        }
-        return out;
-    },
-};
-const can1 = {
-    id: "CAN-1",
-    group: "CAN",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        for (const p of site.pages)
-            if (!p.canonical)
-                add(p.fetched.publicUrl, t.noCanonical);
-        return out;
-    },
-};
-const can2 = {
-    id: "CAN-2",
-    group: "CAN",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const o = { target: site.target, base: site.base };
-        for (const p of site.pages) {
-            if (!p.canonical)
-                continue;
-            if (!/^https?:\/\//i.test(p.canonical))
-                add(p.fetched.publicUrl, t.relativeCanonical(p.canonical));
-            else if (!isSameSite(p.canonical, o))
-                add(p.fetched.publicUrl, t.foreignCanonical(p.canonical));
-        }
-        return out;
-    },
-};
-const can3 = {
-    id: "CAN-3",
-    group: "CAN",
-    level: "error",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const { canonicals } = seoOf(site);
-        const o = { target: site.target, base: site.base };
-        // A canonical pointing at a sampled page is known from the crawl; others were requested in collect().
-        const sampled = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p.fetched]));
-        const failed = new Map(site.failed.map((f) => [norm(f.publicUrl), f]));
-        for (const p of site.pages) {
-            const href = p.canonical ? absolute(p.canonical, p.fetched.publicUrl) : "";
-            if (!href || !isSameSite(href, o))
-                continue;
-            const key = norm(href);
-            const known = sampled.get(key) ?? failed.get(key);
-            const probe = known ? { status: known.status, error: known.error, redirected: Boolean(known.redirected), finalUrl: known.finalUrl ?? known.publicUrl } : canonicals.get(key);
-            if (!probe)
-                continue;
-            if (probe.status !== 200)
-                add(p.fetched.publicUrl, t.canonicalStatus(rel(href, site.base), statusOf(probe)));
-            else if (probe.redirected && norm(probe.finalUrl) !== key)
-                add(p.fetched.publicUrl, t.canonicalRedirects(rel(href, site.base), rel(probe.finalUrl, site.base)), "warn");
-        }
-        return out;
-    },
-};
-const map1 = {
-    id: "MAP-1",
-    group: "MAP",
-    level: "warn",
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        if (!site.sitemap)
-            add("site", t.noSitemap);
-        else if (site.robots && !/^\s*sitemap\s*:/im.test(site.robots.fetched.body))
-            add("site", t.sitemapNotInRobots, "info");
-        return out;
-    },
-};
-const inSitemap = (site) => new Set((site.sitemap?.urls ?? []).map((u) => norm(u.loc)));
-const map2 = {
-    id: "MAP-2",
-    group: "MAP",
-    level: "warn",
-    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const listed = inSitemap(site);
-        for (const f of [...site.pages.map((p) => p.fetched), ...site.failed]) {
-            if (!listed.has(norm(f.publicUrl)) || !f.redirected || !f.finalUrl)
-                continue;
-            if (norm(f.finalUrl) !== norm(f.publicUrl))
-                add(f.publicUrl, t.sitemapRedirects(rel(f.finalUrl, site.base)));
-        }
-        return out;
-    },
-};
-const map3 = {
-    id: "MAP-3",
-    group: "MAP",
-    level: "warn",
-    applies: (site, t) => (site.sitemap ? null : t.skipNoSitemap),
-    run(site, _c, t) {
-        const { out, add } = finder(this);
-        const listed = inSitemap(site);
-        for (const p of site.pages) {
-            const f = p.fetched;
-            // A listed address that redirects is MAP-2's finding; its target's canonical says nothing new.
-            if (!listed.has(norm(f.publicUrl)) || (f.finalUrl && norm(f.finalUrl) !== norm(f.publicUrl)))
-                continue;
-            const href = p.canonical ? absolute(p.canonical, f.publicUrl) : "";
-            if (href && norm(href) !== norm(f.publicUrl))
-                add(f.publicUrl, t.sitemapCanonicalElsewhere(rel(href, site.base)));
-        }
-        return out;
-    },
-};
-export const siteRules = [idx1, idx2, sec1, sec2, can1, can2, can3, map1, map2, map3];