eaa-kit 0.2.1 → 0.3.0

package/dist/manual-Vz-oX1I_.js

@@ -0,0 +1,239 @@
+import { a as impactRank } from "./impact-YdoOtFqm.js";
+import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
+import { r as findingElements } from "./result-DLxd2Eip.js";
+/** 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);
+		for (const node of findingElements(finding)) {
+			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;
+}
+/**
+* Unevaluated rules folded across the site, sorted by rule id.
+*
+* Both reports list these once at the end rather than 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 blindRules(audits) {
+	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, {
+			ruleId: finding.ruleId,
+			pages: 1,
+			finding
+		});
+	}
+	return [...byRule.values()].sort((a, b) => a.ruleId.localeCompare(b.ruleId));
+}
+/**
+* What one page's result actually rests on, as phrases both reports print.
+*
+* The 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 coverageParts(audit) {
+	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 parts;
+}
+/** 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. */
+function bySeverityThenReach(a, b) {
+	return impactRank(a.impact) - impactRank(b.impact) || b.pages.length - a.pages.length || a.ruleId.localeCompare(b.ruleId);
+}
+//#endregion
+//#region src/audit/manual.ts
+/**
+* What a person has to check, and where to read about it.
+*
+* Automated testing finds a minority of accessibility barriers. This tool says
+* so everywhere, and saying so is not much use on its own: a reader told that
+* six rules "could not be evaluated" is left knowing there is a gap and not
+* what to do about it.
+*
+* So each rule the browserless engine cannot decide carries the check somebody
+* would do by hand, and each success criterion carries a link to what it
+* actually requires. The point is to turn the honest disclaimer into the part
+* of the report with the most work in it.
+*/
+/**
+* WCAG 2.2 Understanding pages, by success criterion.
+*
+* The Understanding document rather than the criterion text: the text says what
+* conformance is, and the Understanding page says what it is for and how to
+* meet it, which is what somebody reading a report needs.
+*
+* Level A and AA only, since that is what this tool audits against.
+*/
+const UNDERSTANDING = {
+	"1.1.1": "non-text-content",
+	"1.2.1": "audio-only-and-video-only-prerecorded",
+	"1.2.2": "captions-prerecorded",
+	"1.2.3": "audio-description-or-media-alternative-prerecorded",
+	"1.2.4": "captions-live",
+	"1.2.5": "audio-description-prerecorded",
+	"1.3.1": "info-and-relationships",
+	"1.3.2": "meaningful-sequence",
+	"1.3.3": "sensory-characteristics",
+	"1.3.4": "orientation",
+	"1.3.5": "identify-input-purpose",
+	"1.4.1": "use-of-color",
+	"1.4.2": "audio-control",
+	"1.4.3": "contrast-minimum",
+	"1.4.4": "resize-text",
+	"1.4.5": "images-of-text",
+	"1.4.10": "reflow",
+	"1.4.11": "non-text-contrast",
+	"1.4.12": "text-spacing",
+	"1.4.13": "content-on-hover-or-focus",
+	"2.1.1": "keyboard",
+	"2.1.2": "no-keyboard-trap",
+	"2.1.4": "character-key-shortcuts",
+	"2.2.1": "timing-adjustable",
+	"2.2.2": "pause-stop-hide",
+	"2.3.1": "three-flashes-or-below-threshold",
+	"2.4.1": "bypass-blocks",
+	"2.4.2": "page-titled",
+	"2.4.3": "focus-order",
+	"2.4.4": "link-purpose-in-context",
+	"2.4.5": "multiple-ways",
+	"2.4.6": "headings-and-labels",
+	"2.4.7": "focus-visible",
+	"2.4.11": "focus-not-obscured-minimum",
+	"2.5.1": "pointer-gestures",
+	"2.5.2": "pointer-cancellation",
+	"2.5.3": "label-in-name",
+	"2.5.4": "motion-actuation",
+	"2.5.7": "dragging-movements",
+	"2.5.8": "target-size-minimum",
+	"3.1.1": "language-of-page",
+	"3.1.2": "language-of-parts",
+	"3.2.1": "on-focus",
+	"3.2.2": "on-input",
+	"3.2.3": "consistent-navigation",
+	"3.2.4": "consistent-identification",
+	"3.2.6": "consistent-help",
+	"3.3.1": "error-identification",
+	"3.3.2": "labels-or-instructions",
+	"3.3.3": "error-suggestion",
+	"3.3.4": "error-prevention-legal-financial-data",
+	"3.3.7": "redundant-entry",
+	"3.3.8": "accessible-authentication-minimum",
+	"4.1.2": "name-role-value",
+	"4.1.3": "status-messages"
+};
+/** Where to read what a success criterion requires, or undefined if unknown. */
+function understandingUrl(criterion) {
+	const slug = UNDERSTANDING[criterion];
+	return slug === void 0 ? void 0 : `https://www.w3.org/WAI/WCAG22/Understanding/${slug}.html`;
+}
+/**
+* The check a person does for a rule this engine could not decide.
+*
+* Written as an action rather than a restatement of the criterion. "Ensure
+* sufficient contrast" tells somebody nothing they did not already know; the
+* useful sentence names what to open and what to look at.
+*/
+const MANUAL_CHECKS = {
+	"color-contrast": {
+		check: "Open the page and check text against its background with a contrast checker. Body text needs 4.5:1, and large or bold text 3:1. Check the states too — hover, focus, visited, disabled and placeholder text are the ones usually missed.",
+		browserAnswers: true
+	},
+	"color-contrast-enhanced": {
+		check: "Only needed if you are claiming AAA. Body text needs 7:1 and large text 4.5:1.",
+		browserAnswers: true
+	},
+	"target-size": {
+		check: "Measure the clickable area of buttons, icon links and form controls: 24×24 CSS pixels at minimum, unless they are inline in a sentence or have that much clear space around them. Icon-only controls in a header or a media player are where this usually fails.",
+		browserAnswers: true
+	},
+	"scrollable-region-focusable": {
+		check: "Find anything that scrolls inside the page — a code block, a wide table, a long list — and try reaching it with the Tab key alone. If it cannot take focus, a keyboard user cannot scroll it.",
+		browserAnswers: true
+	},
+	"link-in-text-block": {
+		check: "Look at links inside paragraphs. If the only thing distinguishing them from the surrounding text is colour, they need an underline or a 3:1 contrast difference against that text as well.",
+		browserAnswers: true
+	},
+	"no-autoplay-audio": {
+		check: "Load the page and listen. Anything that plays for more than three seconds on its own needs a pause or stop control, or a volume control independent of the system volume.",
+		browserAnswers: false
+	},
+	"avoid-inline-spacing": {
+		check: "Override line height to 1.5×, paragraph spacing to 2×, letter spacing to 0.12× and word spacing to 0.16× the font size, then check nothing is clipped or overlapping. Inline styles that set spacing with !important are what break this.",
+		browserAnswers: true
+	},
+	"p-as-heading": {
+		check: "Look for paragraphs styled to look like headings. A screen reader reads them as body text, so they are invisible to anyone navigating by heading.",
+		browserAnswers: false
+	},
+	"css-orientation-lock": {
+		check: "Rotate a phone or tablet. The content should work in both orientations unless one is essential, which is rare outside games and instruments.",
+		browserAnswers: false
+	}
+};
+/** The check for a rule, if there is one written for it. */
+function manualCheckFor(ruleId) {
+	return MANUAL_CHECKS[ruleId];
+}
+//#endregion
+export { groupIssues as a, coverageParts as i, understandingUrl as n, isShared as o, blindRules as r, manualCheckFor as t };

