search-auditor 0.1.1 → 0.2.0

package/dist/rules/data/data-3.js

@@ -0,0 +1,29 @@
+/** DATA-3: Rich-result types have the properties Google requires. */
+import { finder } from "auditor-engine";
+import { REQUIRED, typesOf } from "./shared.js";
+/** Present and not empty: "", [] and {} do not count. */
+const has = (n, key) => {
+    const v = n[key];
+    return v !== undefined && v !== null && v !== "" && !(Array.isArray(v) && !v.length);
+};
+export const data3 = {
+    id: "DATA-3",
+    group: "DATA",
+    level: "warn",
+    applies: (site, t) => (site.pages.some((p) => p.jsonLd.some((n) => typesOf(n).some((x) => REQUIRED[x]))) ? null : t.skipNoRichTypes),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const missing = new Map();
+            for (const n of p.jsonLd)
+                for (const type of typesOf(n)) {
+                    const absent = (REQUIRED[type] ?? []).filter((req) => !req.split("|").some((k) => has(n, k)));
+                    if (absent.length)
+                        missing.set(type, new Set([...(missing.get(type) ?? []), ...absent.map((a) => a.replace(/\|/g, " / "))]));
+                }
+            for (const [type, keys] of missing)
+                add(p.fetched.publicUrl, t.missingProperties(type, [...keys].join(", ")));
+        }
+        return out;
+    },
+};

package/dist/rules/data/data-4.d.ts

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

package/dist/rules/data/data-4.js

@@ -0,0 +1,17 @@
+/** DATA-4: Nested pages have breadcrumbs. */
+import { finder } from "auditor-engine";
+import { BREADCRUMB_DEPTH, depthOf, typesOf } from "./shared.js";
+export const data4 = {
+    id: "DATA-4",
+    group: "DATA",
+    level: "info",
+    applies: (site, t) => (site.pages.some((p) => depthOf(p.fetched.publicUrl) >= BREADCRUMB_DEPTH) ? null : t.skipNoNestedPages),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Google shows the trail instead of the bare address under the title: «Blog › AI agents».
+        for (const p of site.pages)
+            if (depthOf(p.fetched.publicUrl) >= BREADCRUMB_DEPTH && !p.jsonLd.some((n) => typesOf(n).includes("BreadcrumbList")))
+                add(p.fetched.publicUrl, t.noBreadcrumbs);
+        return out;
+    },
+};

package/dist/rules/data/data-5.d.ts

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

package/dist/rules/data/data-5.js

@@ -0,0 +1,28 @@
+/** DATA-5: Addresses and dates in the markup are in a format search engines read. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+import { DATE_KEYS, ISO_DATE, URL_KEYS } from "./shared.js";
+/** String values of a property: a plain string or each string of an array. */
+const strings = (n, key) => {
+    const v = n[key];
+    return (Array.isArray(v) ? v : [v]).filter((x) => typeof x === "string");
+};
+export const data5 = {
+    id: "DATA-5",
+    group: "DATA",
+    level: "warn",
+    applies: (site, t) => (site.pages.some((p) => p.jsonLd.length) ? null : t.skipNoJsonLd),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // Relative addresses are resolved against nothing in JSON-LD: «/logo.png» is not an address there.
+            const relative = p.jsonLd.flatMap((n) => URL_KEYS.flatMap((k) => strings(n, k).map((v) => `${k}: ${v}`))).filter((s) => !/: (https?:\/\/|#)/i.test(s));
+            const dates = p.jsonLd.flatMap((n) => DATE_KEYS.flatMap((k) => strings(n, k).map((v) => ({ k, v })))).filter(({ v }) => !ISO_DATE.test(v.trim()));
+            if (relative.length)
+                add(p.fetched.publicUrl, t.relativeInMarkup(relative.length, short(relative[0], 60)));
+            if (dates.length)
+                add(p.fetched.publicUrl, t.badDatesInMarkup(dates.length, `${dates[0].k}: ${short(dates[0].v, 30)}`));
+        }
+        return out;
+    },
+};

package/dist/rules/data/data-6.d.ts

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

package/dist/rules/data/data-6.js

