search-auditor 0.1.0 → 0.2.0

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

@@ -0,0 +1,17 @@
+/** META-8: The snippet is not forbidden. */
+import { finder } from "auditor-engine";
+export const meta8 = {
+    id: "META-8",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const rules = `${p.metaRobots} ${p.fetched.headers.get("x-robots-tag") ?? ""}`;
+            const found = rules.match(/\bnosnippet\b|\bmax-snippet\s*:\s*0\b/i)?.[0];
+            if (found)
+                add(p.fetched.publicUrl, t.noSnippet(found));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,16 @@
+/** META-9: The site has a favicon. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+export const meta9 = {
+    id: "META-9",
+    group: "META",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Checked only when the home page declares no icon: then /favicon.ico must be an image.
+        const f = seoOf(site).favicon;
+        if (f && (f.status !== 200 || !/^image\//i.test(f.headers.get("content-type") ?? "image/")))
+            add(`${site.base}/`, t.noFavicon(f.status ? String(f.status) : (f.error ?? "no answer")));
+        return out;
+    },
+};

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

@@ -0,0 +1,15 @@
+/** Constants and helpers shared by the META checks. */
+export declare const TITLE: {
+    min: number;
+    max: number;
+};
+export declare const DESCRIPTION: {
+    min: number;
+    max: number;
+};
+/** Characters as a person counts them: emoji and letters with marks are one each. */
+export declare const len: (s: string) => number;
+/** Titles that name a template, not a page: what a framework or an editor leaves when nobody writes one. */
+export declare const GENERIC_TITLE: RegExp;
+/** The same text for a person: case, spaces and trailing punctuation do not matter. */
+export declare const plain: (s: string) => string;

package/dist/rules/meta/shared.js

@@ -0,0 +1,9 @@
+/** Constants and helpers shared by the META checks. */
+export const TITLE = { min: 10, max: 60 };
+export const DESCRIPTION = { min: 50, max: 160 };
+/** Characters as a person counts them: emoji and letters with marks are one each. */
+export const len = (s) => [...s.trim()].length;
+/** Titles that name a template, not a page: what a framework or an editor leaves when nobody writes one. */
+export const GENERIC_TITLE = /^(home|home ?page|index|untitled|untitled document|document|new page|page|welcome|react app|vite app|vite \+ react|next\.?js app|create next app|gatsby|nuxt|my site|главная|главная страница|без названия|новая страница|страница|добро пожаловать)$/i;
+/** The same text for a person: case, spaces and trailing punctuation do not matter. */
+export const plain = (s) => s.toLowerCase().replace(/\s+/g, " ").replace(/[.!…]+$/, "").trim();

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

@@ -0,0 +1,8 @@
+/**
+ * Security and HTTPS (SEC): is the site served securely, so browsers do not warn and search engines trust it.
+ * HTTPS with a permanent redirect from http://, a valid certificate that is not about to expire, HSTS, the site's own
+ * addresses on https://, no resources over http:// (mixed content), and basic security headers.
+ * The connection checks need the live site: a local build has no certificate and no real server headers.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const secRules: SeoRule[];

package/dist/rules/sec/index.js

@@ -0,0 +1,8 @@
+import { sec1 } from "./sec-1.js";
+import { sec2 } from "./sec-2.js";
+import { sec3 } from "./sec-3.js";
+import { sec4 } from "./sec-4.js";
+import { sec5 } from "./sec-5.js";
+import { sec6 } from "./sec-6.js";
+import { sec7 } from "./sec-7.js";
+export const secRules = [sec1, sec2, sec3, sec4, sec5, sec6, sec7];

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

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

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

@@ -0,0 +1,21 @@
+/** SEC-1: The site works over HTTPS, and http:// redirects to it. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,17 @@
+/** SEC-2: HTTPS pages do not load anything over http://. */
+import { finder } from "auditor-engine";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** SEC-3: http:// redirects to https:// permanently. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { liveHttps } from "./shared.js";
+export const sec3 = {
+    id: "SEC-3",
+    group: "SEC",
+    level: "warn",
+    applies: (site, t) => (seoOf(site).local ? t.skipLocal : liveHttps(site, false) ? null : t.skipNotHttps),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const hop = seoOf(site).httpHop;
+        // 302 and 307 say «for now»: search engines keep the http:// address and do not pass its weight on.
+        if (hop && (hop.status === 302 || hop.status === 307) && hop.location.startsWith("https://"))
+            add(`http://${new URL(site.base).host}/`, t.temporaryRedirect(hop.status));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,23 @@
+/** SEC-4: The certificate is valid and not about to expire. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { CERT_WARN_DAYS, liveHttps } from "./shared.js";
+export const sec4 = {
+    id: "SEC-4",
+    group: "SEC",
+    level: "error",
+    applies: (site, t) => (seoOf(site).local ? t.skipLocal : liveHttps(site, false) ? null : t.skipNotHttps),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const cert = seoOf(site).cert;
+        if (!cert)
+            return out;
+        if (cert.daysLeft < 0)
+            add("site", t.certExpired(cert.validTo));
+        else if (!cert.valid)
+            add("site", t.certInvalid(cert.error ?? "untrusted"));
+        else if (cert.daysLeft < CERT_WARN_DAYS)
+            add("site", t.certExpiring(cert.daysLeft, cert.validTo), "warn");
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,23 @@
+/** SEC-5: The server asks browsers to use only https (HSTS). */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { HSTS_MIN_AGE, homeOf, liveHttps } from "./shared.js";
+export const sec5 = {
+    id: "SEC-5",
+    group: "SEC",
+    level: "warn",
+    applies: (site, t) => (seoOf(site).local ? t.skipLocal : liveHttps(site, false) ? null : t.skipNotHttps),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const home = homeOf(site);
+        if (!home)
+            return out;
+        const hsts = home.fetched.headers.get("strict-transport-security") ?? "";
+        const age = Number(hsts.match(/max-age\s*=\s*"?(\d+)/i)?.[1] ?? NaN);
+        if (!hsts)
+            add(home.fetched.publicUrl, t.noHsts);
+        else if (!(age >= HSTS_MIN_AGE))
+            add(home.fetched.publicUrl, t.shortHsts(Number.isFinite(age) ? Math.round(age / 86_400) : 0), "info");
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,32 @@
+/** SEC-6: The site's own addresses use https://. */
+import { finder } from "auditor-engine";
+export const sec6 = {
+    id: "SEC-6",
+    group: "SEC",
+    level: "warn",
+    applies: (site, t) => (site.base.startsWith("https://") ? null : t.skipNotHttps),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // The same host over http://: every such address costs a redirect, and a canonical to it names the wrong version.
+        const insecure = `http://${new URL(site.base).host}`;
+        const isInsecure = (u) => !!u && (u === insecure || u.startsWith(insecure + "/"));
+        for (const p of site.pages) {
+            const where = p.fetched.publicUrl;
+            if (isInsecure(p.canonical))
+                add(where, t.httpAddress("canonical", p.canonical));
+            for (const h of p.hreflang)
+                if (isInsecure(h.href))
+                    add(where, t.httpAddress(`hreflang ${h.lang}`, h.href));
+            for (const key of ["url", "image"])
+                if (isInsecure(p.og[key]))
+                    add(where, t.httpAddress(`og:${key}`, p.og[key]));
+            const links = p.links.filter(isInsecure);
+            if (links.length)
+                add(where, t.httpLinks(links.length, links[0]));
+        }
+        const listed = (site.sitemap?.urls ?? []).filter((u) => isInsecure(u.loc));
+        if (listed.length)
+            add(`${site.base}/sitemap.xml`, t.httpInSitemap(listed.length, listed[0].loc));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,26 @@
+/** SEC-7: Basic security headers are set. */
+import { finder } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { homeOf } from "./shared.js";
+export const sec7 = {
+    id: "SEC-7",
+    group: "SEC",
+    level: "info",
+    applies: (site, t) => (seoOf(site).local ? t.skipLocal : null),
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const home = homeOf(site);
+        if (!home)
+            return out;
+        const h = home.fetched.headers;
+        const csp = h.get("content-security-policy") ?? "";
+        const missing = [
+            !/nosniff/i.test(h.get("x-content-type-options") ?? "") && "X-Content-Type-Options: nosniff",
+            !h.get("x-frame-options") && !/frame-ancestors/i.test(csp) && "X-Frame-Options / CSP frame-ancestors",
+            !h.get("referrer-policy") && "Referrer-Policy",
+        ].filter((x) => Boolean(x));
+        if (missing.length)
+            add(home.fetched.publicUrl, t.missingHeaders(missing.join(", ")));
+        return out;
+    },
+};

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

@@ -0,0 +1,10 @@
+/** Constants and helpers shared by the SEC checks. */
+import type { Page, Site } from "auditor-engine";
+/** Half a year: the shortest HSTS max-age that browsers and the preload list treat as a real commitment. */
+export declare const HSTS_MIN_AGE = 15552000;
+/** A certificate that runs out within two weeks is about to take the site down. */
+export declare const CERT_WARN_DAYS = 14;
+/** The home page among the audited ones: its headers stand for the server's. */
+export declare const homeOf: (site: Site) => Page | undefined;
+/** The site is live and on https: the checks of the connection itself apply. */
+export declare const liveHttps: (site: Site, local: boolean) => boolean;

package/dist/rules/sec/shared.js

@@ -0,0 +1,8 @@
+/** Half a year: the shortest HSTS max-age that browsers and the preload list treat as a real commitment. */
+export const HSTS_MIN_AGE = 15_552_000;
+/** A certificate that runs out within two weeks is about to take the site down. */
+export const CERT_WARN_DAYS = 14;
+/** The home page among the audited ones: its headers stand for the server's. */
+export const homeOf = (site) => site.pages.find((p) => new URL(p.fetched.publicUrl).pathname === "/") ?? site.pages[0];
+/** The site is live and on https: the checks of the connection itself apply. */
+export const liveHttps = (site, local) => !local && site.base.startsWith("https://");

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

@@ -0,0 +1,8 @@
+/**
+ * Page structure (STR): can search engines and people read what a page is about, in which language, on any screen.
+ * One H1 with text, heading levels without gaps and without empty headings, a title and an H1 about the same thing,
+ * the page language in <html lang> that matches the text, a viewport for mobile that still allows zoom, the main
+ * content in <main>, and a doctype so browsers do not fall back to quirks mode.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const strRules: SeoRule[];

package/dist/rules/str/index.js

@@ -0,0 +1,11 @@
+import { str1 } from "./str-1.js";
+import { str2 } from "./str-2.js";
+import { str3 } from "./str-3.js";
+import { str4 } from "./str-4.js";
+import { str5 } from "./str-5.js";
+import { str6 } from "./str-6.js";
+import { str7 } from "./str-7.js";
+import { str8 } from "./str-8.js";
+import { str9 } from "./str-9.js";
+import { str10 } from "./str-10.js";
+export const strRules = [str1, str2, str3, str4, str5, str6, str7, str8, str9, str10];

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

@@ -0,0 +1,14 @@
+/** Constants and helpers shared by the STR checks. */
+/** Languages written in Cyrillic: a page in one of them is mostly Cyrillic letters. */
+export declare const CYRILLIC_LANGS: Set<string>;
+/** Languages written in Latin letters that a page may declare. */
+export declare const LATIN_LANGS: Set<string>;
+/** Below this many letters a page says too little to tell its language. */
+export declare const MIN_LETTERS = 200;
+/** Share of Cyrillic among the letters of a text, and how many letters there are. */
+export declare function scriptOf(text: string): {
+    cyrillic: number;
+    letters: number;
+};
+/** Words of four letters and more, cut to five: «engineers» and «engineer», «инженер» and «инженера» match. */
+export declare const stems: (s: string) => Set<string>;

package/dist/rules/str/shared.js

@@ -0,0 +1,16 @@
+/** Constants and helpers shared by the STR checks. */
+/** Languages written in Cyrillic: a page in one of them is mostly Cyrillic letters. */
+export const CYRILLIC_LANGS = new Set(["ru", "uk", "be", "bg", "sr", "mk", "kk", "ky", "tg", "mn"]);
+/** Languages written in Latin letters that a page may declare. */
+export const LATIN_LANGS = new Set(["en", "de", "fr", "es", "it", "pt", "nl", "pl", "cs", "sk", "sv", "no", "nb", "da", "fi", "tr", "ro", "hu", "id", "vi", "lv", "lt", "et", "hr", "sl", "az", "uz"]);
+/** Below this many letters a page says too little to tell its language. */
+export const MIN_LETTERS = 200;
+/** Share of Cyrillic among the letters of a text, and how many letters there are. */
+export function scriptOf(text) {
+    const cyr = (text.match(/[Ѐ-ӿ]/g) ?? []).length;
+    const lat = (text.match(/[A-Za-zÀ-ɏ]/g) ?? []).length;
+    const letters = cyr + lat;
+    return { cyrillic: letters ? cyr / letters : 0, letters };
+}
+/** Words of four letters and more, cut to five: «engineers» and «engineer», «инженер» and «инженера» match. */
+export const stems = (s) => new Set((s.toLowerCase().match(/[\p{L}\p{N}]{4,}/gu) ?? []).map((w) => w.slice(0, 5)));

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

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

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

@@ -0,0 +1,17 @@
+/** STR-1: One H1 per page. */
+import { finder } from "auditor-engine";
+export 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;
+    },
+};

package/dist/rules/str/str-10.d.ts

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

package/dist/rules/str/str-10.js

@@ -0,0 +1,15 @@
+/** STR-10: The page starts with <!doctype html>. */
+import { finder } from "auditor-engine";
+export const str10 = {
+    id: "STR-10",
+    group: "STR",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Comments and a byte order mark may come first; anything else puts the browser in quirks mode.
+        for (const p of site.pages)
+            if (!/^()?(\s|<!--[\s\S]*?-->)*<!doctype\s+html/i.test(p.fetched.body))
+                add(p.fetched.publicUrl, t.noDoctype);
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,19 @@
+/** STR-2: Heading levels do not skip. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,14 @@
+/** STR-3: The page declares its language. */
+import { finder } from "auditor-engine";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,14 @@
+/** STR-4: Pages are set up for mobile. */
+import { finder } from "auditor-engine";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,19 @@
+/** STR-5: Headings are not empty. */
+import { finder } from "auditor-engine";
+export const str5 = {
+    id: "STR-5",
+    group: "STR",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            // An H1 that is only a logo reads as no H1 at all: the alt text of an image is not heading text.
+            if (p.h1.length && p.h1.every((h) => !h.trim()))
+                add(p.fetched.publicUrl, t.emptyH1);
+            const empty = p.headingsAll.filter((h) => h.level > 1 && !h.text.trim());
+            if (empty.length)
+                add(p.fetched.publicUrl, t.emptyHeadings(empty.length, [...new Set(empty.map((h) => `H${h.level}`))].join(", ")), "info");
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,22 @@
+/** STR-6: The title and the H1 are about the same thing. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+import { stems } from "./shared.js";
+export const str6 = {
+    id: "STR-6",
+    group: "STR",
+    level: "info",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const h1 = p.h1.find((h) => h.trim()) ?? "";
+            if (!h1 || !p.title.trim())
+                continue;
+            const [a, b] = [stems(p.title), stems(h1)];
+            // Not one word in common: Google then often rewrites the title in the results, from the H1 or the text.
+            if (a.size && b.size && ![...a].some((w) => b.has(w)))
+                add(p.fetched.publicUrl, t.titleH1Apart(short(p.title, 50), short(h1, 50)));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** STR-7: The page can be zoomed on a phone. */
+import { finder } from "auditor-engine";
+export const str7 = {
+    id: "STR-7",
+    group: "STR",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const v = p.viewport;
+            const max = Number(v.match(/maximum-scale\s*=\s*([\d.]+)/i)?.[1] ?? NaN);
+            // Zoom up to 2× at least: below that, people with weaker sight cannot read the page.
+            if (/user-scalable\s*=\s*(no|0)\b/i.test(v) || max < 2)
+                add(p.fetched.publicUrl, t.noZoom(v));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,24 @@
+/** STR-8: <html lang> matches the language of the text. */
+import { finder } from "auditor-engine";
+import { CYRILLIC_LANGS, LATIN_LANGS, MIN_LETTERS, scriptOf } from "./shared.js";
+export const str8 = {
+    id: "STR-8",
+    group: "STR",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const lang = p.htmlLang.trim().toLowerCase().split(/[-_]/)[0] ?? "";
+            const { cyrillic, letters } = scriptOf(p.text);
+            if (!lang || letters < MIN_LETTERS)
+                continue;
+            // Only a clear mismatch: a Cyrillic page declared as a Latin-script language, or the other way round.
+            const percent = Math.round(cyrillic * 100);
+            if (LATIN_LANGS.has(lang) && cyrillic > 0.7)
+                add(p.fetched.publicUrl, t.langMismatch(lang, t.scriptCyrillic, percent));
+            if (CYRILLIC_LANGS.has(lang) && cyrillic < 0.3)
+                add(p.fetched.publicUrl, t.langMismatch(lang, t.scriptLatin, 100 - percent));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,14 @@
+/** STR-9: The main content sits in <main>. */
+import { finder } from "auditor-engine";
+export const str9 = {
+    id: "STR-9",
+    group: "STR",
+    level: "info",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages)
+            if (!/<main\b|\brole\s*=\s*["']?main\b/i.test(p.fetched.body))
+                add(p.fetched.publicUrl, t.noMain);
+        return out;
+    },
+};

package/dist/rules/util.d.ts

@@ -1,4 +1,4 @@
-import type { Fetched, Rule } from "ai-search-auditor";
+import type { Fetched, Rule } from "auditor-engine";
 import type { SeoMessages } from "../i18n/index.ts";
 import type { SearchConfig } from "../types.ts";
 /** An SEO check: same contract as the AI search rules, with its own messages and config. */

package/dist/trace.d.ts

@@ -0,0 +1,20 @@
+import { type Origins } from "auditor-engine";
+import type { Certificate } from "./types.ts";
+/**
+ * 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 declare function trace(url: string, o: Origins, timeoutMs?: number): Promise<{
+    hops: string[];
+    loop: boolean;
+    status: number;
+}>;
+/** Time to the response headers, in ms: what a crawler waits before the page starts to arrive. */
+export declare function timeToFirstByte(url: string, o: Origins, timeoutMs?: number): Promise<number | null>;
+/** The first answer to a URL without following redirects: its status and Location. */
+export declare function firstHop(url: string, timeoutMs?: number): Promise<{
+    status: number;
+    location: string;
+} | null>;
+/** Opens a TLS connection to the host and reads its certificate: trusted or not, and how long it has left. */
+export declare function certificateOf(host: string, timeoutMs?: number): Promise<Certificate | null>;