@contentrain/verify 0.1.0

package/dist/load-KUG-8Ug4.mjs

@@ -0,0 +1,742 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+//#region src/types.ts
+const CHECK_GROUPS = [
+	"identity",
+	"indexing",
+	"status",
+	"international",
+	"structured",
+	"navigation",
+	"assets"
+];
+//#endregion
+//#region src/html.ts
+/** Everything before the first `</head>`, or '' when there is none. */
+function head(html) {
+	const end = html.search(/<\/head\s*>/i);
+	return end === -1 ? "" : html.slice(0, end);
+}
+/** Everything after the first `</head>`, or the whole document when there is none. */
+function body(html) {
+	const end = html.search(/<\/head\s*>/i);
+	return end === -1 ? html : html.slice(end);
+}
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'",
+	"#39": "'"
+};
+function decodeEntities(value) {
+	return value.replace(/&(#39|amp|lt|gt|quot|apos);/g, (_m, name) => ENTITIES[name] ?? _m);
+}
+/**
+* Read one attribute off a single tag's source. Quote-aware; unquoted allowed.
+*
+* The name must be preceded by whitespace, not merely a word boundary: `-` is
+* not a word character, so `\bhref` matches inside `data-href` — and lazy-
+* loading WordPress themes put the real URL in `data-src` and a placeholder in
+* `src` on almost every image.
+*/
+function attr(tag, name) {
+	const match = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i").exec(tag);
+	if (!match) return void 0;
+	return decodeEntities(match[1] ?? match[2] ?? match[3] ?? "");
+}
+/** Every `<tag …>` opening tag in the source, as raw strings. */
+function tags(source, name) {
+	return [...source.matchAll(new RegExp(`<${name}\\b[^>]*>`, "gi"))].map((m) => m[0]);
+}
+/**
+* `<title>` texts from the head. `<svg>` blocks are removed first: a `<title>`
+* inside one is an accessibility label, valid markup, and not the page title —
+* counting it would report a duplicate on every page with an inline icon.
+*/
+function titles(html) {
+	return [...head(html).replace(/<svg\b[\s\S]*?<\/svg\s*>/gi, "").matchAll(/<title\b[^>]*>([\s\S]*?)<\/title\s*>/gi)].map((m) => decodeEntities(m[1] ?? "").trim());
+}
+/** `<meta name="…">` / `<meta property="…">` content, keyed by lowercased key. */
+function metaMap(html) {
+	const found = /* @__PURE__ */ new Map();
+	for (const tag of tags(head(html), "meta")) {
+		const key = (attr(tag, "property") ?? attr(tag, "name"))?.toLowerCase();
+		if (!key) continue;
+		const content = attr(tag, "content") ?? "";
+		found.set(key, [...found.get(key) ?? [], content]);
+	}
+	return found;
+}
+/** `<link>` tags from the head, with `rel` lowercased. */
+function links(html) {
+	const found = [];
+	for (const tag of tags(head(html), "link")) {
+		const rel = attr(tag, "rel")?.toLowerCase();
+		const href = attr(tag, "href");
+		if (!rel || href === void 0) continue;
+		found.push({
+			rel,
+			href,
+			hreflang: attr(tag, "hreflang"),
+			type: attr(tag, "type")
+		});
+	}
+	return found;
+}
+/** Links whose `rel` list contains the given token. */
+function linksRel(html, token) {
+	return links(html).filter((link) => link.rel.split(/\s+/).includes(token));
+}
+/** Every `application/ld+json` block in the document, parsed where possible. */
+function jsonLd(html) {
+	const blocks = [];
+	for (const match of html.matchAll(/<script\b[^>]*\btype\s*=\s*["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script\s*>/gi)) {
+		const raw = (match[1] ?? "").trim();
+		try {
+			blocks.push({
+				raw,
+				value: JSON.parse(raw)
+			});
+		} catch {
+			blocks.push({ raw });
+		}
+	}
+	return blocks;
+}
+/**
+* `@type` values in a JSON-LD block, including those nested in `@graph` —
+* themes commonly ship one graph holding Organization, WebSite and WebPage,
+* and reading only the root would see none of them.
+*/
+function jsonLdTypes(value) {
+	const found = [];
+	const walk = (node) => {
+		if (Array.isArray(node)) {
+			for (const item of node) walk(item);
+			return;
+		}
+		if (!node || typeof node !== "object") return;
+		const record = node;
+		const type = record["@type"];
+		if (typeof type === "string") found.push(type);
+		else if (Array.isArray(type)) {
+			for (const t of type) if (typeof t === "string") found.push(t);
+		}
+		if ("@graph" in record) walk(record["@graph"]);
+	};
+	walk(value);
+	return found;
+}
+/** `href` of every `<a>` in the document body. */
+function anchors(html) {
+	return tags(body(html), "a").map((tag) => attr(tag, "href")).filter((href) => href !== void 0);
+}
+/** Every `<img>` in the document body. */
+function images(html) {
+	return tags(body(html), "img").map((tag) => ({
+		src: attr(tag, "src") ?? "",
+		alt: attr(tag, "alt")
+	})).filter((image) => image.src !== "");
+}
+/** Visible text, roughly: script/style stripped, tags removed, runs collapsed. */
+function text(html) {
+	return body(html).replace(/<(script|style)\b[\s\S]*?<\/\1\s*>/gi, " ").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+}
+/** `<loc>` entries of a sitemap or sitemap index. */
+function sitemapLocations(xml) {
+	return [...xml.matchAll(/<loc>\s*([\s\S]*?)\s*<\/loc>/gi)].map((m) => decodeEntities((m[1] ?? "").trim()));
+}
+//#endregion
+//#region src/url.ts
+const SITE_FALLBACK = "https://contentrain.invalid";
+/** Absolute URL for `href` as seen from `base`, or undefined when unresolvable. */
+function resolve(href, base, site) {
+	try {
+		const origin = site ?? SITE_FALLBACK;
+		const absoluteBase = base.startsWith("http") ? base : new URL(base, origin).href;
+		return new URL(href, absoluteBase).href;
+	} catch {
+		return;
+	}
+}
+/** Whether a resolved URL belongs to the site under test. */
+function isInternal(url, site, extraHosts = []) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return false;
+		if (!site) return parsed.origin === SITE_FALLBACK || extraHosts.includes(parsed.host);
+		return parsed.host === new URL(site).host || extraHosts.includes(parsed.host);
+	} catch {
+		return false;
+	}
+}
+/**
+* The identity of a document: path only, with `index.html` and a trailing
+* slash removed, query and fragment dropped. `/` stays `/`.
+*/
+function identity(url, site) {
+	const full = url.startsWith("http") ? url : resolve(url, "/", site) ?? url;
+	let path;
+	try {
+		path = new URL(full).pathname;
+	} catch {
+		path = full.split(/[?#]/)[0] ?? full;
+	}
+	path = path.replace(/\/index\.html?$/i, "/");
+	if (path.length > 1) path = path.replace(/\/+$/, "");
+	return path === "" ? "/" : path;
+}
+/** Absolute form of a document's own address, when the site origin is known. */
+function absolute(url, site) {
+	if (url.startsWith("http")) return url;
+	if (!site) return void 0;
+	try {
+		return new URL(url, site).href;
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/checks.ts
+const NOT_FOUND_TEXT = /\b(404|not found|page not found|sayfa bulunamad[ıi]|nicht gefunden|introuvable|no se encontr)/i;
+function finding(f) {
+	return f;
+}
+function identityChecks(doc, ctx) {
+	const out = [];
+	const url = doc.url;
+	const group = "identity";
+	const found = titles(doc.html);
+	if (found.every((t) => t === "")) out.push(finding({
+		group,
+		check: "identity.title-missing",
+		severity: "error",
+		url,
+		message: "No non-empty <title> in the head."
+	}));
+	else if (found.length > 1) out.push(finding({
+		group,
+		check: "identity.title-duplicate",
+		severity: "error",
+		url,
+		message: `${found.length} <title> elements in the head — a crawler takes one and it is not defined which.`,
+		detail: found.join(" | ")
+	}));
+	const meta = metaMap(doc.html);
+	if (!meta.get("description")?.[0]?.trim()) out.push(finding({
+		group,
+		check: "identity.description-missing",
+		severity: "warning",
+		url,
+		message: "No meta description."
+	}));
+	const canonicals = linksRel(doc.html, "canonical");
+	if (canonicals.length === 0) out.push(finding({
+		group,
+		check: "identity.canonical-missing",
+		severity: "warning",
+		url,
+		message: "No canonical link."
+	}));
+	else if (canonicals.length > 1) out.push(finding({
+		group,
+		check: "identity.canonical-duplicate",
+		severity: "error",
+		url,
+		message: `${canonicals.length} canonical links — the page tells crawlers two different things about itself.`,
+		detail: canonicals.map((c) => c.href).join(" | ")
+	}));
+	else {
+		const declared = resolve(canonicals[0].href, url, ctx.input.site);
+		const self = absolute(url, ctx.input.site) ?? resolve(url, "/", ctx.input.site);
+		if (declared && self && identity(declared, ctx.input.site) !== identity(self, ctx.input.site)) out.push(finding({
+			group,
+			check: "identity.canonical-mismatch",
+			severity: "error",
+			url,
+			message: "Canonical points at a different page.",
+			detail: `${canonicals[0].href} ≠ ${url}`
+		}));
+	}
+	const missingOg = [
+		"og:title",
+		"og:type",
+		"og:url"
+	].filter((key) => !meta.get(key)?.[0]);
+	if (missingOg.length) out.push(finding({
+		group,
+		check: "identity.open-graph-incomplete",
+		severity: "warning",
+		url,
+		message: `Open Graph incomplete — missing ${missingOg.join(", ")}. Shares render without a card.`
+	}));
+	if (!meta.get("twitter:card")?.[0]) out.push(finding({
+		group,
+		check: "identity.twitter-card-missing",
+		severity: "info",
+		url,
+		message: "No twitter:card."
+	}));
+	return out;
+}
+/** `noindex` as declared by a robots meta or an X-Robots-Tag header. */
+function noindexReason(doc) {
+	const robots = metaMap(doc.html).get("robots")?.join(",") ?? "";
+	if (/\bnoindex\b/i.test(robots)) return `<meta name="robots" content="${robots}">`;
+	const header = doc.headers?.["x-robots-tag"] ?? "";
+	if (/\bnoindex\b/i.test(header)) return `X-Robots-Tag: ${header}`;
+}
+function indexingChecks(doc, ctx) {
+	const out = [];
+	const group = "indexing";
+	const url = doc.url;
+	const reason = noindexReason(doc);
+	if (reason) out.push(finding({
+		group,
+		check: "indexing.noindex",
+		severity: "error",
+		url,
+		message: "Page is marked noindex.",
+		detail: reason
+	}));
+	if (ctx.input.sitemap !== void 0) {
+		if (!new Set(sitemapLocations(ctx.input.sitemap).map((loc) => identity(loc, ctx.input.site))).has(identity(url, ctx.input.site)) && !reason) out.push(finding({
+			group,
+			check: "indexing.sitemap-missing-entry",
+			severity: "warning",
+			url,
+			message: "Indexable page is not in the sitemap."
+		}));
+	}
+	return out;
+}
+/** Sitemap entries pointing at pages the build does not serve. */
+function sitemapStaleChecks(ctx) {
+	if (ctx.input.sitemap === void 0) return [];
+	const out = [];
+	for (const loc of sitemapLocations(ctx.input.sitemap)) {
+		const id = identity(loc, ctx.input.site);
+		if (ctx.byIdentity.has(id)) continue;
+		out.push(finding({
+			group: "indexing",
+			check: "indexing.sitemap-stale-entry",
+			severity: "warning",
+			url: loc,
+			message: "Sitemap lists a page the build does not serve."
+		}));
+	}
+	return out;
+}
+function statusChecks(doc, ctx) {
+	const out = [];
+	const group = "status";
+	const url = doc.url;
+	const status = doc.status ?? 200;
+	const before = ctx.baselineByIdentity.get(identity(url, ctx.input.site));
+	if (before) {
+		const was = before.status ?? 200;
+		if (was !== status) out.push(finding({
+			group,
+			check: "status.mismatch",
+			severity: "error",
+			url,
+			message: `Status changed: ${was} → ${status}.`
+		}));
+	}
+	if (status === 200) {
+		const bodyText = text(doc.html);
+		const title = titles(doc.html)[0] ?? "";
+		if ((NOT_FOUND_TEXT.test(title) || NOT_FOUND_TEXT.test(bodyText.slice(0, 400))) && bodyText.length <= ctx.options.soft404MaxTextLength) out.push(finding({
+			group,
+			check: "status.soft-404",
+			severity: "error",
+			url,
+			message: "Page says it was not found but answers 200.",
+			detail: title || bodyText.slice(0, 120)
+		}));
+	}
+	return out;
+}
+/** Redirect rules: chains, loops, and targets that do not exist. */
+function redirectChecks(ctx) {
+	const rules = ctx.input.redirects;
+	if (!rules?.length) return [];
+	const out = [];
+	const group = "status";
+	const byFrom = new Map(rules.map((rule) => [identity(rule.from, ctx.input.site), rule]));
+	for (const rule of rules) {
+		const seen = new Set([identity(rule.from, ctx.input.site)]);
+		let hops = 1;
+		let target = identity(rule.to, ctx.input.site);
+		while (byFrom.has(target)) {
+			if (seen.has(target)) {
+				out.push(finding({
+					group,
+					check: "status.redirect-loop",
+					severity: "error",
+					url: rule.from,
+					message: "Redirect chain loops.",
+					detail: [...seen, target].join(" → ")
+				}));
+				break;
+			}
+			seen.add(target);
+			target = identity(byFrom.get(target).to, ctx.input.site);
+			hops += 1;
+		}
+		if (hops > ctx.options.maxRedirectHops) out.push(finding({
+			group,
+			check: "status.redirect-chain",
+			severity: "warning",
+			url: rule.from,
+			message: `Redirect chain is ${hops} hops.`,
+			detail: [...seen, target].join(" → ")
+		}));
+		if (!!isInternal(resolve(rule.to, rule.from, ctx.input.site) ?? "", ctx.input.site, ctx.options.internalHosts) && !ctx.served.has(target) && !byFrom.has(target)) out.push(finding({
+			group,
+			check: "status.redirect-target-missing",
+			severity: "error",
+			url: rule.from,
+			message: "Redirect points at a page the build does not serve.",
+			detail: rule.to
+		}));
+	}
+	return out;
+}
+/**
+* hreflang has to be symmetric: if A offers B as its Turkish alternate, B must
+* offer A back. A one-sided declaration is ignored by search engines entirely,
+* so a half-migrated set of alternates is not a partial win — it is nothing.
+*/
+function internationalChecks(ctx) {
+	const out = [];
+	const group = "international";
+	const declared = /* @__PURE__ */ new Map();
+	for (const doc of ctx.input.documents) {
+		const self = identity(doc.url, ctx.input.site);
+		const alternates = /* @__PURE__ */ new Map();
+		for (const link of linksRel(doc.html, "alternate")) {
+			if (!link.hreflang) continue;
+			const target = resolve(link.href, doc.url, ctx.input.site);
+			if (!target) continue;
+			alternates.set(link.hreflang.toLowerCase(), identity(target, ctx.input.site));
+		}
+		if (alternates.size) declared.set(self, alternates);
+	}
+	for (const [self, alternates] of declared) {
+		if (![...alternates.values()].includes(self)) out.push(finding({
+			group,
+			check: "international.hreflang-no-self",
+			severity: "warning",
+			url: self,
+			message: "Page declares hreflang alternates but does not list itself."
+		}));
+		for (const [lang, target] of alternates) {
+			if (target === self) continue;
+			if (!ctx.byIdentity.has(target)) {
+				out.push(finding({
+					group,
+					check: "international.hreflang-unknown-target",
+					severity: "warning",
+					url: self,
+					message: `hreflang="${lang}" points at a page the build does not serve.`,
+					detail: target
+				}));
+				continue;
+			}
+			const back = declared.get(target);
+			if (!back || ![...back.values()].includes(self)) out.push(finding({
+				group,
+				check: "international.hreflang-not-reciprocal",
+				severity: "error",
+				url: self,
+				message: `hreflang="${lang}" names ${target}, which does not name it back — search engines ignore one-sided alternates.`
+			}));
+		}
+	}
+	return out;
+}
+function structuredChecks(doc, ctx) {
+	const out = [];
+	const group = "structured";
+	const url = doc.url;
+	const blocks = jsonLd(doc.html);
+	for (const block of blocks) if (block.value === void 0) out.push(finding({
+		group,
+		check: "structured.jsonld-invalid",
+		severity: "error",
+		url,
+		message: "A JSON-LD block does not parse — the whole block is discarded by consumers.",
+		detail: block.raw.slice(0, 120)
+	}));
+	const before = ctx.baselineByIdentity.get(identity(url, ctx.input.site));
+	if (!before) return out;
+	const had = new Set(jsonLd(before.html).flatMap((block) => jsonLdTypes(block.value)));
+	const has = new Set(blocks.flatMap((block) => jsonLdTypes(block.value)));
+	const lost = [...had].filter((type) => !has.has(type));
+	if (lost.length) out.push(finding({
+		group,
+		check: "structured.type-lost",
+		severity: "warning",
+		url,
+		message: `Structured data types the old page had are gone: ${lost.join(", ")}.`
+	}));
+	return out;
+}
+function navigationChecks(doc, ctx) {
+	const out = [];
+	const group = "navigation";
+	const url = doc.url;
+	const redirected = new Set((ctx.input.redirects ?? []).map((rule) => identity(rule.from, ctx.input.site)));
+	const broken = /* @__PURE__ */ new Set();
+	for (const href of anchors(doc.html)) {
+		if (/^(#|mailto:|tel:|javascript:|data:)/i.test(href)) continue;
+		const target = resolve(href, url, ctx.input.site);
+		if (!target || !isInternal(target, ctx.input.site, ctx.options.internalHosts)) continue;
+		const id = identity(target, ctx.input.site);
+		if (ctx.served.has(id) || redirected.has(id)) continue;
+		broken.add(href);
+	}
+	for (const href of broken) out.push(finding({
+		group,
+		check: "navigation.broken-internal-link",
+		severity: "error",
+		url,
+		message: "Internal link goes nowhere.",
+		detail: href
+	}));
+	for (const token of ["next", "prev"]) for (const link of linksRel(doc.html, token)) {
+		const target = resolve(link.href, url, ctx.input.site);
+		if (!target || !isInternal(target, ctx.input.site, ctx.options.internalHosts)) continue;
+		if (ctx.served.has(identity(target, ctx.input.site))) continue;
+		out.push(finding({
+			group,
+			check: "navigation.pagination-broken",
+			severity: "warning",
+			url,
+			message: `rel="${token}" points at a page the build does not serve.`,
+			detail: link.href
+		}));
+	}
+	const before = ctx.baselineByIdentity.get(identity(url, ctx.input.site));
+	if (before) {
+		const feedRel = (html) => linksRel(html, "alternate").some((link) => /rss|atom|feed/i.test(link.type ?? ""));
+		if (feedRel(before.html) && !feedRel(doc.html)) out.push(finding({
+			group,
+			check: "navigation.feed-lost",
+			severity: "warning",
+			url,
+			message: "The old page advertised a feed; this one does not."
+		}));
+	}
+	return out;
+}
+function assetChecks(doc, ctx) {
+	const out = [];
+	const group = "assets";
+	const url = doc.url;
+	const refs = images(doc.html);
+	const broken = /* @__PURE__ */ new Set();
+	for (const image of refs) {
+		if (/^data:/i.test(image.src)) continue;
+		const target = resolve(image.src, url, ctx.input.site);
+		if (!target || !isInternal(target, ctx.input.site, ctx.options.internalHosts)) continue;
+		if (ctx.served.has(identity(target, ctx.input.site))) continue;
+		broken.add(image.src);
+	}
+	for (const src of broken) out.push(finding({
+		group,
+		check: "assets.broken-image",
+		severity: "error",
+		url,
+		message: "Image does not resolve to anything the build serves.",
+		detail: src
+	}));
+	const noAlt = refs.filter((image) => image.alt === void 0);
+	if (noAlt.length) out.push(finding({
+		group,
+		check: "assets.missing-alt",
+		severity: "warning",
+		url,
+		message: `${noAlt.length} image${noAlt.length === 1 ? "" : "s"} without an alt attribute.`,
+		detail: noAlt.slice(0, 5).map((image) => image.src).join(", ")
+	}));
+	const before = ctx.baselineByIdentity.get(identity(url, ctx.input.site));
+	if (before) {
+		const had = new Map(images(before.html).filter((i) => i.alt).map((i) => [identity(resolve(i.src, before.url, ctx.input.site) ?? i.src, ctx.input.site), i.alt]));
+		const now = new Map(refs.map((i) => [identity(resolve(i.src, url, ctx.input.site) ?? i.src, ctx.input.site), i.alt]));
+		const lost = [...had.keys()].filter((src) => now.has(src) && !now.get(src));
+		if (lost.length) out.push(finding({
+			group,
+			check: "assets.alt-lost",
+			severity: "warning",
+			url,
+			message: `${lost.length} image${lost.length === 1 ? "" : "s"} lost alt text the old page had.`,
+			detail: lost.slice(0, 5).join(", ")
+		}));
+	}
+	return out;
+}
+//#endregion
+//#region src/verify.ts
+const DEFAULTS = {
+	maxRedirectHops: 1,
+	soft404MaxTextLength: 600
+};
+/**
+* Checks that need an input the caller did not supply. Reported rather than
+* silently omitted: a green report over a run that never compared anything is
+* the most dangerous output this package could produce.
+*/
+function absentInputs(input, groups) {
+	const skipped = [];
+	if (!input.baseline) {
+		for (const group of [
+			"status",
+			"structured",
+			"navigation",
+			"assets"
+		]) if (groups.includes(group)) skipped.push({
+			group,
+			reason: "no baseline — parity checks did not run"
+		});
+	}
+	if (input.sitemap === void 0 && groups.includes("indexing")) skipped.push({
+		group: "indexing",
+		reason: "no sitemap — membership checks did not run"
+	});
+	if (!input.redirects?.length && groups.includes("status")) skipped.push({
+		group: "status",
+		reason: "no redirect rules — chain and target checks did not run"
+	});
+	return skipped;
+}
+function buildContext(input) {
+	const options = {
+		...DEFAULTS,
+		...input.options
+	};
+	const byIdentity = new Map(input.documents.map((doc) => [identity(doc.url, input.site), doc]));
+	return {
+		input,
+		options,
+		byIdentity,
+		baselineByIdentity: new Map((input.baseline?.documents ?? []).map((doc) => [identity(doc.url, input.site), doc])),
+		served: new Set([...byIdentity.keys(), ...(input.assets ?? []).map((asset) => identity(asset, input.site))])
+	};
+}
+/**
+* Run the gates over a built site.
+*
+* Nothing is fetched. `input.documents` is the built site as served, and
+* `input.baseline` — when the caller has one — is the site it replaced. Without
+* a baseline every self-check still runs; only the parity checks (status
+* change, lost structured data, lost alt text, lost feed) go quiet, because
+* there is nothing to compare against.
+*/
+function verify(input) {
+	const groups = [...input.groups ?? CHECK_GROUPS];
+	const ctx = buildContext(input);
+	const findings = [];
+	const skipped = absentInputs(input, groups);
+	const run = (group, fn) => {
+		if (!groups.includes(group)) return;
+		findings.push(...fn());
+	};
+	for (const doc of input.documents) {
+		run("identity", () => identityChecks(doc, ctx));
+		run("indexing", () => indexingChecks(doc, ctx));
+		run("status", () => statusChecks(doc, ctx));
+		run("structured", () => structuredChecks(doc, ctx));
+		run("navigation", () => navigationChecks(doc, ctx));
+		run("assets", () => assetChecks(doc, ctx));
+	}
+	run("indexing", () => sitemapStaleChecks(ctx));
+	run("status", () => redirectChecks(ctx));
+	run("international", () => internationalChecks(ctx));
+	const counts = {
+		error: 0,
+		warning: 0,
+		info: 0
+	};
+	for (const item of findings) counts[item.severity] += 1;
+	return {
+		passed: counts.error === 0,
+		findings,
+		counts,
+		documents: input.documents.length,
+		groups,
+		skipped
+	};
+}
+/** A report as lines, most severe first. Used by the CLI and by consumers. */
+function formatReport(report) {
+	const order = [
+		"error",
+		"warning",
+		"info"
+	];
+	const lines = [];
+	for (const severity of order) for (const item of report.findings.filter((f) => f.severity === severity)) {
+		const where = item.url ? ` ${item.url}` : "";
+		const detail = item.detail ? `\n    ${item.detail}` : "";
+		lines.push(`${severity.toUpperCase().padEnd(7)} ${item.check}${where}\n    ${item.message}${detail}`);
+	}
+	for (const { group, reason } of report.skipped) lines.push(`SKIPPED ${group} — ${reason}`);
+	lines.push(`\n${report.documents} document${report.documents === 1 ? "" : "s"} · ${report.counts.error} error · ${report.counts.warning} warning · ${report.counts.info} info · ` + (report.passed ? "PASS" : "FAIL"));
+	return lines.join("\n");
+}
+//#endregion
+//#region src/load.ts
+const DOCUMENT_EXT = /\.html?$/i;
+async function walk(dir, root, files = []) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const full = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			await walk(full, root, files);
+			continue;
+		}
+		files.push(relative(root, full));
+	}
+	return files;
+}
+/**
+* Load a static build as a verification input: every `.html` becomes a
+* document served at its path, everything else becomes an asset.
+*
+* `dist/about/index.html` is served at `/about/`, which `identity()` then
+* reduces to `/about` — the same address a link to `/about/` or
+* `/about/index.html` resolves to.
+*/
+async function loadSiteDirectory(dir, site) {
+	const files = await walk(dir, dir);
+	const documents = [];
+	const assets = [];
+	let sitemap;
+	for (const file of files.toSorted()) {
+		const served = `/${file.split(sep).join("/")}`;
+		if (DOCUMENT_EXT.test(file)) {
+			documents.push({
+				url: served,
+				html: await readFile(join(dir, file), "utf8"),
+				status: 200
+			});
+			continue;
+		}
+		if (/^\/sitemap[^/]*\.xml$/i.test(served)) sitemap = await readFile(join(dir, file), "utf8");
+		assets.push(served);
+	}
+	return {
+		documents,
+		assets,
+		sitemap,
+		site
+	};
+}
+//#endregion
+export { CHECK_GROUPS as i, formatReport as n, verify as r, loadSiteDirectory as t };
+
+//# sourceMappingURL=load-KUG-8Ug4.mjs.map