@@ -0,0 +1,16 @@
+/** DATA-6: The home page names the site with WebSite. */
+import { finder } from "auditor-engine";
+import { typesOf } from "./shared.js";
+export const data6 = {
+    id: "DATA-6",
+    group: "DATA",
+    level: "info",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Google takes the site name shown above results from WebSite on the home page; without it, it guesses.
+        const home = site.pages.find((p) => new URL(p.fetched.publicUrl).pathname === "/");
+        if (home && !home.jsonLd.some((n) => typesOf(n).includes("WebSite") && typeof n.name === "string" && n.name.trim()))
+            add(home.fetched.publicUrl, t.noWebSite);
+        return out;
+    },
+};

package/dist/rules/data/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Structured data (DATA): does the JSON-LD on the pages parse and say enough for rich results in search.
+ * No syntax errors, @context and @type on every entity, the properties Google requires for rich-result types,
+ * breadcrumbs on nested pages, full addresses and ISO dates, and the site name in WebSite on the home page.
+ * What the markup says about authorship, articles and FAQs is checked by the AI search rules (C group).
+ */
+import type { SeoRule } from "../util.ts";
+export declare const dataRules: SeoRule[];

package/dist/rules/data/index.js

@@ -0,0 +1,7 @@
+import { data1 } from "./data-1.js";
+import { data2 } from "./data-2.js";
+import { data3 } from "./data-3.js";
+import { data4 } from "./data-4.js";
+import { data5 } from "./data-5.js";
+import { data6 } from "./data-6.js";
+export const dataRules = [data1, data2, data3, data4, data5, data6];

package/dist/rules/data/shared.d.ts

@@ -0,0 +1,22 @@
+/** Constants and helpers shared by the DATA checks. */
+import { type JsonLdNode } from "auditor-engine";
+/** The JSON-LD blocks of the raw HTML that parse, as written: the top level keeps @context, flattening loses it. */
+export declare function blocks(html: string): unknown[];
+/** The entities a block describes at its top level: the block itself, the items of an array, or of @graph. */
+export declare const topNodes: (block: unknown) => JsonLdNode[];
+/** A node that only points at another one: {"@id": "…#person"}. It needs no @type of its own. */
+export declare const isReference: (n: JsonLdNode) => boolean;
+export declare const typesOf: (n: JsonLdNode) => string[];
+/**
+ * What Google needs to show a rich result, per type: every name in a list is required; «a|b» means one of them.
+ * Article and FAQPage are checked by the AI search rules (C-4, C-7).
+ */
+export declare const REQUIRED: Record<string, string[]>;
+/** Properties that hold an address, and those that hold a date. */
+export declare const URL_KEYS: string[];
+export declare const DATE_KEYS: string[];
+/** ISO 8601 as Google reads it: a date, or a date and time with an optional zone. */
+export declare const ISO_DATE: RegExp;
+/** Pages this deep or deeper get a breadcrumb trail; a language prefix (/ru) does not count as a level. */
+export declare const BREADCRUMB_DEPTH = 2;
+export declare const depthOf: (url: string) => number;

package/dist/rules/data/shared.js