package/dist/{playwright-DSRnXmcd.js → playwright-DYFsGUNd.js}

@@ -1,4 +1,5 @@
-import { i as shapeResults, n as failedPage, r as runOptions, t as DEFAULT_TAGS } from "./result-2aZPfM8w.js";
+import { r as isFile } from "./fs-BmPtmFke.js";
+import { i as pageUrl, n as failedPage, o as runOptions, s as shapeResults, t as DEFAULT_TAGS } from "./result-DLxd2Eip.js";
 import { createRequire } from "node:module";
 import { stat } from "node:fs/promises";
 import path from "node:path";
@@ -74,7 +75,7 @@ async function handle(root, requestUrl, response) {
 	}
 	try {
 		const target = (await stat(file)).isDirectory() ? path.join(file, "index.html") : file;
-		if (!await isReadableFile(target)) {
+		if (!await isFile(target)) {
 			response.writeHead(404).end();
 			return;
 		}
@@ -88,13 +89,6 @@ async function handle(root, requestUrl, response) {
 		response.writeHead(404).end();
 	}
 }
-async function isReadableFile(candidate) {
-	try {
-		return (await stat(candidate)).isFile();
-	} catch {
-		return false;
-	}
-}
 /** Resolves a request path inside the root, or nothing if it escapes it. */
 function resolveFile(root, requestUrl) {
 	const { pathname } = new URL(requestUrl, "http://127.0.0.1");
@@ -151,7 +145,7 @@ async function runBrowserAudit(directory, pages, options = {}) {
 		browser = await chromium.launch({ headless: true });
 	} catch (cause) {
 		await server?.close();
-		throw cause;
+		throw launchFailure(cause);
 	}
 	try {
 		const context = await browser.newContext({
@@ -176,7 +170,7 @@ async function auditOne(context, origin, page, options) {
 	const identity = {
 		relativePath: page.relativePath,
 		absolutePath: page.absolutePath,
-		url: reportedUrl(page, options.baseUrl),
+		url: pageUrl(page, options.baseUrl),
 		engine: "browser"
 	};
 	const tab = await context.newPage();
@@ -218,9 +212,27 @@ async function auditOne(context, origin, page, options) {
 function servedUrl(origin, relativePath) {
 	return `${origin}/${relativePath.split("/").map(encodeURIComponent).join("/")}`;
 }
-function reportedUrl(page, baseUrl) {
-	if (!baseUrl) return pathToFileURL(page.absolutePath).href;
-	return new URL(page.relativePath, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).href;
+/**
+* A launch that failed because the browser was never downloaded, told as setup.
+*
+* The third setup failure, and the only one that used to arrive as a crash.
+* `npm i -D playwright` does not fetch Chromium, so somebody who followed the
+* install line exactly still lands here — and what they saw was Playwright's
+* message boxed in ASCII, wrapped in a stack trace through this package's
+* bundled internals. That reads as eaa-kit falling over, not as a step left to
+* run, and the two want very different things from the reader.
+*
+* Anything else is passed through untouched: a launch can fail for reasons
+* that really are bugs, and dressing those up as setup advice would send
+* somebody off installing a browser they already have.
+*/
+function launchFailure(cause) {
+	if (!(cause instanceof Error)) return cause;
+	const missing = /Executable doesn't exist at (.+)/.exec(cause.message);
+	if (missing === null) return cause;
+	return new BrowserUnavailableError(`Playwright is installed, but the Chromium it drives is not.
+  Download it with:  npx playwright install chromium
+  It was looked for at: ${missing[1]?.trim() ?? "an unreported path"}`);
 }
 /**
 * Playwright is an optional peer dependency: the browserless path must never
@@ -229,18 +241,53 @@ function reportedUrl(page, baseUrl) {
 * problems with different fixes.
 */
 async function loadChromium(cwd = process.cwd()) {
-	let module;
+	const tried = [];
+	const specifiers = ["playwright", "@playwright/test"];
+	const roots = [cwd, void 0];
+	for (const root of roots) for (const specifier of specifiers) {
+		const loaded = await tryLoad(specifier, root);
+		if (loaded === void 0) continue;
+		tried.push(`${specifier}${root === void 0 ? " (from eaa-kit)" : ""}`);
+		const chromium = launcherIn(loaded);
+		if (chromium !== void 0) return chromium;
+	}
+	if (tried.length === 0) throw new BrowserUnavailableError("Browser mode needs Playwright, which is an optional peer dependency.\n  Install it with:  npm i -D playwright\n  Then the browser: npx playwright install chromium");
+	throw new BrowserUnavailableError(`Found ${tried.join(" and ")}, but no chromium launcher on it.\n  This usually means an incomplete or mismatched install. Try:
+    npm i -D playwright@latest
+    npx playwright install chromium --force`);
+}
+/** Import a specifier, resolved from `root` when given. Undefined if absent. */
+async function tryLoad(specifier, root) {
 	try {
-		const resolved = createRequire(pathToFileURL(path.join(cwd, "package.json")).href).resolve("playwright");
-		module = await import(pathToFileURL(resolved).href);
-	} catch {}
-	if (module === void 0) try {
-		module = await import("playwright");
+		if (root === void 0) return await import(specifier);
+		const require = createRequire(pathToFileURL(path.join(root, "package.json")).href);
+		return await import(pathToFileURL(require.resolve(specifier)).href);
 	} catch {
-		throw new BrowserUnavailableError("Browser mode needs Playwright, which is an optional peer dependency.\n  Install it with:  npm i -D playwright\n  Then the browser: npx playwright install chromium");
+		return;
+	}
+}
+/**
+* The chromium launcher, whichever shape the module came back in.
+*
+* Playwright is CommonJS. Whether `await import()` of it exposes named exports
+* depends on Node's static analysis of the file succeeding, which is not
+* guaranteed and differs between versions; when it does not, everything is on
+* `default` instead. Reading only the named export produced "installed but
+* exports no chromium launcher" against a perfectly good install.
+*
+* Exported for its own tests. Driving this through a real import under vitest
+* proves nothing: vitest hands CommonJS back through an interop proxy that
+* answers `.chromium` whether or not Node hoisted it, so both shapes look
+* identical from in there and the test passes with this function broken. The
+* shapes are checked here directly, and the real interop is exercised against
+* real Node by scripts/test-packaged.mjs.
+*/
+function launcherIn(module) {
+	const candidates = [module, module?.default];
+	for (const candidate of candidates) {
+		const chromium = candidate?.chromium;
+		if (chromium !== void 0 && typeof chromium.launch === "function") return chromium;
 	}
-	if (!module.chromium) throw new BrowserUnavailableError("Playwright is installed but exports no chromium launcher");
-	return module.chromium;
 }
 //#endregion
 export { BrowserUnavailableError, runBrowserAudit };

package/dist/{pool-DixLeu8L.js → pool-BWkWZiJW.js}

@@ -1,6 +1,5 @@
-import { n as failedPage } from "./result-2aZPfM8w.js";
-import { stat } from "node:fs/promises";
-import { pathToFileURL } from "node:url";
+import { r as isFile } from "./fs-BmPtmFke.js";
+import { i as pageUrl, n as failedPage } from "./result-DLxd2Eip.js";
 import { Worker } from "node:worker_threads";
 import { availableParallelism } from "node:os";
 //#region src/audit/runners/pool.ts
@@ -97,7 +96,7 @@ async function runPooledAudit(pages, options = {}) {
 	return runWorkers(pages, runnerOptions, Math.min(workers, pages.length), entry);
 }
 async function auditHere(pages, options) {
-	const { runJsdomAudit } = await import("./jsdom-C6dIyaxN.js");
+	const { runJsdomAudit } = await import("./jsdom-X4KYfTp8.js");
 	return runJsdomAudit(pages, options);
 }
 async function runWorkers(pages, options, count, entry) {
@@ -159,11 +158,6 @@ function identity(page, options) {
 		durationMs: 0
 	};
 }
-/** Kept in step with the sequential runner's own URL derivation. */
-function pageUrl(page, baseUrl) {
-	if (!baseUrl) return pathToFileURL(page.absolutePath).href;
-	return new URL(page.relativePath, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).href;
-}
 /**
 * Locate the worker entry point.
 *
@@ -180,9 +174,7 @@ async function findWorkerEntry() {
 		new URL("../audit/runners/worker.js", import.meta.url),
 		new URL("./worker.js", import.meta.url)
 	];
-	for (const candidate of candidates) try {
-		if ((await stat(candidate)).isFile()) return candidate;
-	} catch {}
+	for (const candidate of candidates) if (await isFile(candidate)) return candidate;
 }
 //#endregion
 export { plannedWorkers, runPooledAudit };

package/dist/{project-CufCqIE2.js → project-DW08TseF.js}

@@ -1,4 +1,6 @@
-import { readFile, stat } from "node:fs/promises";
+import { n as isDirectory, t as exists } from "./fs-BmPtmFke.js";
+import { r as candidateOutputs } from "./frameworks-BYa3tULg.js";
+import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { glob } from "tinyglobby";
 import { spawn } from "node:child_process";
@@ -17,15 +19,6 @@ import { spawn } from "node:child_process";
 * project's server if the build produces nothing browsable. Naming a directory
 * or passing --url skips all of it.
 */
-/** Build output directories, in the order worth trying them. */
-const BUILD_DIRECTORIES = [
-	"dist",
-	"out",
-	"build",
-	"_site",
-	".output/public",
-	"public"
-];
 /** Ports the common dev and preview servers use, tried if nothing is announced. */
 const KNOWN_PORTS = [
 	3e3,
@@ -55,10 +48,7 @@ async function detectPackageManager(cwd) {
 		["pnpm-lock.yaml", "pnpm"],
 		["yarn.lock", "yarn"],
 		["bun.lockb", "bun"]
-	]) try {
-		await stat(path.join(cwd, file));
-		return manager;
-	} catch {}
+	]) if (await exists(path.join(cwd, file))) return manager;
 	return "npm";
 }
 /**
@@ -69,13 +59,10 @@ async function detectPackageManager(cwd) {
 * assets. What makes a directory the build output is that there is HTML in it.
 */
 async function findBuildOutput(cwd) {
-	for (const candidate of BUILD_DIRECTORIES) {
+	const candidates = await candidateOutputs(cwd, await readPackageJson(cwd));
+	for (const candidate of candidates) {
 		const directory = path.join(cwd, candidate);
-		try {
-			if (!(await stat(directory)).isDirectory()) continue;
-		} catch {
-			continue;
-		}
+		if (!await isDirectory(directory)) continue;
 		if ((await glob(["**/*.html", "**/*.htm"], {
 			cwd: directory,
 			ignore: ["**/node_modules/**"],
@@ -278,4 +265,4 @@ async function autoDetectSource(cwd, options = {}) {
 	};
 }
 //#endregion
-export { autoDetectSource };
+export { autoDetectSource, readPackageJson };

package/dist/{render-BO0nVrrZ.js → render-DI_aCnAZ.js}

@@ -1,8 +1,9 @@
 import { _ as withDefault, a as isoDateTime, c as object, d as record, f as safeParse, o as nullable, p as string, s as number, t as array } from "./schema-CMZ8ItGk.js";
-import { n as IMPACT_LEVELS } from "./impact-DvgBjupx.js";
-import { n as escapeText, t as escapeAttribute } from "./escape-Dm1o_RAk.js";
+import { n as isDirectory } from "./fs-BmPtmFke.js";
+import { a as impactRank, n as IMPACT_LEVELS } from "./impact-YdoOtFqm.js";
+import { a as standardsReference, i as escapeText, r as escapeAttribute } from "./text-BFmNtMsV.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
-import { readFile, readdir, stat } from "node:fs/promises";
+import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/statement/error.ts
@@ -110,14 +111,10 @@ function toImpact(value) {
 }
 /**
 * Most severe first, then by rule id so two runs of the same build order the
-* list identically. An unclassified impact sorts with the most severe, on the
-* same reasoning as `--fail-on`: a missing impact is a gap in what we know, not
-* evidence that the barrier is harmless.
+* list identically.
 */
 function bySeverityThenRule(a, b) {
-	const rank = (finding) => finding.impact === null ? IMPACT_LEVELS.length : IMPACT_LEVELS.indexOf(finding.impact);
-	const difference = rank(b) - rank(a);
-	return difference === 0 ? a.ruleId.localeCompare(b.ruleId) : difference;
+	return impactRank(a.impact) - impactRank(b.impact) || a.ruleId.localeCompare(b.ruleId);
 }
 //#endregion
 //#region src/statement/html.ts
@@ -524,9 +521,6 @@ function reasonScope(reason) {
 		isFixPlanned: reason === "fix-planned"
 	};
 }
-function standardsReference(successCriteria, en301549) {
-	return [...successCriteria.map((criterion) => `WCAG ${criterion}`), ...en301549.map((clause) => `EN 301 549 ${clause}`)].join(", ");
-}
 /**
 * 2026-08-20 becomes 20. August 2026 or 20 August 2026.
 *
@@ -578,9 +572,7 @@ async function findTemplateDirectory() {
 		path.join(here, "..", "statement", "templates"),
 		path.join(here, "statement", "templates")
 	];
-	for (const candidate of candidates) try {
-		if ((await stat(candidate)).isDirectory()) return candidate;
-	} catch {}
+	for (const candidate of candidates) if (await isDirectory(candidate)) return candidate;
 	throw new StatementError(`Could not locate the statement templates. Looked in: ${candidates.join(", ")}`);
 }
 //#endregion

package/dist/{result-2aZPfM8w.js → result-DLxd2Eip.js}

@@ -1,3 +1,4 @@
+import { pathToFileURL } from "node:url";
 import axe from "axe-core";
 //#region src/audit/result.ts
 /** WCAG 2.2 AA and everything it builds on. Best-practice rules stay off. */
@@ -8,6 +9,42 @@ const DEFAULT_TAGS = [
 	"wcag21aa",
 	"wcag22aa"
 ];
+/**
+* The URL a page is audited under, shared by every runner so their reports name
+* the same page. Without a base URL that is the file it came off disk as.
+*/
+function pageUrl(page, baseUrl) {
+	if (!baseUrl) return pathToFileURL(page.absolutePath).href;
+	return new URL(page.relativePath, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`).href;
+}
+/**
+* The elements a finding points at, as selector and markup.
+*
+* A rule can fail with no node attached — a document-level rule. It still has
+* an identity, so it gets one empty element: the baseline writer, the baseline
+* matcher, the issues view and SARIF all have to agree on what that identity
+* is, and they only do because they all come through here.
+*/
+function findingElements(finding) {
+	if (finding.nodes.length === 0) return [{
+		selector: "",
+		html: ""
+	}];
+	return finding.nodes.map((node) => ({
+		selector: node.target.join(" "),
+		html: node.html
+	}));
+}
+/** Every rule this page reached any verdict on, in one list. */
+function ruleOutcomes(audit) {
+	return [
+		...audit.violations,
+		...audit.accepted ?? [],
+		...audit.incomplete,
+		...audit.passes,
+		...audit.inapplicable
+	];
+}
 function runOptions(tags) {
 	return {
 		runOnly: {
@@ -165,4 +202,4 @@ function enClauses(tags) {
 	return [...clauses].sort();
 }
 //#endregion
-export { shapeResults as i, failedPage as n, runOptions as r, DEFAULT_TAGS as t };
+export { ruleOutcomes as a, pageUrl as i, failedPage as n, runOptions as o, findingElements as r, shapeResults as s, DEFAULT_TAGS as t };

package/dist/{routes-BxbSZKXC.js → routes-C2Cgf6Ko.js}

@@ -1,4 +1,4 @@
-import { stat } from "node:fs/promises";
+import { i as toPosix, n as isDirectory } from "./fs-BmPtmFke.js";
 import path from "node:path";
 import { glob } from "tinyglobby";
 //#region src/audit/routes.ts
@@ -49,7 +49,7 @@ const CONVENTIONS = [
 * without knowing the data behind it.
 */
 function routePathFor(relativeFile, framework) {
-	let route = relativeFile.split(path.sep).join("/");
+	let route = toPosix(relativeFile);
 	if (framework === "next-app" || framework === "sveltekit") route = route.includes("/") ? route.replace(/\/[^/]+$/, "") : "";
 	else {
 		route = route.replace(/\.[^./]+$/, "");
@@ -90,11 +90,7 @@ function emittedPathsFor(route) {
 async function buildRouteMap(cwd) {
 	for (const convention of CONVENTIONS) {
 		const directory = path.join(cwd, convention.dir);
-		try {
-			if (!(await stat(directory)).isDirectory()) continue;
-		} catch {
-			continue;
-		}
+		if (!await isDirectory(directory)) continue;
 		const files = await glob([convention.pattern], {
 			cwd: directory,
 			ignore: ["**/node_modules/**"],
@@ -105,7 +101,7 @@ async function buildRouteMap(cwd) {
 		for (const file of files) {
 			const route = routePathFor(file, convention.framework);
 			if (route === void 0) continue;
-			const source = `${convention.dir}/${file.split(path.sep).join("/")}`;
+			const source = `${convention.dir}/${toPosix(file)}`;
 			for (const emitted of emittedPathsFor(route)) if (!sources.has(emitted)) sources.set(emitted, source);
 		}
 		if (sources.size > 0) return {

package/dist/run-BMASMmwO.d.ts

@@ -0,0 +1,45 @@
+import { t as ImpactLevel } from "./impact-EEB9ZXmC.js";
+//#region src/cli/audit.d.ts
+declare const OUTPUT_FORMATS: readonly ['console', 'json', 'sarif', 'html'];
+type OutputFormat = (typeof OUTPUT_FORMATS)[number];
+//#endregion
+//#region src/integration/run.d.ts
+/**
+ * What a build-time integration does once the build has written its files.
+ *
+ * Astro, Vite and Next all reach the same point by different routes: a
+ * directory exists, and the build should stop if what is in it fails the
+ * threshold. Only the hook name and the logger differ, so only those live in
+ * the integrations.
+ */
+interface IntegrationOptions {
+  /** Lowest impact that fails the build. Defaults to 'serious'. */
+  failOn?: ImpactLevel;
+  include?: string[];
+  exclude?: string[];
+  baseUrl?: string;
+  /** Audit in real Chromium. Needs the playwright peer. */
+  browser?: boolean;
+  concurrency?: number;
+  baseline?: string;
+  format?: OutputFormat;
+  /** Write the report here instead of the build log. */
+  output?: string;
+  /**
+   * Report without failing the build. For the week it takes to adopt this on a
+   * site that already exists — a baseline is the honest way to go green after
+   * that.
+   */
+  failBuild?: boolean;
+  /** Skip entirely. For turning it off per environment without unwiring it. */
+  enabled?: boolean;
+}
+/**
+ * Thrown to fail the build. Its own class so a consumer can tell an audit
+ * failure from the build tool falling over.
+ */
+declare class BuildAuditError extends Error {
+  readonly name = "BuildAuditError";
+}
+//#endregion
+export { IntegrationOptions as n, BuildAuditError as t };