eaa-kit 0.2.0 → 0.3.0

package/dist/audit-D4gju2BT.js

@@ -1,949 +0,0 @@
-import { n as IMPACT_LEVELS, r as countAtOrAbove } from "./impact-DvgBjupx.js";
-import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import pc from "picocolors";
-import { glob } from "tinyglobby";
-/** Whether this element looks like one component rendered on many pages. */
-function isShared(element) {
-	return element.pages.length >= 3;
-}
-/**
-* Fold a run's violations into one entry per rule, and one per element within it.
-*
-* Accepted violations are not included: a baseline moves them out of what fails
-* the build, and this is a view of what fails.
-*/
-function groupIssues(audits) {
-	const byRule = /* @__PURE__ */ new Map();
-	for (const audit of audits) for (const finding of audit.violations) {
-		let issue = byRule.get(finding.ruleId);
-		if (issue === void 0) {
-			issue = {
-				ruleId: finding.ruleId,
-				help: finding.help,
-				impact: finding.impact ?? null,
-				successCriteria: finding.successCriteria,
-				enClauses: finding.enClauses,
-				helpUrl: finding.helpUrl,
-				elements: [],
-				pages: [],
-				occurrences: 0
-			};
-			byRule.set(finding.ruleId, issue);
-		}
-		if (!issue.pages.includes(audit.relativePath)) issue.pages.push(audit.relativePath);
-		const nodes = finding.nodes.length > 0 ? finding.nodes.map((node) => ({
-			selector: node.target.join(" "),
-			html: node.html
-		})) : [{
-			selector: "",
-			html: ""
-		}];
-		for (const node of nodes) {
-			issue.occurrences += 1;
-			const fingerprint = elementFingerprint(finding.ruleId, node.selector, node.html);
-			const existing = issue.elements.find((element) => element.fingerprint === fingerprint);
-			if (existing) {
-				if (!existing.pages.includes(audit.relativePath)) existing.pages.push(audit.relativePath);
-				continue;
-			}
-			issue.elements.push({
-				fingerprint,
-				selector: node.selector,
-				html: node.html,
-				pages: [audit.relativePath]
-			});
-		}
-	}
-	const issues = [...byRule.values()];
-	for (const issue of issues) {
-		issue.pages.sort();
-		for (const element of issue.elements) element.pages.sort();
-		issue.elements.sort(byReachThenSelector);
-	}
-	issues.sort(bySeverityThenReach);
-	return issues;
-}
-/** Widest reach first, then by selector so two runs agree. */
-function byReachThenSelector(a, b) {
-	return b.pages.length - a.pages.length || a.selector.localeCompare(b.selector);
-}
-/**
-* Worst first, then widest reach, then by rule id.
-*
-* An unclassified impact sorts with the most severe, on the same reasoning as
-* `--fail-on`: not knowing how bad a barrier is is not evidence that it is mild.
-*/
-function bySeverityThenReach(a, b) {
-	const rank = (issue) => issue.impact === null ? IMPACT_LEVELS.length : IMPACT_LEVELS.indexOf(issue.impact);
-	return rank(b) - rank(a) || b.pages.length - a.pages.length || a.ruleId.localeCompare(b.ruleId);
-}
-//#endregion
-//#region src/audit/report/console.ts
-const DEFAULT_MAX_NODES = 3;
-const MIN_WIDTH = 40;
-const MAX_WIDTH = 100;
-/**
-* Human-readable audit report.
-*
-* Deliberately not a columnar table: rule ids, help text and selectors are all
-* variable-length, so a real table either wraps into soup or scrolls sideways
-* on a narrow terminal. Everything is left-aligned and indented instead, and
-* every line is assembled from segments trimmed as a group, so the width
-* guarantee holds however long a selector or rule id turns out to be.
-*
-* Returns a string rather than printing, so the format is testable.
-*/
-function formatConsoleReport(audits, options = {}) {
-	const ctx = context(options);
-	const lines = [
-		"",
-		...headerLines(audits, ctx),
-		""
-	];
-	lines.push(...issuesSection(audits, ctx));
-	if (options.perPage) {
-		lines.push("", ...legendLines(ctx), "");
-		for (const audit of audits) lines.push(...pageSection(audit, ctx));
-	}
-	lines.push(...summary(audits, ctx));
-	return lines.join("\n");
-}
-function context(options) {
-	const detected = process.stdout.columns ?? 80;
-	const width = Math.min(Math.max(options.width ?? detected, MIN_WIDTH), MAX_WIDTH);
-	const c = pc.createColors(options.color ?? pc.isColorSupported);
-	const unicode = supportsUnicode();
-	return {
-		width,
-		maxNodes: options.maxNodes ?? DEFAULT_MAX_NODES,
-		failOn: options.failOn ?? "serious",
-		sourceFor: options.sourceFor ?? (() => void 0),
-		c,
-		symbol: (kind) => {
-			switch (kind) {
-				case "violation": return unicode ? "✗" : "x";
-				case "review": return "?";
-				case "blind": return unicode ? "·" : "-";
-				case "clean": return unicode ? "✓" : "+";
-				case "error": return "!";
-			}
-		}
-	};
-}
-/** cmd.exe and older Windows consoles render these glyphs as mojibake. */
-function supportsUnicode() {
-	if (process.platform !== "win32") return true;
-	return Boolean(process.env["WT_SESSION"] || process.env["TERM_PROGRAM"] || process.env["ConEmuTask"] || process.env["TERM"]);
-}
-/**
-* Joins segments into one line, trimming the group to the terminal width.
-* Colour codes are applied after trimming, so they never count towards it.
-*/
-function render(ctx, segments) {
-	let remaining = ctx.width;
-	const parts = [];
-	for (const segment of segments) {
-		if (remaining <= 0) break;
-		const text = segment.text.length <= remaining ? segment.text : `${segment.text.slice(0, Math.max(remaining - 1, 0))}…`;
-		remaining -= text.length;
-		parts.push(segment.paint ? segment.paint(text) : text);
-	}
-	return parts.join("");
-}
-function headerLines(audits, ctx) {
-	const engineLabel = (audits[0]?.engine ?? "jsdom") === "browser" ? "chromium" : "jsdom (browserless)";
-	const pageCount = `${audits.length} ${plural(audits.length, "page")}`;
-	return [render(ctx, [{
-		text: "eaa-kit audit",
-		paint: ctx.c.bold
-	}, {
-		text: ` ${pageCount} · ${engineLabel}`,
-		paint: ctx.c.dim
-	}])];
-}
-/**
-* What the per-page counts mean.
-*
-* Only with the per-page listing, which is the only place those words appear:
-* "not applicable" reads like good news unless it is spelled out, and printing
-* the gloss for a section that is not there is noise.
-*/
-function legendLines(ctx) {
-	return [render(ctx, [{
-		text: "passed = checked and met · not applicable = nothing to check",
-		paint: ctx.c.dim
-	}])];
-}
-function pageSection(audit, ctx) {
-	const lines = [render(ctx, [{
-		text: audit.relativePath,
-		paint: ctx.c.underline
-	}])];
-	if (audit.error) {
-		lines.push(render(ctx, [{
-			text: `  ${ctx.symbol("error")} not audited: `,
-			paint: ctx.c.red
-		}, { text: audit.error }]), "");
-		return lines;
-	}
-	for (const finding of sortByImpact(audit.violations)) lines.push(...violationLines(finding, ctx));
-	for (const finding of audit.incomplete.filter((item) => item.reason === "needs-review")) lines.push(render(ctx, [
-		{
-			text: `  ${ctx.symbol("review")} `,
-			paint: ctx.c.yellow
-		},
-		{
-			text: finding.ruleId,
-			paint: ctx.c.yellow
-		},
-		{
-			text: ` needs manual review${criteria(finding)}`,
-			paint: ctx.c.dim
-		}
-	]));
-	if (audit.violations.length === 0) {
-		const clean = (audit.accepted ?? []).length === 0;
-		lines.push(render(ctx, [{
-			text: `  ${ctx.symbol("clean")} `,
-			paint: clean ? ctx.c.green : ctx.c.dim
-		}, {
-			text: clean ? "no violations" : "no new violations",
-			paint: clean ? ctx.c.green : ctx.c.dim
-		}]));
-	}
-	for (const finding of sortByImpact(audit.accepted ?? [])) {
-		const elements = finding.nodes.length;
-		lines.push(render(ctx, [
-			{
-				text: "  · ",
-				paint: ctx.c.dim
-			},
-			{
-				text: finding.ruleId,
-				paint: ctx.c.dim
-			},
-			{
-				text: ` accepted by the baseline (${elements} ${plural(elements, "element")})`,
-				paint: ctx.c.dim
-			}
-		]));
-	}
-	lines.push(coverageLine(audit, ctx));
-	lines.push("");
-	return lines;
-}
-/**
-* What this page's result actually rests on.
-*
-* The four counts stay separate on purpose. Only `passed` is evidence that a
-* criterion was met here; `not applicable` means the rule found nothing to
-* check, and adding the two together would turn an empty page into a
-* near-perfect score.
-*/
-function coverageLine(audit, ctx) {
-	const blind = audit.incomplete.filter((finding) => finding.reason === "engine-limitation").length;
-	const review = audit.incomplete.length - blind;
-	const parts = [`${audit.passes.length} passed`, `${audit.inapplicable.length} not applicable`];
-	if (review > 0) parts.push(`${review} to review`);
-	if (blind > 0) parts.push(`${blind} not evaluated`);
-	return render(ctx, [{
-		text: `    ${parts.join(" · ")}`,
-		paint: ctx.c.dim
-	}]);
-}
-function violationLines(finding, ctx) {
-	const impact = finding.impact ?? "unknown";
-	const lines = [render(ctx, [
-		{
-			text: `  ${ctx.symbol("violation")} `,
-			paint: ctx.c.red
-		},
-		{
-			text: finding.ruleId,
-			paint: ctx.c.bold
-		},
-		{
-			text: ` ${impact}${criteria(finding)}`,
-			paint: ctx.c.dim
-		}
-	]), render(ctx, [{ text: `      ${finding.help}` }])];
-	for (const node of finding.nodes.slice(0, ctx.maxNodes)) {
-		lines.push(render(ctx, [{
-			text: `      ${node.target.join(" ")}`,
-			paint: ctx.c.cyan
-		}]));
-		lines.push(render(ctx, [{
-			text: `        ${collapse(node.html)}`,
-			paint: ctx.c.dim
-		}]));
-	}
-	const hidden = finding.nodes.length - ctx.maxNodes;
-	if (hidden > 0) lines.push(render(ctx, [{
-		text: `      + ${hidden} more ${plural(hidden, "element")}`,
-		paint: ctx.c.dim
-	}]));
-	return lines;
-}
-function summary(audits, ctx) {
-	const withViolations = audits.filter((audit) => audit.violations.length > 0);
-	const errored = audits.filter((audit) => audit.error);
-	const ruleCount = audits.reduce((total, audit) => total + audit.violations.length, 0);
-	const elementCount = audits.reduce((total, audit) => total + audit.violations.reduce((sum, finding) => sum + finding.nodes.length, 0), 0);
-	const reviewCount = countRules(audits, "needs-review");
-	const pages = `${audits.length} ${plural(audits.length, "page")}`;
-	const lines = [render(ctx, [{
-		text: "Summary",
-		paint: ctx.c.bold
-	}])];
-	if (ruleCount === 0) lines.push(render(ctx, [{
-		text: `  No violations across ${pages}.`,
-		paint: ctx.c.green
-	}]));
-	else {
-		lines.push(render(ctx, [{
-			text: `  ${ruleCount} ${plural(ruleCount, "violation")} on ${withViolations.length} of ${pages}`,
-			paint: ctx.c.red
-		}, {
-			text: ` (${elementCount} ${plural(elementCount, "element")})`,
-			paint: ctx.c.dim
-		}]));
-		lines.push(thresholdLine(audits, ctx));
-	}
-	if (reviewCount > 0) lines.push(render(ctx, [{
-		text: `  ${reviewCount} ${plural(reviewCount, "rule")} ${reviewCount === 1 ? "needs" : "need"} manual review`,
-		paint: ctx.c.yellow
-	}]));
-	if (errored.length > 0) lines.push(render(ctx, [{
-		text: `  ${errored.length} ${plural(errored.length, "page")} could not be audited`,
-		paint: ctx.c.red
-	}]));
-	const accepted = audits.reduce((total, audit) => total + (audit.accepted ?? []).reduce((sum, finding) => sum + finding.nodes.length, 0), 0);
-	if (accepted > 0) lines.push(render(ctx, [{
-		text: `  ${accepted} ${plural(accepted, "element")} accepted by the baseline, not counted above`,
-		paint: ctx.c.dim
-	}]));
-	lines.push(...blindSection(audits, ctx));
-	return lines;
-}
-/**
-* Why the run passed or failed. Without this, a build that exits 0 while the
-* report lists violations looks like a bug rather than a threshold choice.
-*/
-function thresholdLine(audits, ctx) {
-	const failOn = ctx.failOn;
-	const failing = countAtOrAbove(audits, failOn);
-	if (failing === 0) return render(ctx, [{
-		text: `  none at or above ${failOn} (--fail-on ${failOn}), so this run passes`,
-		paint: ctx.c.green
-	}]);
-	return render(ctx, [{
-		text: `  ${failing} at or above ${failOn} (--fail-on ${failOn})`,
-		paint: ctx.c.red
-	}]);
-}
-/**
-* The unevaluated rules are listed once, at the end, rather than repeated under
-* every page: on a large site the same handful recurs on each one, and a wall
-* of "not evaluated" would bury the findings that are real.
-*/
-function blindSection(audits, ctx) {
-	const byRule = /* @__PURE__ */ new Map();
-	for (const audit of audits) for (const finding of audit.incomplete) {
-		if (finding.reason !== "engine-limitation") continue;
-		const entry = byRule.get(finding.ruleId);
-		if (entry) entry.pages += 1;
-		else byRule.set(finding.ruleId, {
-			pages: 1,
-			finding
-		});
-	}
-	if (byRule.size === 0) return [];
-	const lines = [
-		"",
-		render(ctx, [{
-			text: "Not evaluated",
-			paint: ctx.c.bold
-		}]),
-		render(ctx, [{
-			text: "  This engine reached no verdict on these.",
-			paint: ctx.c.dim
-		}]),
-		render(ctx, [{
-			text: "  They are never reported as passing.",
-			paint: ctx.c.dim
-		}])
-	];
-	for (const [ruleId, { pages, finding }] of [...byRule].sort((a, b) => b[1].pages - a[1].pages)) {
-		lines.push(render(ctx, [
-			{ text: `  ${ctx.symbol("blind")} ` },
-			{ text: ruleId },
-			{
-				text: ` ${pages} ${plural(pages, "page")}${criteria(finding)}`,
-				paint: ctx.c.dim
-			}
-		]));
-		lines.push(render(ctx, [{
-			text: `      ${finding.reasonDetail}`,
-			paint: ctx.c.dim
-		}]));
-	}
-	return lines;
-}
-function countRules(audits, reason) {
-	const ruleIds = /* @__PURE__ */ new Set();
-	for (const audit of audits) for (const finding of audit.incomplete) if (finding.reason === reason) ruleIds.add(finding.ruleId);
-	return ruleIds.size;
-}
-function sortByImpact(findings) {
-	return [...findings].sort((a, b) => {
-		const rank = impactRank(a) - impactRank(b);
-		return rank === 0 ? a.ruleId.localeCompare(b.ruleId) : rank;
-	});
-}
-/** Most severe first; anything axe-core left unclassified sorts last. */
-function impactRank(finding) {
-	const index = IMPACT_LEVELS.indexOf(finding.impact);
-	return index === -1 ? IMPACT_LEVELS.length : IMPACT_LEVELS.length - index;
-}
-function criteria(finding) {
-	return finding.successCriteria.length > 0 ? `, WCAG ${finding.successCriteria.join(" ")}` : "";
-}
-function collapse(html) {
-	return html.replace(/\s+/g, " ").trim();
-}
-function plural(count, word) {
-	return count === 1 ? word : `${word}s`;
-}
-/**
-* What is actually broken, once per element rather than once per page.
-*
-* The page-by-page listing above is the truth, and on a site built from
-* components it is not the work: one header with a missing `alt` reappears on
-* every page that renders it, and nothing in a per-page report says those are
-* one line in one file. This section says it, and orders the result by what
-* fixing it would buy.
-*/
-function issuesSection(audits, ctx) {
-	const issues = groupIssues(audits);
-	if (issues.length === 0) return [];
-	const elements = issues.reduce((total, issue) => total + issue.elements.length, 0);
-	const occurrences = issues.reduce((total, issue) => total + issue.occurrences, 0);
-	const lines = [render(ctx, [{
-		text: "Issues",
-		paint: ctx.c.bold
-	}])];
-	lines.push(render(ctx, [{
-		text: occurrences === elements ? `  ${elements} ${plural(elements, "distinct element")} to fix.` : `  ${occurrences} ${plural(occurrences, "violation")} across the site come from ${elements} ${plural(elements, "distinct element")}.`,
-		paint: ctx.c.dim
-	}]));
-	for (const issue of issues) {
-		lines.push("");
-		lines.push(render(ctx, [
-			{ text: `  ${ctx.symbol("violation")} ` },
-			{
-				text: issue.ruleId,
-				paint: ctx.c.bold
-			},
-			{
-				text: ` ${issue.impact ?? "unclassified"}`,
-				paint: ctx.c.dim
-			},
-			...issue.successCriteria.length > 0 ? [{
-				text: `, WCAG ${issue.successCriteria.join(" ")}`,
-				paint: ctx.c.dim
-			}] : []
-		]));
-		lines.push(render(ctx, [{
-			text: `      ${issue.help}`,
-			paint: ctx.c.dim
-		}]));
-		for (const element of issue.elements.slice(0, ctx.maxNodes)) {
-			lines.push(render(ctx, [{ text: `      ${collapse(element.html)}` }]));
-			lines.push(...whereLines(element, ctx));
-		}
-		if (issue.elements.length > ctx.maxNodes) lines.push(render(ctx, [{
-			text: `      …and ${issue.elements.length - ctx.maxNodes} more ${plural(issue.elements.length - ctx.maxNodes, "element")}`,
-			paint: ctx.c.dim
-		}]));
-	}
-	return lines;
-}
-/** Where one element appears, and what that says about where the fix goes. */
-function whereLines(element, ctx) {
-	const shown = element.pages.slice(0, ctx.maxNodes);
-	const rest = element.pages.length - shown.length;
-	const lines = [render(ctx, [{
-		text: `        on ${element.pages.length} ${plural(element.pages.length, "page")}:`,
-		paint: ctx.c.dim
-	}])];
-	for (const page of shown) {
-		const source = ctx.sourceFor(page);
-		lines.push(render(ctx, [{
-			text: `          ${page}`,
-			paint: ctx.c.dim
-		}, ...source === void 0 ? [] : [{
-			text: `  ${source}`,
-			paint: ctx.c.dim
-		}]]));
-	}
-	if (rest > 0) lines.push(render(ctx, [{
-		text: `          …and ${rest} more ${plural(rest, "page")}`,
-		paint: ctx.c.dim
-	}]));
-	if (isShared(element)) lines.push(render(ctx, [{
-		text: "        identical on each — likely one shared component",
-		paint: ctx.c.dim
-	}]));
-	return lines;
-}
-//#endregion
-//#region src/audit/collect.ts
-/** Every HTML document a static build is expected to emit. */
-const DEFAULT_INCLUDE = ["**/*.html", "**/*.htm"];
-/** Vendored and tooling directories are never part of the shipped site. */
-const DEFAULT_EXCLUDE = ["**/node_modules/**", "**/.git/**"];
-/** Number of files read in parallel; keeps large builds under the fd limit. */
-const READ_CONCURRENCY = 24;
-/**
-* Thrown when the build directory itself is unusable. A missing or wrong
-* `dist/` is a user mistake worth reporting loudly, unlike a directory that
-* simply holds no HTML.
-*/
-var BuildDirectoryError = class extends Error {
-	dir;
-	name = "BuildDirectoryError";
-	constructor(message, dir) {
-		super(message);
-		this.dir = dir;
-	}
-};
-/**
-* Glob HTML files out of a build directory and read them.
-*
-* Returns pages sorted by relative path so reports and snapshots are stable
-* across platforms. An empty array means "no HTML found" — the caller decides
-* whether that is an error.
-*/
-async function collectPages(dir, options = {}) {
-	const root = path.resolve(dir);
-	await assertDirectory(root, dir);
-	const relativePaths = (await glob(options.include ?? DEFAULT_INCLUDE, {
-		cwd: root,
-		ignore: options.exclude ?? DEFAULT_EXCLUDE,
-		onlyFiles: true,
-		dot: false,
-		absolute: false
-	})).map(toPosix).sort();
-	const pages = [];
-	for (let i = 0; i < relativePaths.length; i += READ_CONCURRENCY) {
-		const batch = relativePaths.slice(i, i + READ_CONCURRENCY);
-		pages.push(...await Promise.all(batch.map((relativePath) => readPage(root, relativePath))));
-	}
-	return pages;
-}
-async function assertDirectory(root, original) {
-	let stats;
-	try {
-		stats = await stat(root);
-	} catch (cause) {
-		if (cause.code === "ENOENT") throw new BuildDirectoryError(`Build directory not found: ${original}`, root);
-		throw new BuildDirectoryError(`Build directory is not readable: ${original} (${cause.message})`, root);
-	}
-	if (!stats.isDirectory()) throw new BuildDirectoryError(`Build path is not a directory: ${original}`, root);
-}
-async function readPage(root, relativePath) {
-	const absolutePath = path.join(root, relativePath);
-	const html = await readFile(absolutePath, "utf8");
-	return {
-		absolutePath,
-		relativePath,
-		html: html.charCodeAt(0) === 65279 ? html.slice(1) : html
-	};
-}
-function toPosix(filePath) {
-	return filePath.split(path.sep).join("/");
-}
-/** Whether a path exists, relative to a project root. */
-async function present(root, name) {
-	try {
-		await stat(path.resolve(root, name));
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** A file's contents, or undefined if it is not there. */
-async function contents(root, name) {
-	try {
-		return await readFile(path.resolve(root, name), "utf8");
-	} catch {
-		return;
-	}
-}
-const NEXT_CONFIGS = [
-	"next.config.js",
-	"next.config.mjs",
-	"next.config.ts"
-];
-/** Common build output directories, in the order worth suggesting them. */
-const BUILD_DIRECTORIES = [
-	"dist",
-	"build",
-	"out",
-	"_site",
-	"public",
-	".output/public"
-];
-/**
-* Advice for a Next.js project, or undefined if this is not one.
-*
-* Worth a branch of its own because it is the commonest way to arrive here at
-* all: a default `next build` writes a server bundle rather than browsable
-* HTML, and `./dist` — every tutorial's answer — is a directory it never uses.
-*/
-async function nextJsAdvice(root, dir, head) {
-	const config = (await Promise.all(NEXT_CONFIGS.map(async (name) => await present(root, name) ? name : void 0))).find((name) => name !== void 0);
-	if (config === void 0) return void 0;
-	if (await present(root, "out")) return `${head} A Next.js static export writes to out/, not ${dir}.\n  Try: eaa-kit audit ./out`;
-	const source = await contents(root, config) ?? "";
-	if (!/output\s*:\s*['"`]export['"`]/.test(source)) return `${head} A Next.js build writes a server bundle, not browsable HTML.\n  To audit it, add output: 'export' to ${config}, run your build, then:\n    eaa-kit audit ./out
-  A site with SSR, API routes, middleware or ISR cannot be exported. Audit it
-  running instead:
-    eaa-kit audit --url http://localhost:3000`;
-	return `${head} ${config} sets output: 'export', but there is no out/ directory.\n  Run your build first, then: eaa-kit audit ./out
-  If the build failed, it names what blocks the export — an API route,
-  middleware, getServerSideProps or a revalidate.`;
-}
-/** Advice for a Nuxt project, or undefined if this is not one. */
-async function nuxtAdvice(root, head) {
-	if (!await present(root, "nuxt.config.ts")) return void 0;
-	return `${head} Nuxt writes a static build to .output/public.\n  Try: eaa-kit audit ./.output/public
-  Or audit it running: eaa-kit audit --url http://localhost:3000`;
-}
-/**
-* Advice from whatever build directories are lying around.
-*
-* Naming one that is actually there beats listing the ones that usually are.
-*/
-async function siblingDirectoryAdvice(root, dir, head) {
-	const given = dir.replace(/^\.\//, "");
-	const others = (await Promise.all(BUILD_DIRECTORIES.map(async (name) => name !== given && await present(root, name) ? name : void 0))).filter((name) => name !== void 0);
-	if (others.length === 0) return void 0;
-	return `${head} This project also has ${others.map((name) => `${name}/`).join(", ")} — try one of those.`;
-}
-/**
-* What to suggest when a directory holds no HTML, or is not there at all.
-*
-* Nearly always the wrong directory rather than a site with no pages, and the
-* commonest way to arrive is a framework whose build emits no browsable HTML —
-* so rather than repeating "check the path", each branch names the next step
-* for the project actually in front of the reader. Where a static export cannot
-* work at all, that step is `--url` rather than advice that cannot apply.
-*/
-async function emptyDirectoryHint(dir, cwd = process.cwd()) {
-	const head = await present(cwd, dir) ? `${dir} holds no HTML files.` : `${dir} does not exist.`;
-	return await nextJsAdvice(cwd, dir, head) ?? await nuxtAdvice(cwd, head) ?? await siblingDirectoryAdvice(cwd, dir, head) ?? `${head} Point eaa-kit at the directory your build fills with .html files —\n  commonly dist/, build/, out/ or _site/, depending on the builder.
-  If your site renders on a server and never writes HTML, audit it running:
-    eaa-kit audit --url http://localhost:3000`;
-}
-//#endregion
-//#region src/cli/pages.ts
-/**
-* Collect the pages to audit, reporting to stderr on the way.
-*
-* Returns undefined when there is nothing to audit, having already explained
-* why. Every caller turns that into exit 2 — a run that reached no verdict,
-* which is not the same as a clean one.
-*/
-async function resolvePages(directory, options = {}) {
-	if (directory === void 0 && options.url === void 0) return resolveAutomatically(options);
-	if (options.url !== void 0) {
-		const crawled = await crawlPages(options.url, options);
-		if (!crawled) return void 0;
-		if (crawled.pages.length === 0) {
-			process.stderr.write(`${pc.yellow("warning")} No pages could be fetched from ${options.url}\n`);
-			return;
-		}
-		return {
-			pages: crawled.pages,
-			origin: crawled.origin,
-			label: options.url
-		};
-	}
-	const cwd = options.cwd ?? process.cwd();
-	const shown = options.label ?? directory;
-	let pages;
-	try {
-		pages = await collectPages(directory, {
-			...options.include ? { include: options.include } : {},
-			...options.exclude ? { exclude: options.exclude } : {}
-		});
-	} catch (cause) {
-		if (!(cause instanceof BuildDirectoryError)) throw cause;
-		process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-		process.stderr.write(pc.dim(`${await emptyDirectoryHint(shown, cwd)}\n`));
-		return;
-	}
-	if (pages.length === 0) {
-		process.stderr.write(`${pc.yellow("warning")} ${await emptyDirectoryHint(shown, cwd)}\n`);
-		return;
-	}
-	return {
-		pages,
-		label: shown
-	};
-}
-/**
-* Fetch the pages of a running site, reporting what happened on the way.
-*
-* Returns undefined when the crawl could not start, which the caller turns into
-* exit 2 — a run that reached no verdict, not a clean one.
-*/
-async function crawlPages(url, options) {
-	const { crawlSite, CrawlError, parseEntryUrl } = await import("./crawl-CtJbMNNb.js");
-	let entry;
-	try {
-		entry = parseEntryUrl(url, options.allowRemote ?? false);
-	} catch (cause) {
-		if (cause instanceof CrawlError) {
-			process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-			return;
-		}
-		throw cause;
-	}
-	process.stderr.write(pc.dim(`Crawling ${entry.origin}…\n`));
-	const result = await crawlSite(entry, {
-		...options.allowRemote ? { allowRemote: true } : {},
-		...options.ignoreRobots ? { ignoreRobots: true } : {},
-		...options.maxPages === void 0 ? {} : { maxPages: options.maxPages },
-		...options.maxDepth === void 0 ? {} : { maxDepth: options.maxDepth },
-		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
-	});
-	if (result.pages.length === 0 && result.failures.length > 0) {
-		process.stderr.write(`${pc.red("error")} Could not fetch ${entry.href} (${result.failures[0]?.reason})\n`);
-		process.stderr.write(pc.dim("  Is the site running at that address?\n"));
-		return;
-	}
-	process.stderr.write(pc.dim(`Found ${result.pages.length} ${result.pages.length === 1 ? "page" : "pages"} from ${result.discovery === "sitemap" ? "sitemap.xml and links" : "links"}\n`));
-	if (result.failures.length > 0) {
-		process.stderr.write(`${pc.yellow("warning")} ${result.failures.length} ${result.failures.length === 1 ? "URL was" : "URLs were"} not fetched, and so not audited:\n`);
-		for (const failure of result.failures.slice(0, 10)) process.stderr.write(pc.dim(`  ${failure.url} — ${failure.reason}\n`));
-		if (result.failures.length > 10) process.stderr.write(pc.dim(`  …and ${result.failures.length - 10} more\n`));
-	}
-	if (result.truncated) process.stderr.write(`${pc.yellow("warning")} Stopped at ${result.pages.length} ${result.pages.length === 1 ? "page" : "pages"}; the site has more. Raise --max-pages to go further.\n`);
-	return {
-		pages: result.pages,
-		origin: result.origin
-	};
-}
-/**
-* No directory and no URL: work out what this project needs.
-*
-* The point is that `eaa-kit audit` on its own does something useful. Anything
-* this starts is handed back as `cleanup` so the caller can stop it once the
-* report is written.
-*/
-async function resolveAutomatically(options) {
-	const cwd = options.cwd ?? process.cwd();
-	const { autoDetectSource } = await import("./project-CiyzKQud.js");
-	const detected = await autoDetectSource(cwd, {
-		...options.noBuild ? { noBuild: true } : {},
-		onStep: (message) => process.stderr.write(pc.dim(`${message}\n`))
-	});
-	if (detected?.directory !== void 0) return await resolvePages(detected.directory, {
-		...options,
-		label: path.relative(cwd, detected.directory) || "."
-	});
-	if (detected?.url !== void 0) {
-		const resolved = await resolvePages(void 0, {
-			...options,
-			url: detected.url
-		});
-		if (resolved === void 0) {
-			await detected.cleanup?.();
-			return;
-		}
-		return {
-			...resolved,
-			...detected.cleanup ? { cleanup: detected.cleanup } : {}
-		};
-	}
-	await detected?.cleanup?.();
-	process.stderr.write(`${pc.yellow("warning")} ${await emptyDirectoryHint("./dist", cwd)}\n`);
-}
-//#endregion
-//#region src/cli/audit.ts
-const OUTPUT_FORMATS = [
-	"console",
-	"json",
-	"sarif",
-	"html"
-];
-function isOutputFormat(value) {
-	return OUTPUT_FORMATS.includes(value);
-}
-/**
-* `eaa-kit audit [dir]`.
-*
-* Writes progress to stderr and the report to stdout, so the report can be
-* piped somewhere without the chatter coming along.
-*/
-async function runAuditCommand(dir, options = {}) {
-	const resolved = await resolvePages(dir, options);
-	if (!resolved) return {
-		audits: [],
-		exitCode: 2
-	};
-	const { pages, origin, label, cleanup } = resolved;
-	try {
-		const engineNote = await describeEngine(pages, options);
-		process.stderr.write(pc.dim(`Auditing ${pages.length} ${pages.length === 1 ? "page" : "pages"} in ${label}${engineNote}…\n`));
-		const effectiveBaseUrl = options.baseUrl ?? origin;
-		const runnerOptions = {
-			...effectiveBaseUrl === void 0 ? {} : { baseUrl: effectiveBaseUrl },
-			...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
-		};
-		let audits;
-		if (options.browser) {
-			const { BrowserUnavailableError, runBrowserAudit } = await import("./playwright-DWux49V3.js");
-			try {
-				audits = await runBrowserAudit(options.url === void 0 ? dir : void 0, pages, runnerOptions);
-			} catch (cause) {
-				if (cause instanceof BrowserUnavailableError) {
-					process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-					return {
-						audits: [],
-						exitCode: 2
-					};
-				}
-				throw cause;
-			}
-		} else {
-			const { runPooledAudit } = await import("./pool-DixLeu8L.js");
-			audits = await runPooledAudit(pages, {
-				...runnerOptions,
-				...options.concurrency === void 0 ? {} : { concurrency: options.concurrency }
-			});
-		}
-		const failOn = options.failOn ?? "serious";
-		if (options.baseline) {
-			const applied = await acceptBaseline(audits, options);
-			if (!applied) return {
-				audits,
-				exitCode: 2
-			};
-			audits = applied;
-		}
-		await emit(audits, label, failOn, options);
-		const unaudited = audits.filter((audit) => audit.error);
-		if (unaudited.length > 0) {
-			process.stderr.write(`${pc.red("error")} ${unaudited.length} of ${audits.length} pages could not be audited\n`);
-			return {
-				audits,
-				exitCode: 2
-			};
-		}
-		return {
-			audits,
-			exitCode: countAtOrAbove(audits, failOn) > 0 ? 1 : 0
-		};
-	} finally {
-		await cleanup?.();
-	}
-}
-/**
-* Move the violations the baseline accounts for out of the failing set.
-*
-* Returns undefined when the baseline could not be read, which the caller
-* turns into exit 2: a run asked to use a baseline it cannot find has not
-* measured what it was told to measure, and silently failing on everything
-* would be as wrong as silently passing.
-*/
-async function acceptBaseline(audits, options) {
-	const { applyBaseline, BaselineError, readBaseline } = await import("./baseline-CV_3lbER.js");
-	try {
-		const outcome = applyBaseline(audits, await readBaseline(options.baseline, options.cwd ?? process.cwd()));
-		if (outcome.accepted > 0) process.stderr.write(pc.dim(`Baseline accepted ${outcome.accepted} violating elements\n`));
-		if (outcome.stale.length > 0) {
-			const count = outcome.stale.length;
-			process.stderr.write(pc.dim(`${count} baseline ${count === 1 ? "entry no longer matches" : "entries no longer match"} and can be removed\n`));
-		}
-		if (outcome.expired.length > 0) process.stderr.write(pc.yellow(`${outcome.expired.length} baseline entries have expired and no longer suppress anything\n`));
-		return outcome.audits;
-	} catch (cause) {
-		if (cause instanceof BaselineError) {
-			process.stderr.write(`${pc.red("error")} ${cause.message}\n`);
-			return;
-		}
-		throw cause;
-	}
-}
-/**
-* What the progress line says about the engine.
-*
-* The thread count is on it because it is the difference between a run that
-* looks stalled and one that is working, and because a user comparing two
-* timings deserves to know which one used the machine.
-*/
-async function describeEngine(pages, options) {
-	if (options.browser) return " with Chromium";
-	const { plannedWorkers } = await import("./pool-DixLeu8L.js");
-	const workers = options.concurrency ?? plannedWorkers(pages);
-	return workers > 1 ? ` across ${workers} threads` : "";
-}
-/**
-* Emit the chosen format, to a file when --output is given and to stdout
-* otherwise. Colour is dropped when writing to a file, since escape codes in a
-* saved report are noise.
-*/
-async function emit(audits, dir, failOn, options) {
-	const body = await renderReport(audits, dir, failOn, options.format ?? "console", typeof options.output === "string", options);
-	if (!options.output) {
-		process.stdout.write(body);
-		return;
-	}
-	const target = path.resolve(options.cwd ?? process.cwd(), options.output);
-	await mkdir(path.dirname(target), { recursive: true });
-	await writeFile(target, body, "utf8");
-	process.stderr.write(pc.dim(`Report written to ${options.output}\n`));
-}
-async function renderReport(audits, dir, failOn, format, toFile, options) {
-	switch (format) {
-		case "json": {
-			const { buildJsonReport, serialiseJsonReport } = await import("./json-C9xS1PNC.js");
-			return serialiseJsonReport(buildJsonReport(audits, {
-				directory: dir,
-				...options.url === void 0 ? {} : { sourceKind: "url" },
-				failOn,
-				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
-			}));
-		}
-		case "sarif": {
-			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-eSCuI0eX.js");
-			return serialiseSarifReport(buildSarifReport(audits, { directory: dir }));
-		}
-		case "html": {
-			const { buildHtmlReport } = await import("./html-BLEuzep6.js");
-			return buildHtmlReport(audits, {
-				directory: dir,
-				failOn,
-				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
-			});
-		}
-		case "console": {
-			const { buildRouteMap, sourceFor } = await import("./routes-BxbSZKXC.js");
-			const routes = await buildRouteMap(options.cwd ?? process.cwd());
-			return `${formatConsoleReport(audits, {
-				dir,
-				failOn,
-				sourceFor: (page) => sourceFor(routes, page),
-				...options.perPage ? { perPage: true } : {},
-				...toFile ? { color: false } : {}
-			})}\n`;
-		}
-	}
-}
-//#endregion
-export { resolvePages as i, isOutputFormat as n, runAuditCommand as r, OUTPUT_FORMATS as t };