@@ -0,0 +1,59 @@
+/** Constants and helpers shared by the DATA checks. */
+import { jsonLdTypes } from "auditor-engine";
+/** The JSON-LD blocks of the raw HTML that parse, as written: the top level keeps @context, flattening loses it. */
+export function blocks(html) {
+    const out = [];
+    for (const m of html.matchAll(/<script\b[^>]*type\s*=\s*["']?application\/ld\+json["']?[^>]*>([\s\S]*?)<\/script>/gi)) {
+        try {
+            out.push(JSON.parse(m[1] ?? ""));
+        }
+        catch {
+            // A block that does not parse is DATA-1's finding.
+        }
+    }
+    return out;
+}
+/** The entities a block describes at its top level: the block itself, the items of an array, or of @graph. */
+export const topNodes = (block) => {
+    const list = Array.isArray(block) ? block : [block];
+    return list.flatMap((b) => {
+        if (!b || typeof b !== "object")
+            return [];
+        const graph = b["@graph"];
+        return Array.isArray(graph) ? graph : [b];
+    });
+};
+/** A node that only points at another one: {"@id": "…#person"}. It needs no @type of its own. */
+export const isReference = (n) => Object.keys(n).every((k) => k === "@id");
+export const typesOf = (n) => jsonLdTypes(n);
+/**
+ * What Google needs to show a rich result, per type: every name in a list is required; «a|b» means one of them.
+ * Article and FAQPage are checked by the AI search rules (C-4, C-7).
+ */
+export const REQUIRED = {
+    Product: ["name", "offers|review|aggregateRating"],
+    Offer: ["price|priceSpecification"],
+    Event: ["name", "startDate", "location"],
+    Recipe: ["name", "image"],
+    VideoObject: ["name", "thumbnailUrl", "uploadDate"],
+    LocalBusiness: ["name", "address"],
+    Restaurant: ["name", "address"],
+    Store: ["name", "address"],
+    JobPosting: ["title", "datePosted", "description", "hiringOrganization"],
+    Course: ["name", "description"],
+    AggregateRating: ["ratingValue", "ratingCount|reviewCount"],
+    Review: ["reviewRating", "author"],
+    BreadcrumbList: ["itemListElement"],
+    ListItem: ["position"],
+};
+/** Properties that hold an address, and those that hold a date. */
+export const URL_KEYS = ["url", "image", "logo", "thumbnailUrl", "contentUrl", "sameAs", "item"];
+export const DATE_KEYS = ["datePublished", "dateModified", "dateCreated", "uploadDate", "startDate", "endDate", "datePosted", "validThrough", "validFrom", "priceValidUntil"];
+/** ISO 8601 as Google reads it: a date, or a date and time with an optional zone. */
+export const ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+/** Pages this deep or deeper get a breadcrumb trail; a language prefix (/ru) does not count as a level. */
+export const BREADCRUMB_DEPTH = 2;
+export const depthOf = (url) => {
+    const parts = new URL(url).pathname.split("/").filter(Boolean);
+    return parts.length - (parts[0] && /^[a-z]{2}(-[a-z]{2})?$/i.test(parts[0]) ? 1 : 0);
+};

package/dist/rules/idx/idx-1.d.ts

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

package/dist/rules/idx/idx-1.js

@@ -0,0 +1,15 @@
+/** IDX-1: Pages answer 200. */
+import { finder } from "auditor-engine";
+import { statusOf } from "../util.js";
+export 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;
+    },
+};

package/dist/rules/idx/idx-2.d.ts

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

package/dist/rules/idx/idx-2.js

@@ -0,0 +1,22 @@
+/** IDX-2: Missing pages answer 404. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel, short } from "../util.js";
+import { NOT_FOUND } from "./shared.js";
+export 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;
+    },
+};

package/dist/rules/idx/idx-3.d.ts

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

package/dist/rules/idx/idx-3.js

@@ -0,0 +1,35 @@
+/** IDX-3: robots.txt answers without errors. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { short, statusOf } from "../util.js";
+import { ROBOTS_KEYS, ROBOTS_LIMIT } from "./shared.js";
+export const idx3 = {
+    id: "IDX-3",
+    group: "IDX",
+    level: "error",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const r = seoOf(site).robotsRaw;
+        const where = `${site.base}/robots.txt`;
+        // 5xx, 429 and no answer: Google stops crawling. Other 4xx mean «no rules», which is fine.
+        if (r.status === 0 || r.status === 429 || r.status >= 500) {
+            add(where, t.robotsStatus(statusOf(r)));
+            return out;
+        }
+        if (r.status !== 200)
+            return out;
+        if (/^\s*<(!doctype|html)/i.test(r.body)) {
+            add(where, t.robotsHtml, "warn");
+            return out;
+        }
+        if (Buffer.byteLength(r.body) > ROBOTS_LIMIT)
+            add(where, t.robotsSize(Math.round(Buffer.byteLength(r.body) / 1024)), "warn");
+        const bad = r.body
+            .split(/\r?\n/)
+            .map((l) => l.replace(/#.*/, "").trim())
+            .filter((l) => l && !ROBOTS_KEYS.has((l.match(/^([a-z-]+)\s*:/i)?.[1] ?? "").toLowerCase()));
+        if (bad.length)
+            add(where, t.robotsBadLines(bad.length, short(bad[0], 50)), "warn");
+        return out;
+    },
+};

