eaa-kit 0.3.0 → 0.4.0

package/dist/remediation-Dtowi2EC.js

@@ -0,0 +1,321 @@
+import { a as impactRank } from "./impact-DZt2oBCP.js";
+import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
+import { a as findingElements } from "./result-DoamKFsp.js";
+//#region src/audit/completeness.ts
+/**
+* Fold what the collector knew together with what the engine managed.
+*
+* The audits carry the second half: a page with an `error` was collected and
+* then not audited, and is as unmeasured as one that was never fetched.
+*/
+function runCompleteness(audits, collection) {
+	const errored = audits.filter((audit) => audit.error).length;
+	return {
+		...collection,
+		audited: audits.length - errored,
+		errored,
+		complete: collection.unreachable.length === 0 && !collection.truncated && errored === 0
+	};
+}
+/**
+* What was missed, as phrases both reports print.
+*
+* Separate clauses rather than one total, for the same reason the coverage
+* parts are: a page that could not be fetched and a page that could not be
+* parsed are different problems with different fixes, and summing them would
+* name neither.
+*/
+function missedParts(completeness) {
+	const parts = [];
+	if (completeness.unreachable.length > 0) parts.push(`${completeness.unreachable.length} could not be reached`);
+	if (completeness.errored > 0) parts.push(`${completeness.errored} could not be audited`);
+	if (completeness.truncated) parts.push("the run stopped at its page limit");
+	return parts;
+}
+/** How the pages were found, in words, for the run details both reports show. */
+function discoveryLabel(discovery) {
+	switch (discovery) {
+		case "directory": return "files in the build directory";
+		case "sitemap": return "sitemap.xml and links";
+		case "links": return "links from the entry page";
+	}
+}
+/** 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/remediation.ts
+/**
+* Swap or add an attribute on the opening tag of the failing element.
+*
+* String surgery rather than a parser: the input is one element as axe-core
+* captured it, the output is shown to a person rather than written to disk, and
+* pulling in a parser to produce a suggestion would cost more than it is worth.
+*/
+function withAttribute(html, attribute, value) {
+	const openingTag = /^<([a-zA-Z][\w-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/.exec(html.trim());
+	if (openingTag === null) return void 0;
+	const [, tag = "", raw = ""] = openingTag;
+	const selfClosing = /\/\s*$/.test(raw) ? " /" : "";
+	const attributes = raw.replace(/\s*\/\s*$/, "");
+	const existing = new RegExp(`\\s${attribute}\\s*=\\s*("[^"]*"|'[^']*')`, "i");
+	const replacement = `${attribute}="${value}"`;
+	return `<${tag}${existing.test(attributes) ? attributes.replace(existing, ` ${replacement}`) : `${attributes} ${replacement}`}${selfClosing}>`;
+}
+/** Put text between the tags of an element that has none. */
+function withContent(html, content) {
+	const opening = /^<([a-zA-Z][\w-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/.exec(html.trim());
+	if (opening === null) return void 0;
+	const [matched, tag = ""] = opening;
+	return `${matched}${content}</${tag}>`;
+}
+/**
+* The generic fix for a rule, whatever built the site.
+*
+* Scoped to the rules that actually fire on real sites. A table covering every
+* axe-core rule would be mostly entries nobody reads, and each one is a claim
+* this project has to keep true.
+*/
+const GENERIC = {
+	"image-alt": {
+		why: "A screen reader announces this image by its filename, or skips it entirely.",
+		fix: "Add alt text describing what the image conveys. If it is decorative and repeats adjacent text, use alt=\"\" so it is skipped deliberately rather than by accident.",
+		example: (html) => withAttribute(html, "alt", "What this image shows")
+	},
+	"link-name": {
+		why: "A screen reader announces this as \"link\" with nothing after it, so where it goes is unknowable without following it.",
+		fix: "Give the link text. Where the design calls for an icon alone, keep the visible icon and add a visually hidden label or an aria-label.",
+		example: (html) => withContent(html, "Where this link goes")
+	},
+	"button-name": {
+		why: "A screen reader announces this as \"button\" with nothing after it, so what it does is unknowable without pressing it.",
+		fix: "Give the button text, or an aria-label where it shows only an icon.",
+		example: (html) => withContent(html, "What this button does")
+	},
+	"html-has-lang": {
+		why: "A screen reader reads the page in whatever language it defaults to, so German content is read with English pronunciation rules and is close to unintelligible.",
+		fix: "Set the lang attribute on <html> to the language the page is written in.",
+		example: (html) => withAttribute(html, "lang", "de")
+	},
+	"html-lang-valid": {
+		why: "An unrecognised language tag leaves a screen reader guessing, with the same result as no tag at all.",
+		fix: "Use a valid BCP 47 tag: de, de-AT, en-GB.",
+		example: (html) => withAttribute(html, "lang", "de-AT")
+	},
+	"document-title": {
+		why: "The title is the first thing a screen reader announces and what a tab and a bookmark show. Without one, every page of the site is indistinguishable from every other.",
+		fix: "Add a <title> to the document head, naming this page before the site."
+	},
+	label: {
+		why: "A screen reader announces this field with no name, so what to type in it is unknowable.",
+		fix: "Give the field a <label for=\"…\">, or an aria-label where the design has no visible label. A placeholder is not a label: it disappears as soon as somebody types."
+	},
+	"form-field-multiple-labels": {
+		why: "Screen readers disagree about which label to announce, so what somebody hears depends on their software.",
+		fix: "Leave one label on the field and fold the rest into it, or into aria-describedby."
+	},
+	"aria-allowed-attr": {
+		why: "An ARIA attribute its role does not permit is ignored or, worse, changes how the element is announced in a way nobody intended.",
+		fix: "Remove the attribute, or change the role to one that allows it."
+	},
+	"aria-required-attr": {
+		why: "The role promises state that is not there, so a screen reader announces a control without saying whether it is checked, expanded or selected.",
+		fix: "Add the attributes the role requires, and keep them in step with the state as it changes."
+	},
+	"aria-valid-attr-value": {
+		why: "An aria-labelledby or aria-describedby pointing at an id that is not on the page leaves the element with no name at all.",
+		fix: "Point it at an element that exists, or drop the attribute and label the element directly."
+	},
+	"aria-hidden-focus": {
+		why: "The element is hidden from screen readers and still reachable by keyboard, so somebody tabbing through the page lands on something their software cannot describe.",
+		fix: "Remove aria-hidden, or take the element out of the tab order with tabindex=\"-1\" and by disabling the control."
+	},
+	"heading-order": {
+		why: "Headings are how screen reader users navigate a page. A level skipped reads as a missing section.",
+		fix: "Step heading levels one at a time. Where the jump was for visual size, keep the level and set the size in CSS."
+	},
+	"empty-heading": {
+		why: "It appears in the heading list a screen reader user navigates by, with nothing to read.",
+		fix: "Give the heading text, or remove it and style the surrounding element instead."
+	},
+	"landmark-one-main": {
+		why: "Without a main landmark there is no \"skip to content\": a screen reader user hears the whole navigation again on every page.",
+		fix: "Wrap the page content in <main>, once per page."
+	},
+	region: {
+		why: "Content outside a landmark cannot be reached by landmark navigation, so it is only found by reading the page from the top.",
+		fix: "Put the content inside <header>, <nav>, <main> or <footer>."
+	},
+	list: {
+		why: "A screen reader announces \"list, N items\" and lets somebody skip it. Anything else between the <li>s breaks that count.",
+		fix: "Make every direct child of <ul> or <ol> an <li>, and move anything else inside one."
+	},
+	listitem: {
+		why: "An <li> outside a list is announced as ordinary text, so the grouping the layout implies is not there for anybody who cannot see it.",
+		fix: "Put the item inside a <ul> or <ol>."
+	},
+	"duplicate-id-aria": {
+		why: "ARIA references resolve to the first match, so one of these elements is silently labelled by the wrong thing.",
+		fix: "Make the ids unique. Where they come from a component rendered more than once, derive the id from a prop or a generated suffix."
+	},
+	"color-contrast": {
+		why: "Text this close to its background is unreadable for many people with low vision, and for anybody in bright sunlight.",
+		fix: "Raise the contrast to 4.5:1 for body text, or 3:1 for large or bold text. Check hover, focus, visited, disabled and placeholder states too — those are the ones usually missed."
+	},
+	"link-in-text-block": {
+		why: "A link distinguished from its paragraph by colour alone is invisible to somebody who cannot distinguish those colours.",
+		fix: "Underline links inside paragraphs, or give them a 3:1 contrast difference against the surrounding text as well as against the background."
+	},
+	"target-size": {
+		why: "A target this small is hard to hit for anybody with a tremor, and for everybody on a phone.",
+		fix: "Make the clickable area at least 24×24 CSS pixels, with padding rather than a bigger icon."
+	},
+	"frame-title": {
+		why: "A screen reader announces an untitled frame as \"frame\", so what is in it is unknowable without entering it.",
+		fix: "Add a title attribute saying what the frame contains.",
+		example: (html) => withAttribute(html, "title", "What this frame contains")
+	},
+	"meta-viewport": {
+		why: "Blocking zoom stops anybody who needs larger text from reading the page at all on a phone.",
+		fix: "Remove user-scalable=no and any maximum-scale below 5 from the viewport meta tag.",
+		example: (html) => withAttribute(html, "content", "width=device-width, initial-scale=1")
+	}
+};
+/**
+* Fixes that genuinely differ by framework.
+*
+* Deliberately short. Everything absent here is covered by the generic entry,
+* because for most rules the correction is identical whatever produced the
+* markup, and a per-framework table full of restatements would be a maintenance
+* cost with no reader.
+*/
+const BY_FRAMEWORK = {
+	next: {
+		"image-alt": { fix: "next/image requires alt, so an empty one here means it was set to '' or a plain <img> was used. Give it a real alt, or alt=\"\" only where the image repeats adjacent text." },
+		"html-has-lang": { fix: "Set lang on the <html> element in app/layout.tsx (App Router) or pages/_document.tsx (Pages Router). Setting it in a page component will not reach the document." }
+	},
+	nuxt: {
+		"html-has-lang": { fix: "Set app.head.htmlAttrs.lang in nuxt.config.ts, or call useHead({ htmlAttrs: { lang: 'de' } }) in app.vue." },
+		"link-name": { fix: "Give the <NuxtLink> content, or an aria-label where it renders an icon alone." }
+	},
+	astro: {
+		"html-has-lang": { fix: "Set lang on the <html> element in your layout under src/layouts, not in the individual page." },
+		"image-alt": { fix: "Astro's <Image /> requires alt. Give it one describing what the image conveys, or alt=\"\" where it repeats adjacent text." }
+	},
+	sveltekit: { "html-has-lang": { fix: "Set lang on the <html> element in src/app.html, which is the template every route is rendered into." } },
+	remix: { "html-has-lang": { fix: "Set lang on the <html> element in the root route (app/root.tsx), which renders the document shell." } }
+};
+/**
+* What to do about a rule, in this project's idiom where that differs.
+*
+* `framework` is the registry id from `detectFramework`. An unknown one, or
+* none, falls through to the generic advice rather than to nothing: the fix for
+* most rules does not depend on what built the page.
+*/
+function remediationFor(ruleId, framework) {
+	const generic = GENERIC[ruleId];
+	const specific = framework === void 0 ? void 0 : BY_FRAMEWORK[framework]?.[ruleId];
+	if (generic === void 0) return void 0;
+	return specific === void 0 ? generic : {
+		...generic,
+		...specific
+	};
+}
+//#endregion
+export { isShared as a, runCompleteness as c, groupIssues as i, blindRules as n, discoveryLabel as o, coverageParts as r, missedParts as s, remediationFor as t };

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

@@ -1,7 +1,7 @@
-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 { c as number, f as record, l as object, m as string, o as isoDateTime, p as safeParse, s as nullable, t as array, v as withDefault } from "./schema-is6CGX2D.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 { a as impactRank, n as IMPACT_LEVELS } from "./impact-DZt2oBCP.js";
+import { i as escapeText, o as standardsReference, r as escapeAttribute } from "./text-CKKpzkYM.js";
 import { t as TOOL_VERSION } from "./version-B3v4rNoG.js";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";

package/dist/{result-DLxd2Eip.js → result-DoamKFsp.js}

@@ -10,6 +10,83 @@ const DEFAULT_TAGS = [
 	"wcag22aa"
 ];
 /**
+* Rules this engine structurally cannot decide.
+*
+* jsdom has no layout: every element reports a 0x0 box, computed style is
+* limited to the inline cascade, and nothing is ever fetched. axe-core does not
+* know that, so it happily returns `pass` for some of these — `target-size`
+* passes on any page because a 0x0 target gets measured against nothing, and
+* `color-contrast` passes on pages whose colours were never computed. Both were
+* observed on real sites. Reporting either as a pass would be a false clean
+* bill of health, so every rule listed here is force-reported as incomplete no
+* matter which bucket axe-core put it in.
+*
+* The browser runner passes an empty map instead: with real layout these rules
+* are exactly the ones it exists to answer.
+*
+* Rules tagged `experimental` are listed for completeness but filtered out at
+* scope time: axe-core does not run them by default, so a browser run would not
+* evaluate them either and telling the user to re-run with --browser would be
+* misleading.
+*/
+const ENGINE_BLIND_RULES = {
+	"color-contrast": {
+		detail: "needs rendered foreground and background colours",
+		applicabilityUnreliable: false
+	},
+	"color-contrast-enhanced": {
+		detail: "needs rendered foreground and background colours",
+		applicabilityUnreliable: false
+	},
+	"target-size": {
+		detail: "needs element geometry; every box is 0x0 without layout",
+		applicabilityUnreliable: false
+	},
+	"scrollable-region-focusable": {
+		detail: "needs computed overflow",
+		applicabilityUnreliable: true
+	},
+	"link-in-text-block": {
+		detail: "needs rendered colours and text decoration",
+		applicabilityUnreliable: true
+	},
+	"no-autoplay-audio": {
+		detail: "needs media duration, and media is never loaded",
+		applicabilityUnreliable: true
+	},
+	"avoid-inline-spacing": {
+		detail: "needs computed spacing after the full cascade",
+		applicabilityUnreliable: false
+	},
+	"p-as-heading": {
+		detail: "needs computed font size and weight",
+		applicabilityUnreliable: false
+	},
+	"css-orientation-lock": {
+		detail: "needs CSS media query evaluation",
+		applicabilityUnreliable: true
+	}
+};
+const blindScopeCache = /* @__PURE__ */ new Map();
+/**
+* Blind rules the requested tag filter would actually have run. Experimental
+* rules are excluded: axe-core leaves them off by default, so a browser run
+* would not have evaluated them either.
+*/
+function blindRulesInScope(tags) {
+	const key = [...tags].sort().join(",");
+	const cached = blindScopeCache.get(key);
+	if (cached) return cached;
+	const inScope = /* @__PURE__ */ new Map();
+	for (const rule of axe.getRules([...tags])) {
+		if (rule.tags.includes("experimental")) continue;
+		const blind = ENGINE_BLIND_RULES[rule.ruleId];
+		if (blind) inScope.set(rule.ruleId, blind);
+	}
+	blindScopeCache.set(key, inScope);
+	return inScope;
+}
+/**
 * 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.
 */
@@ -202,4 +279,4 @@ function enClauses(tags) {
 	return [...clauses].sort();
 }
 //#endregion
-export { ruleOutcomes as a, pageUrl as i, failedPage as n, runOptions as o, findingElements as r, shapeResults as s, DEFAULT_TAGS as t };
+export { findingElements as a, runOptions as c, failedPage as i, shapeResults as l, ENGINE_BLIND_RULES as n, pageUrl as o, blindRulesInScope as r, ruleOutcomes as s, DEFAULT_TAGS as t, successCriteria as u };

package/dist/routes-CmdRUuOs.js

@@ -0,0 +1,265 @@
+import { i as toPosix, n as isDirectory } from "./fs-BmPtmFke.js";
+import { i as detectFramework } from "./frameworks-B4ClIJgE.js";
+import { i as readPackageJson } from "./project-CzOnkLH6.js";
+import path from "node:path";
+import { glob } from "tinyglobby";
+//#region src/audit/routes.ts
+/**
+* A path segment that serves more than one page, or none.
+*
+* Dynamic segments are refused rather than resolved: `[slug]` stands for every
+* post there is, and picking one would name a file that did not produce the
+* page in front of the reader. Private and slot folders contribute no route at
+* all.
+*/
+function classifyBracketSegment(segment) {
+	if (/^\(.*\)$/.test(segment)) return "skip";
+	if (/^[[(]|^_|^@/.test(segment)) return "refuse";
+	return "route";
+}
+/** Drop the extension, and fold an index file into the directory it sits in. */
+function withoutExtension(file) {
+	const route = file.replace(/\.[^./]+$/, "").replace(/\/index$/, "");
+	return route === "index" ? "" : route;
+}
+/** The directory a route file sits in, for routers that put the route there. */
+function containingDirectory(file) {
+	return file.includes("/") ? file.replace(/\/[^/]+$/, "") : "";
+}
+/** Keep the segments that are routes, refusing the file if any is dynamic. */
+function joinSegments(route) {
+	const kept = [];
+	for (const segment of route.split("/").filter((part) => part !== "")) {
+		const kind = classifyBracketSegment(segment);
+		if (kind === "refuse") return void 0;
+		if (kind === "skip") continue;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/** `pages/kontakt.tsx` serves `/kontakt`; the filename is the route. */
+function fileNamedRoute(file) {
+	return joinSegments(withoutExtension(file));
+}
+/** `app/kontakt/page.tsx` serves `/kontakt`; the directory is the route. */
+function directoryNamedRoute(file) {
+	return joinSegments(containingDirectory(file));
+}
+/**
+* A documentation tree whose directory layout is the URL layout.
+*
+* No dynamic segments to worry about — these are files an author wrote, one per
+* page — so the only work is folding the index file into its directory.
+*/
+function mirroredRoute(file) {
+	return withoutExtension(file);
+}
+/**
+* Remix and React Router flat routes: `blog.post.tsx` serves `/blog/post`.
+*
+* The dot is the separator, `_index` is a directory's own page, and a trailing
+* underscore on a segment escapes a parent layout without changing the URL. A
+* `$` segment is dynamic and refused, as `[slug]` is elsewhere.
+*/
+function remixRoute(file) {
+	const withoutRouteFile = file.replace(/\/route\.[^./]+$/, "");
+	const flat = withoutRouteFile === file ? withoutExtension(file) : toPosix(withoutRouteFile);
+	const leaf = flat.includes("/") ? flat.split("/").pop() : flat;
+	if (leaf === "") return void 0;
+	const kept = [];
+	for (const raw of leaf.split(".")) {
+		const segment = raw.replace(/_$/, "");
+		if (segment === "") continue;
+		if (segment === "_index") continue;
+		if (segment.startsWith("$")) return void 0;
+		if (segment.includes("[")) return void 0;
+		kept.push(segment);
+	}
+	return kept.join("/");
+}
+/**
+* Hugo content: `content/posts/hello.md` serves `/posts/hello/`.
+*
+* `_index.md` is a section's own page rather than a page called `_index`, which
+* is the one place Hugo's leading underscore does not mean "private".
+*/
+function hugoRoute(file) {
+	const withoutIndex = file.replace(/(^|\/)_index\.[^./]+$/, "");
+	if (withoutIndex !== file) return toPosix(withoutIndex);
+	return withoutExtension(file);
+}
+/**
+* Conventions, most specific first.
+*
+* Order still matters where the registry knows nothing about a project, which
+* is the case for a plain directory of HTML and for anything the registry has
+* not heard of.
+*/
+const CONVENTIONS = [
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "next-app",
+		ids: ["next"],
+		dir: "src/app",
+		pattern: "**/page.{tsx,ts,jsx,js,mdx}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "remix",
+		ids: ["remix"],
+		dir: "app/routes",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: remixRoute
+	},
+	{
+		framework: "starlight",
+		ids: ["astro"],
+		dir: "src/content/docs",
+		pattern: "**/*.{md,mdx,mdoc}",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "astro",
+		ids: ["astro"],
+		dir: "src/pages",
+		pattern: "**/*.{astro,md,mdx,html}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "gatsby",
+		ids: ["gatsby"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,md,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "next-pages",
+		ids: ["next"],
+		dir: "src/pages",
+		pattern: "**/*.{tsx,ts,jsx,js,mdx}",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "nuxt",
+		ids: ["nuxt"],
+		dir: "pages",
+		pattern: "**/*.vue",
+		toRoute: fileNamedRoute
+	},
+	{
+		framework: "sveltekit",
+		ids: ["sveltekit"],
+		dir: "src/routes",
+		pattern: "**/+page.{svelte,ts,js}",
+		toRoute: directoryNamedRoute
+	},
+	{
+		framework: "docusaurus",
+		ids: ["docusaurus"],
+		dir: "docs",
+		pattern: "**/*.{md,mdx}",
+		toRoute: (file) => {
+			const route = mirroredRoute(file);
+			return route === void 0 ? void 0 : route === "" ? "docs" : `docs/${route}`;
+		}
+	},
+	{
+		framework: "vitepress",
+		ids: ["vitepress"],
+		dir: "docs",
+		pattern: "**/*.md",
+		toRoute: mirroredRoute
+	},
+	{
+		framework: "hugo",
+		ids: ["hugo"],
+		dir: "content",
+		pattern: "**/*.{md,html}",
+		toRoute: hugoRoute
+	}
+];
+/** Every page path a build could have emitted for one route. */
+function emittedPathsFor(route) {
+	if (route === "") return [
+		"/",
+		"index.html",
+		"index.htm"
+	];
+	return [
+		route,
+		`${route}/`,
+		`${route}.html`,
+		`${route}/index.html`
+	];
+}
+/**
+* Build a page-to-source map by reading the project's route files.
+*
+* Returns undefined when the project uses no convention this understands, which
+* is not a failure — most builds are not framework projects.
+*/
+async function buildRouteMap(cwd, pkg) {
+	for (const convention of await orderedConventions(cwd, pkg)) {
+		const map = await mapConvention(cwd, convention);
+		if (map !== void 0) return map;
+	}
+}
+/**
+* Conventions to try, the detected framework's first.
+*
+* Without this, `src/pages` is claimed by whichever convention is declared
+* earliest, so a Gatsby project was reported as `next-pages`. The mapping
+* happened to be right and the name was wrong, which is the kind of detail a
+* reader notices and stops trusting the rest of the report over.
+*/
+async function orderedConventions(cwd, pkg) {
+	const detected = await detectFramework(cwd, pkg ?? await readPackageJson(cwd));
+	if (detected === void 0) return [...CONVENTIONS];
+	const id = detected.framework.id;
+	const mine = CONVENTIONS.filter((convention) => convention.ids.includes(id));
+	const rest = CONVENTIONS.filter((convention) => !convention.ids.includes(id));
+	return [...mine, ...rest];
+}
+/** Read one convention's directory, or undefined when it has nothing to say. */
+async function mapConvention(cwd, convention) {
+	const directory = path.join(cwd, convention.dir);
+	if (!await isDirectory(directory)) return void 0;
+	const files = await glob([convention.pattern], {
+		cwd: directory,
+		ignore: ["**/node_modules/**"],
+		onlyFiles: true
+	});
+	if (files.length === 0) return void 0;
+	const sources = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const route = convention.toRoute(toPosix(file));
+		if (route === void 0) continue;
+		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 void 0;
+	return {
+		framework: convention.framework,
+		sources
+	};
+}
+/** The source file for an audited page, if the map knows one. */
+function sourceFor(map, pagePath) {
+	if (map === void 0) return void 0;
+	return map.sources.get(pagePath) ?? map.sources.get(pagePath.replace(/^\//, ""));
+}
+//#endregion
+export { buildRouteMap, sourceFor };