search-auditor 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1,6 +1,4 @@
-import { type CrawlOptions, type Lang, type Report } from "ai-search-auditor";
-import { collect } from "./collect.ts";
-import { type SeoMessages } from "./i18n/index.ts";
+import { type CrawlOptions, type Lang, type Report } from "auditor-engine";
 import type { SearchConfig } from "./types.ts";
 export type { Probe, SearchConfig, SeoExtras, SeoSite } from "./types.ts";
 export type { SeoMessages, SeoRuleId } from "./i18n/index.ts";
@@ -8,7 +6,7 @@ export type { SeoRule } from "./rules/index.ts";
 export { SEO_LANGS, seoMessages } from "./i18n/index.ts";
 export { SEO_GROUPS, seoRules } from "./rules/index.ts";
 export { collect, seoOf, type CollectOptions } from "./collect.ts";
-export { toMarkdown, type Report } from "ai-search-auditor";
+export { toMarkdown, type Report } from "auditor-engine";
 export declare const TOOL: {
     name: string;
     url: string;
@@ -16,143 +14,6 @@ export declare const TOOL: {
 export declare const defaultConfig: SearchConfig;
 /** SEO group ids and names in checklist order. */
 export declare const seoGroups: (lang: Lang) => Record<string, string>;
-/**
- * The SEO checks as a plugin for another runner (ai-search-auditor --seo): everything it needs to run them on its own
- * crawl and render them in its report.
- */
-export declare const seoPlugin: {
-    name: string;
-    rules: import("./rules/util.ts").SeoRule[];
-    groups: (lang: Lang) => Record<string, string>;
-    texts: (lang: Lang) => {
-        "IDX-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "IDX-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "CAN-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "CAN-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "CAN-3": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "MAP-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "MAP-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "MAP-3": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "META-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "META-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "META-3": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "STR-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "STR-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "STR-3": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "STR-4": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "LNK-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "LNK-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "IMG-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "DATA-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "LANG-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "LANG-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "LANG-3": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "SEC-1": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-        "SEC-2": {
-            title: string;
-            fix: string;
-            impact: string;
-        };
-    };
-    messages: (lang: Lang) => SeoMessages["m"];
-    section: (lang: Lang) => string;
-    collect: typeof collect;
-    defaults: {
-        maxLinks: number;
-    };
-};
 export interface AuditSearchOptions {
     base?: string;
     config?: Partial<SearchConfig>;
@@ -160,8 +21,5 @@ export interface AuditSearchOptions {
     urls?: string[];
     log?: CrawlOptions["log"];
 }
-/**
- * One crawl, two rule sets: classic search (this package) and AI search (ai-search-auditor). The report has an overall
- * score and one per part, and renders with ai-search-auditor's toMarkdown.
- */
+/** Crawls the site, collects what the classic search checks need besides the pages and runs them. */
 export declare function auditSearch(target: string, opts?: AuditSearchOptions): Promise<Report>;

package/dist/index.js

@@ -1,76 +1,37 @@
-import { crawl, defaultConfig as aiDefaults, messages as aiMessages, rules as aiRules, runRules, scoreOf, } from "ai-search-auditor";
+import { crawl, defaultConfig as engineDefaults, runRules, scoreOf } from "auditor-engine";
 import { collect } from "./collect.js";
 import { seoMessages } from "./i18n/index.js";
 import { SEO_GROUPS, seoRules } from "./rules/index.js";
 export { SEO_LANGS, seoMessages } from "./i18n/index.js";
 export { SEO_GROUPS, seoRules } from "./rules/index.js";
 export { collect, seoOf } from "./collect.js";
-export { toMarkdown } from "ai-search-auditor";
+export { toMarkdown } from "auditor-engine";
 export const TOOL = { name: "search-auditor", url: "https://github.com/a-bibikov/search-auditor" };
-export const defaultConfig = { ...aiDefaults, maxLinks: 100, ai: true };
+export const defaultConfig = { ...engineDefaults, maxLinks: 100 };
 /** SEO group ids and names in checklist order. */
 export const seoGroups = (lang) => {
     const g = seoMessages(lang).groups;
     return Object.fromEntries(SEO_GROUPS.map((id) => [id, g[id]]));
 };
-/**
- * The SEO checks as a plugin for another runner (ai-search-auditor --seo): everything it needs to run them on its own
- * crawl and render them in its report.
- */
-export const seoPlugin = {
-    name: TOOL.name,
-    rules: seoRules,
-    groups: seoGroups,
-    texts: (lang) => seoMessages(lang).rules,
-    messages: (lang) => seoMessages(lang).m,
-    section: (lang) => seoMessages(lang).report.classic,
-    collect,
-    defaults: { maxLinks: defaultConfig.maxLinks },
-};
-/** Same grade scale as ai-search-auditor: an A needs at least two thirds of the checks to have run. */
-function gradeOf(score, coverage) {
-    const grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
-    return grade === "A" && coverage < 2 / 3 ? { grade: "B", capped: true } : { grade, capped: false };
-}
-/**
- * One crawl, two rule sets: classic search (this package) and AI search (ai-search-auditor). The report has an overall
- * score and one per part, and renders with ai-search-auditor's toMarkdown.
- */
+/** Crawls the site, collects what the classic search checks need besides the pages and runs them. */
 export async function auditSearch(target, opts = {}) {
     const config = { ...defaultConfig, ...opts.config };
-    const st = seoMessages(config.lang);
-    const at = aiMessages(config.lang);
+    const t = seoMessages(config.lang);
     const site = await crawl(target, opts.base, { maxPages: config.maxPages, urls: opts.urls, log: opts.log });
     await collect(site, { maxLinks: config.maxLinks, log: opts.log });
-    const pages = site.pages.length;
-    const seo = runRules(site, seoRules, config, st.m, st.rules);
-    const ai = config.ai ? runRules(site, aiRules, config, at.m, at.rules) : null;
-    const parts = [{ name: st.report.classic, run: seo }, ...(ai ? [{ name: st.report.ai, run: ai }] : [])];
-    const sections = parts.map(({ name, run }) => {
-        const s = scoreOf(run.findings, { pages, checked: run.checked, total: run.total });
-        return { name, score: s.score, grade: s.grade, checked: s.checked, total: s.total };
-    });
-    const findings = parts.flatMap((p) => p.run.findings);
-    const checked = parts.reduce((n, p) => n + p.run.checked, 0);
-    const total = parts.reduce((n, p) => n + p.run.total, 0);
-    // The overall score is the mean of the parts, so two parts at 80 make 80, not the sum of both parts' penalties.
-    const overall = scoreOf(findings, { pages, checked, total });
-    const score = Math.round(sections.reduce((n, s) => n + s.score, 0) / sections.length);
-    const grade = gradeOf(score, total ? checked / total : 1);
+    // Findings about sitemap entries or linked pages beyond the sample do not count as a share of the audited pages.
+    const audited = site.pages.map((p) => p.fetched.publicUrl);
+    const run = runRules(site, seoRules, config, t.m, t.rules);
     return {
         site: site.base,
         lang: config.lang,
         checkedAt: new Date().toISOString(),
-        pages: site.pages.map((p) => p.fetched.publicUrl),
-        ...overall,
-        score,
-        grade: grade.grade,
-        capped: grade.capped,
-        findings,
-        rules: parts.flatMap((p) => p.run.rules),
-        groups: { ...seoGroups(config.lang), ...(ai ? at.report.groups : {}) },
-        ...(ai ? { sections } : {}),
-        chrome: { title: st.report.title, clean: st.report.clean, footer: st.report.footer },
+        pages: audited,
+        ...scoreOf(run.findings, { pages: site.pages.length, audited, checked: run.checked, total: run.total }),
+        findings: run.findings,
+        rules: run.rules,
+        groups: seoGroups(config.lang),
+        chrome: { title: t.report.title, clean: t.report.clean, footer: t.report.footer },
         tool: TOOL,
     };
 }

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

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

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

@@ -0,0 +1,14 @@
+/** CAN-1: Every page has a canonical. */
+import { finder } from "auditor-engine";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,20 @@
+/** CAN-2: The canonical is an absolute address on this site. */
+import { finder, isSameSite } from "auditor-engine";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,32 @@
+/** CAN-3: The canonical leads to a page that works. */
+import { finder, isSameSite } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { absolute, norm, rel, statusOf } from "../util.js";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,18 @@
+/** CAN-4: There is one canonical per page. */
+import { finder } from "auditor-engine";
+import { canonicalTags } from "./shared.js";
+export const can4 = {
+    id: "CAN-4",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        // Two canonicals that disagree make Google ignore both; the same one twice is untidy but harmless.
+        for (const p of site.pages) {
+            const hrefs = [...new Set(canonicalTags(p.fetched.body).map((c) => c.href))];
+            if (hrefs.length > 1)
+                add(p.fetched.publicUrl, t.manyCanonicals(hrefs.length, hrefs.join(", ")));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,17 @@
+/** CAN-5: The canonical sits in <head>. */
+import { finder } from "auditor-engine";
+import { canonicalTags } from "./shared.js";
+export const can5 = {
+    id: "CAN-5",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const inBody = canonicalTags(p.fetched.body).find((c) => !c.inHead);
+            if (inBody)
+                add(p.fetched.publicUrl, t.canonicalInBody(inBody.href));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,22 @@
+/** CAN-6: The canonical in the HTML and in the HTTP header agree. */
+import { finder } from "auditor-engine";
+import { absolute, rel } from "../util.js";
+import { headerCanonical } from "./shared.js";
+export const can6 = {
+    id: "CAN-6",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        for (const p of site.pages) {
+            const header = headerCanonical(p);
+            if (!header || !p.canonical)
+                continue;
+            const fromHeader = absolute(header, p.fetched.publicUrl);
+            const fromHtml = absolute(p.canonical, p.fetched.publicUrl);
+            if (fromHeader !== fromHtml)
+                add(p.fetched.publicUrl, t.canonicalConflict(rel(fromHtml, site.base), rel(fromHeader, site.base)));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,32 @@
+/** CAN-7: A canonical leads straight to the main page, not through another canonical. */
+import { finder, isSameSite } from "auditor-engine";
+import { seoOf } from "../../collect.js";
+import { absolute, norm, rel } from "../util.js";
+export const can7 = {
+    id: "CAN-7",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const o = { target: site.target, base: site.base };
+        // The canonical each target declares: from the crawl for sampled pages, from collect() for the others.
+        const declared = new Map();
+        // A target that redirects is CAN-3's finding: what the page after the redirect declares says nothing new.
+        for (const p of site.pages)
+            if (!p.fetched.redirected)
+                declared.set(norm(p.fetched.publicUrl), p.canonical ? absolute(p.canonical, p.fetched.publicUrl) : "");
+        for (const [url, probe] of seoOf(site).canonicals)
+            if (probe.canonical !== undefined && !probe.redirected)
+                declared.set(url, probe.canonical);
+        for (const p of site.pages) {
+            const self = norm(p.fetched.publicUrl);
+            const target = p.canonical ? absolute(p.canonical, p.fetched.publicUrl) : "";
+            if (!target || norm(target) === self || !isSameSite(target, o))
+                continue;
+            const next = declared.get(norm(target));
+            if (next && norm(next) !== norm(target) && norm(next) !== self)
+                add(p.fetched.publicUrl, t.canonicalChain(rel(target, site.base), rel(next, site.base)));
+        }
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,23 @@
+/** CAN-8: An address with UTM parameters names the clean address as canonical. */
+import { finder } from "auditor-engine";
+import { seoOf, UTM } from "../../collect.js";
+import { norm, rel } from "../util.js";
+export const can8 = {
+    id: "CAN-8",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const utm = seoOf(site).utm;
+        // A page without any canonical is CAN-1's finding; this one is about a canonical that copies the parameters.
+        const main = site.pages.find((p) => p.fetched.publicUrl === utm?.page);
+        if (!utm || utm.status !== 200 || !main?.canonical)
+            return out;
+        const tagged = UTM.split("&")[0];
+        if (!utm.canonical)
+            add(utm.page, t.utmNoCanonical(rel(utm.url, site.base)));
+        else if (utm.canonical.includes(tagged) || norm(utm.canonical) === norm(utm.url))
+            add(utm.page, t.utmCanonical(rel(utm.url, site.base)));
+        return out;
+    },
+};

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

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

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

@@ -0,0 +1,24 @@
+/** CAN-9: A language version does not name another language as canonical. */
+import { finder } from "auditor-engine";
+import { absolute, norm, rel } from "../util.js";
+import { langOf } from "./shared.js";
+export const can9 = {
+    id: "CAN-9",
+    group: "CAN",
+    level: "warn",
+    run(site, _c, t) {
+        const { out, add } = finder(this);
+        const byUrl = new Map(site.pages.map((p) => [norm(p.fetched.publicUrl), p]));
+        for (const p of site.pages) {
+            const href = p.canonical ? absolute(p.canonical, p.fetched.publicUrl) : "";
+            const target = href ? byUrl.get(norm(href)) : undefined;
+            if (!target || target === p)
+                continue;
+            const [from, to] = [langOf(p), langOf(target)];
+            // Translations are separate pages joined by hreflang; a canonical across languages drops this one from search.
+            if (from && to && from !== to)
+                add(p.fetched.publicUrl, t.canonicalOtherLanguage(rel(href, site.base), to, from));
+        }
+        return out;
+    },
+};

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

@@ -0,0 +1,7 @@
+/**
+ * Canonical (CAN): does every page name its main address, so search engines rank that one and not a copy.
+ * A canonical on every page, one per page and in <head>, an absolute address on this site that answers 200,
+ * the same in the HTML and the HTTP header, without chains, ignoring UTM parameters, and never across languages.
+ */
+import type { SeoRule } from "../util.ts";
+export declare const canRules: SeoRule[];

package/dist/rules/can/index.js

@@ -0,0 +1,10 @@
+import { can1 } from "./can-1.js";
+import { can2 } from "./can-2.js";
+import { can3 } from "./can-3.js";
+import { can4 } from "./can-4.js";
+import { can5 } from "./can-5.js";
+import { can6 } from "./can-6.js";
+import { can7 } from "./can-7.js";
+import { can8 } from "./can-8.js";
+import { can9 } from "./can-9.js";
+export const canRules = [can1, can2, can3, can4, can5, can6, can7, can8, can9];

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

@@ -0,0 +1,11 @@
+/** Constants and helpers shared by the CAN checks. */
+import type { Page } from "auditor-engine";
+/** Every <link rel="canonical"> in the raw HTML, with its href and whether it sits in <head>. */
+export declare function canonicalTags(html: string): {
+    href: string;
+    inHead: boolean;
+}[];
+/** The canonical from the HTTP Link header (`Link: <url>; rel="canonical"`), or "". */
+export declare function headerCanonical(page: Page): string;
+/** The language of a page without the region: «ru» for ru-RU. Empty when the page does not say. */
+export declare const langOf: (p: Page) => string;

package/dist/rules/can/shared.js

@@ -0,0 +1,26 @@
+/** Every <link rel="canonical"> in the raw HTML, with its href and whether it sits in <head>. */
+export function canonicalTags(html) {
+    // Where <head> ends: the closing tag, or the first <body> when the closing tag is left out.
+    const end = html.search(/<\/head\s*>|<body[\s>]/i);
+    const tags = [];
+    for (const m of html.matchAll(/<link\b[^>]*>/gi)) {
+        const tag = m[0];
+        if (!/\brel\s*=\s*["']?[^"'>]*\bcanonical\b/i.test(tag))
+            continue;
+        const href = tag.match(/\bhref\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i);
+        tags.push({ href: (href?.[1] ?? href?.[2] ?? href?.[3] ?? "").trim(), inHead: end < 0 || m.index < end });
+    }
+    return tags;
+}
+/** The canonical from the HTTP Link header (`Link: <url>; rel="canonical"`), or "". */
+export function headerCanonical(page) {
+    const link = page.fetched.headers.get("link") ?? "";
+    for (const part of link.split(/,(?=\s*<)/)) {
+        const m = part.match(/<([^>]+)>\s*;(.*)/);
+        if (m && /\brel\s*=\s*"?canonical"?/i.test(m[2]))
+            return m[1].trim();
+    }
+    return "";
+}
+/** The language of a page without the region: «ru» for ru-RU. Empty when the page does not say. */
+export const langOf = (p) => p.htmlLang.trim().toLowerCase().split(/[-_]/)[0] ?? "";

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

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

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

@@ -0,0 +1,16 @@
+/** DATA-1: Structured data has no syntax errors. */
+import { finder } from "auditor-engine";
+import { short } from "../util.js";
+export 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;
+    },
+};

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

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

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

@@ -0,0 +1,25 @@
+/** DATA-2: Every block has @context and every entity a @type. */
+import { finder } from "auditor-engine";
+import { blocks, isReference, topNodes, typesOf } from "./shared.js";
+export const data2 = {
+    id: "DATA-2",
+    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) {
+            for (const block of blocks(p.fetched.body)) {
+                const tops = Array.isArray(block) ? block : [block];
+                // @context may sit on the block or on each item of an array.
+                const context = tops.every((b) => b && typeof b === "object" && /schema\.org/i.test(JSON.stringify(b["@context"] ?? "")));
+                if (!context)
+                    add(p.fetched.publicUrl, t.noContext);
+                const untyped = topNodes(block).filter((n) => !isReference(n) && !typesOf(n).length);
+                if (untyped.length)
+                    add(p.fetched.publicUrl, t.noType(untyped.length));
+            }
+        }
+        return out;
+    },
+};

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

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