package/dist/rules/idx/idx-4.d.ts

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

package/dist/rules/idx/idx-4.js

@@ -0,0 +1,40 @@
+/** IDX-4: robots.txt does not block the pages of the site: those in the sitemap and the audited ones. */
+import { finder } from "auditor-engine";
+import { norm } from "../util.js";
+import { SEARCH_BOTS, pathOf } from "./shared.js";
+export const idx4 = {
+    id: "IDX-4",
+    group: "IDX",
+    level: "error",
+    applies: (site, t) => (site.robots ? null : t.skipNoRobots),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const robots = site.robots.parsed;
+        const blockedFor = (url) => {
+            try {
+                const path = pathOf(url);
+                return SEARCH_BOTS.filter((bot) => !robots.allows(bot, path));
+            }
+            catch {
+                return [];
+            }
+        };
+        const listed = new Set();
+        for (const { loc } of site.sitemap?.urls ?? []) {
+            listed.add(norm(loc));
+            const blocked = blockedFor(loc);
+            if (blocked.length)
+                add(loc, t.blockedBySitemap(blocked.join(", ")));
+        }
+        // Without a sitemap, or for pages it does not list: the pages the site links to are meant to be found too.
+        for (const p of site.pages) {
+            const url = p.fetched.publicUrl;
+            if (listed.has(norm(url)))
+                continue;
+            const blocked = blockedFor(url);
+            if (blocked.length)
+                add(url, t.blockedPage(blocked.join(", ")));
+        }
+        return out;
+    },
+};

package/dist/rules/idx/idx-5.d.ts

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

package/dist/rules/idx/idx-5.js

@@ -0,0 +1,24 @@
+/** IDX-5: The site has one version. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel, statusOf } from "../util.js";
+export const idx5 = {
+    id: "IDX-5",
+    group: "IDX",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const { otherHost, slashVariant } = seoOf(site);
+        const host = new URL(site.base).host;
+        // The other host answering 200 on its own is a second copy; no DNS record or an error is not.
+        if (otherHost && otherHost.status === 200 && new URL(otherHost.finalUrl ?? otherHost.publicUrl).host !== host)
+            add("site", t.otherHostAnswers(otherHost.publicUrl, statusOf(otherHost)));
+        const v = slashVariant;
+        if (v && v.fetched.status === 200 && !v.fetched.redirected) {
+            const points = v.canonical && (v.canonical === v.main || v.canonical === v.mainCanonical);
+            if (!points)
+                add(v.main, t.slashDuplicate(rel(v.variant, site.base)));
+        }
+        return out;
+    },
+};

package/dist/rules/idx/idx-6.d.ts

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

package/dist/rules/idx/idx-6.js

@@ -0,0 +1,25 @@
+/** IDX-6: Redirects take one step. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { rel } from "../util.js";
+export const idx6 = {
+    id: "IDX-6",
+    group: "IDX",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const c of seoOf(site).chains) {
+            const path = [c.url, ...c.hops].map((u) => rel(u, site.base)).join(" → ");
+            const url = rel(c.url, site.base);
+            // Reported where the address is used: the linking pages or the sitemap; else on the address itself.
+            const places = c.from.length ? c.from.map((f) => (f === "sitemap.xml" ? `${site.base}/sitemap.xml` : f)) : [c.url];
+            for (const place of places) {
+                if (c.loop)
+                    add(place, t.redirectLoop(url, path), "error");
+                else if (c.hops.length > 1)
+                    add(place, t.redirectChain(url, c.hops.length, path));
+            }
+        }
+        return out;
+    },
+};

package/dist/rules/idx/idx-7.d.ts

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

package/dist/rules/idx/idx-7.js

@@ -0,0 +1,29 @@
+/** IDX-7: noindex does not close the home page and does not contradict the sitemap and canonical. */
+import { finder } from "auditor-engine";
+import { absolute, norm, rel } from "../util.js";
+import { isNoindex } from "./shared.js";
+export const idx7 = {
+    id: "IDX-7",
+    group: "IDX",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const listed = new Set((site.sitemap?.urls ?? []).map((u) => norm(u.loc)));
+        const byUrl = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
+        for (const p of site.pages) {
+            const self = norm(p.fetched.publicUrl);
+            const href = p.canonical ? absolute(p.canonical, p.fetched.publicUrl) : "";
+            const elsewhere = href && norm(href) !== self ? href : "";
+            if (isNoindex(p) && self === norm(`${site.base}/`))
+                add(p.fetched.publicUrl, t.noindexHome, "error");
+            else if (isNoindex(p) && listed.has(self))
+                add(p.fetched.publicUrl, t.noindexInSitemap);
+            if (isNoindex(p) && elsewhere)
+                add(p.fetched.publicUrl, t.noindexWithCanonical(rel(elsewhere, site.base)));
+            const target = elsewhere ? byUrl.get(norm(elsewhere)) : undefined;
+            if (target && isNoindex(target) && !isNoindex(p))
+                add(p.fetched.publicUrl, t.canonicalToNoindex(rel(elsewhere, site.base)));
+        }
+        return out;
+    },
+};

package/dist/rules/idx/idx-8.d.ts

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

package/dist/rules/idx/idx-8.js

@@ -0,0 +1,25 @@
+/** IDX-8: robots.txt does not block CSS and JavaScript. */
+import { finder, isSameSite } from "auditor-engine";
+import { rel } from "../util.js";
+import { pathOf } from "./shared.js";
+export const idx8 = {
+    id: "IDX-8",
+    group: "IDX",
+    level: "warn",
+    applies: (site, t) => (site.robots ? null : t.skipNoRobots),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const o = { target: site.target, base: site.base };
+        const robots = site.robots.parsed;
+        const seen = new Set();
+        for (const p of site.pages)
+            for (const res of p.resources) {
+                if (seen.has(res) || !isSameSite(res, o) || !/\.(css|js|mjs)(\?|$)/i.test(new URL(res).pathname))
+                    continue;
+                seen.add(res);
+                if (!robots.allows("Googlebot", pathOf(res)))
+                    add(p.fetched.publicUrl, t.blockedResource(rel(res, site.base)));
+            }
+        return out;
+    },
+};

package/dist/rules/idx/idx-9.d.ts

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

package/dist/rules/idx/idx-9.js

@@ -0,0 +1,22 @@
+/** IDX-9: The server answers quickly. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { TTFB, median } from "./shared.js";
+export const idx9 = {
+    id: "IDX-9",
+    group: "IDX",
+    level: "info",
+    applies: (site, t) => (seoOf(site).local ? t.skipLocal : null),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const times = seoOf(site).ttfb;
+        if (!times?.length)
+            return out;
+        const ms = median(times);
+        if (ms > TTFB.poor)
+            add(`${site.base}/`, t.slowServer(ms, TTFB.slow), "warn");
+        else if (ms > TTFB.slow)
+            add(`${site.base}/`, t.slowServer(ms, TTFB.slow));
+        return out;
+    },
+};

package/dist/rules/idx/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Indexing (IDX): can search engines reach the pages and are they allowed to keep them in the index.
+ * Status codes and soft 404s, robots.txt health and what it blocks, one version of the site, redirect chains,
+ * noindex that contradicts the sitemap or the canonical, CSS and JavaScript closed to Googlebot, server speed.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const idxRules: SeoRule[];

package/dist/rules/idx/index.js

@@ -0,0 +1,10 @@
+import { idx1 } from "./idx-1.js";
+import { idx2 } from "./idx-2.js";
+import { idx3 } from "./idx-3.js";
+import { idx4 } from "./idx-4.js";
+import { idx5 } from "./idx-5.js";
+import { idx6 } from "./idx-6.js";
+import { idx7 } from "./idx-7.js";
+import { idx8 } from "./idx-8.js";
+import { idx9 } from "./idx-9.js";
+export const idxRules = [idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9];

package/dist/rules/idx/shared.d.ts

@@ -0,0 +1,18 @@
+/** Constants and helpers shared by the IDX checks. */
+import { type Page } from "auditor-engine";
+/** Titles and H1s of «not found» pages that still answer 200. */
+export declare const NOT_FOUND: RegExp;
+/** The search crawlers whose robots.txt groups matter for indexing. */
+export declare const SEARCH_BOTS: string[];
+/** Directives search engines understand; anything else in robots.txt is skipped by them. */
+export declare const ROBOTS_KEYS: Set<string>;
+/** Google reads the first 500 KiB of robots.txt. */
+export declare const ROBOTS_LIMIT: number;
+/** web.dev: a time to first byte up to 0.8 s is good, over 1.8 s is poor. */
+export declare const TTFB: {
+    slow: number;
+    poor: number;
+};
+export declare const pathOf: (url: string) => string;
+export declare const isNoindex: (p: Page) => boolean;
+export declare const median: (xs: number[]) => number;

package/dist/rules/idx/shared.js

@@ -0,0 +1,18 @@
+/** Constants and helpers shared by the IDX checks. */
+import {} from "auditor-engine";
+/** Titles and H1s of «not found» pages that still answer 200. */
+export const NOT_FOUND = /\b(404|not found|page not found|doesn.t exist)\b|не найден|страница не существует|ничего не найдено/i;
+/** The search crawlers whose robots.txt groups matter for indexing. */
+export const SEARCH_BOTS = ["Googlebot", "Bingbot", "Yandex"];
+/** Directives search engines understand; anything else in robots.txt is skipped by them. */
+export const ROBOTS_KEYS = new Set(["user-agent", "allow", "disallow", "sitemap", "crawl-delay", "host", "clean-param"]);
+/** Google reads the first 500 KiB of robots.txt. */
+export const ROBOTS_LIMIT = 500 * 1024;
+/** web.dev: a time to first byte up to 0.8 s is good, over 1.8 s is poor. */
+export const TTFB = { slow: 800, poor: 1800 };
+export const pathOf = (url) => {
+    const u = new URL(url);
+    return u.pathname + u.search;
+};
+export const isNoindex = (p) => /\b(noindex|none)\b/i.test(`${p.metaRobots} ${p.fetched.headers.get("x-robots-tag") ?? ""}`);
+export const median = (xs) => [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];

package/dist/rules/img/img-1.d.ts

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

package/dist/rules/img/img-1.js

@@ -0,0 +1,18 @@
+/** IMG-1: Images have alt text. */
+import { finder } from "auditor-engine";
+import { rel } from "../util.js";
+export 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;
+    },
+};

package/dist/rules/img/img-2.d.ts

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

package/dist/rules/img/img-2.js

@@ -0,0 +1,20 @@
+/** IMG-2: Images have width and height. */
+import { finder } from "auditor-engine";
+import { imgs } from "./shared.js";
+export const img2 = {
+    id: "IMG-2",
+    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) {
+            // Without both, the browser cannot reserve space, and the layout jumps as images arrive (CLS).
+            const list = imgs(p.fetched.body);
+            const unsized = list.filter((i) => !i.width || !i.height);
+            if (unsized.length)
+                add(p.fetched.publicUrl, t.imagesNoSize(unsized.length, list.length, unsized[0].src));
+        }
+        return out;
+    },
+};

package/dist/rules/img/img-3.d.ts

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

package/dist/rules/img/img-3.js

@@ -0,0 +1,24 @@
+/** IMG-3: Lazy loading is used where it helps. */
+import { finder } from "auditor-engine";
+import { FIRST_SCREEN_TEXT, imgs, LAZY_FROM } from "./shared.js";
+export const img3 = {
+    id: "IMG-3",
+    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 list = imgs(p.fetched.body);
+            // The first image on the first screen is often the largest one (LCP): loading it lazily delays it.
+            // One that comes after a screenful of text is further down, where lazy loading is right.
+            const first = list[0];
+            if (first?.loading === "lazy" && first.textBefore < FIRST_SCREEN_TEXT)
+                add(p.fetched.publicUrl, t.firstImageLazy(first.src));
+            // A long page that loads every image at once: the ones below the first screen can wait.
+            if (list.length >= LAZY_FROM && !list.some((i) => i.loading === "lazy"))
+                add(p.fetched.publicUrl, t.noLazyImages(list.length), "info");
+        }
+        return out;
+    },
+};

package/dist/rules/img/img-4.d.ts

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