eaa-kit 0.3.0 → 0.5.0

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

@@ -1,5 +1,5 @@
 import { r as isFile } from "./fs-BmPtmFke.js";
-import { i as pageUrl, n as failedPage } from "./result-DLxd2Eip.js";
+import { a as failedPage, s as pageUrl } from "./result-BWcYXeRs.js";
 import { Worker } from "node:worker_threads";
 import { availableParallelism } from "node:os";
 //#region src/audit/runners/pool.ts
@@ -52,6 +52,16 @@ const WORK_PER_WORKER_MS = 1600;
 /** Threading at all means at least two, or there is nothing to overlap with. */
 const MIN_WORKERS = 2;
 /**
+* Grace above the runner's own per-page timeout before a worker is killed.
+*
+* The runner races axe-core against a timer, which works whenever the work
+* yields to the event loop: the page is reported with an error and the thread
+* lives on to take the next one. That is the better outcome, so it is given
+* room to happen first. This is the backstop for when it cannot — see
+* `watchdog` below.
+*/
+const HARD_TIMEOUT_GRACE_MS = 5e3;
+/**
 * Ceiling on workers regardless of core count. Past this, the run is bounded by
 * memory bandwidth and by each worker's own start-up rather than by cores, and
 * every extra thread holds another jsdom document tree.
@@ -96,10 +106,33 @@ 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-X4KYfTp8.js");
+	const { runJsdomAudit } = await import("./jsdom-22Bkt65v.js");
 	return runJsdomAudit(pages, options);
 }
+/**
+* The only place a per-page ceiling can actually be enforced.
+*
+* The runner's own timeout is a `Promise.race`, and a race cannot interrupt
+* synchronous work: jsdom's parse and axe-core's walk of the tree both hold the
+* thread, so the timer that is meant to stop them never gets to run. Measured
+* on a 120,000-element document with a two-second ceiling, the audit was still
+* going more than ten minutes later — and because the pool waits on its
+* workers, the whole run went with it. A CI job hung until the platform killed
+* it, which is the failure the ceiling exists to prevent.
+*
+* `worker.terminate()` is the answer, because it stops the thread whatever it
+* is doing. So the supervisor keeps its own deadline per page and kills the
+* thread that overruns it, records that page as unaudited, and lets the rest of
+* the run carry on. The page is reported as a failure rather than as a clean
+* page, which the CLI already turns into exit 2.
+*
+* Two runs still have no hard ceiling, because both refuse the threads that
+* would carry it: `--concurrency 1`, and a machine with too few cores to spare
+* one. Both are documented rather than papered over, and the size cap in
+* `collectPages` is what keeps them bounded in practice.
+*/
 async function runWorkers(pages, options, count, entry) {
+	const deadlineMs = (options.timeoutMs ?? 3e4) + HARD_TIMEOUT_GRACE_MS;
 	const audits = Array.from({ length: pages.length });
 	let next = 0;
 	await Promise.all(Array.from({ length: count }, () => {
@@ -113,7 +146,13 @@ async function runWorkers(pages, options, count, entry) {
 			}
 			let inFlight;
 			let completed = 0;
+			let watchdog;
+			const disarm = () => {
+				if (watchdog !== void 0) clearTimeout(watchdog);
+				watchdog = void 0;
+			};
 			const finish = () => {
+				disarm();
 				worker.terminate();
 				resolve();
 			};
@@ -127,8 +166,18 @@ async function runWorkers(pages, options, count, entry) {
 				next += 1;
 				inFlight = index;
 				worker.postMessage(pages[index]);
+				watchdog = setTimeout(() => {
+					watchdog = void 0;
+					if (inFlight !== void 0) {
+						audits[inFlight] = failedPage(identity(pages[inFlight], options), `the audit worker was stopped after ${deadlineMs}ms on this page`);
+						inFlight = void 0;
+					}
+					finish();
+				}, deadlineMs);
+				watchdog.unref?.();
 			};
 			worker.on("message", (audit) => {
+				disarm();
 				if (inFlight !== void 0) {
 					audits[inFlight] = audit;
 					completed += 1;
@@ -136,6 +185,7 @@ async function runWorkers(pages, options, count, entry) {
 				feed();
 			});
 			worker.on("error", (cause) => {
+				disarm();
 				if (inFlight !== void 0 && completed > 0) audits[inFlight] = failedPage(identity(pages[inFlight], options), `audit worker failed: ${cause.message}`);
 				finish();
 			});

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

@@ -1,5 +1,5 @@
 import { n as isDirectory, t as exists } from "./fs-BmPtmFke.js";
-import { r as candidateOutputs } from "./frameworks-BYa3tULg.js";
+import { r as candidateOutputs } from "./frameworks-B4ClIJgE.js";
 import { readFile } from "node:fs/promises";
 import path from "node:path";
 import { glob } from "tinyglobby";
@@ -226,6 +226,12 @@ async function autoDetectSource(cwd, options = {}) {
 		};
 	}
 	const pkg = await readPackageJson(cwd);
+	const { detectFramework } = await import("./frameworks-etFg_O8K.js");
+	const detected = await detectFramework(cwd, pkg);
+	if (detected !== void 0 && detected.framework.outputs.length === 0) {
+		step(`${detected.framework.name} renders on a server and writes no HTML to disk`);
+		return { steps };
+	}
 	if (pkg === void 0) return void 0;
 	const scripts = pkg.scripts ?? {};
 	if (options.noBuild) return void 0;
@@ -265,4 +271,4 @@ async function autoDetectSource(cwd, options = {}) {
 	};
 }
 //#endregion
-export { autoDetectSource, readPackageJson };
+export { runScript as a, readPackageJson as i, detectPackageManager as n, startServer as o, findBuildOutput as r, autoDetectSource as t };

package/dist/project-MFrXcw1M.js

@@ -0,0 +1,2 @@
+import { i as readPackageJson, t as autoDetectSource } from "./project-CzOnkLH6.js";
+export { autoDetectSource, readPackageJson };

package/dist/remediation-CMBIrnpN.js

@@ -0,0 +1,321 @@
+import { a as impactRank } from "./impact-DZt2oBCP.js";
+import { t as elementFingerprint } from "./fingerprint-BjYV_0F7.js";
+import { o as findingElements } from "./result-BWcYXeRs.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-DbGOVmhx.js}

@@ -1,7 +1,8 @@
-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 { a as impactRank, n as IMPACT_LEVELS } from "./impact-DZt2oBCP.js";
+import { c as nullable, h as string, l as number, m as safeParse, p as record, s as isoDateTime, t as array, u as object, y as withDefault } from "./schema-DJSF4K05.js";
+import { u as STATEMENT_LOCALES } from "./load-yAR4wzez.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 { 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";
@@ -58,7 +59,7 @@ function summariseAuditReport(value, source = "audit report") {
 	const result = safeParse(reportSchema, value);
 	if (!result.success) throw new StatementError(`${source} is not an eaa-kit JSON report (${result.error.issues.map((issue) => `${issue.path.join(".") || "document"}: ${issue.message}`).slice(0, 5).join("; ")})`);
 	const report = result.data;
-	if (report.schemaVersion !== 1) throw new StatementError(`${source} has schemaVersion ${report.schemaVersion}; this version of eaa-kit reads 1`);
+	if (report.schemaVersion !== 2) throw new StatementError(`${source} has schemaVersion ${report.schemaVersion}; this version of eaa-kit reads 2`);
 	const byRule = /* @__PURE__ */ new Map();
 	const rules = new Map(Object.entries(report.rules));
 	for (const page of report.pages) for (const violation of page.violations) {
@@ -411,7 +412,7 @@ async function renderStatement(config, options = {}) {
 	const country = options.country ?? config.enforcement.country;
 	const locale = options.locale ?? defaultLocale(config);
 	const template = `${country.toLowerCase()}.${locale}`;
-	const markdown = tidy(renderTemplate(await loadTemplate(template), buildScope(config, locale, options.audit)));
+	const markdown = tidy(renderTemplate(await loadTemplate(country, locale), buildScope(config, locale, options.audit)));
 	return {
 		markdown,
 		html: toHtmlDocument(markdown, {
@@ -423,9 +424,16 @@ async function renderStatement(config, options = {}) {
 		template
 	};
 }
-/** A German-language site gets a German statement unless told otherwise. */
+/**
+* A site gets its statement in its own language where there is one for it.
+*
+* From `site.locale`, which is a BCP 47 tag: `de-AT` and `de` both mean the
+* German document. English is the fallback because every country has an English
+* template, being the language a statement is most often also published in.
+*/
 function defaultLocale(config) {
-	return config.site.locale.toLowerCase().startsWith("de") ? "de" : "en";
+	const language = config.site.locale.toLowerCase().split("-")[0];
+	return STATEMENT_LOCALES.find((candidate) => candidate === language) ?? "en";
 }
 /**
 * Values the templates interpolate.
@@ -522,6 +530,22 @@ function reasonScope(reason) {
 	};
 }
 /**
+* Where each statement language formats its dates.
+*
+* A region is named for every one, because a bare language tag leaves the
+* format to whatever ICU picks: `de` is de-DE, and this tool's German documents
+* have always been dated the Austrian way. `en-GB` for the same reason —
+* 20 August 2026, not August 20, 2026, in a European legal document.
+*/
+const DATE_LOCALES = {
+	de: "de-AT",
+	en: "en-GB",
+	es: "es-ES",
+	fr: "fr-FR",
+	it: "it-IT",
+	nl: "nl-NL"
+};
+/**
 * 2026-08-20 becomes 20. August 2026 or 20 August 2026.
 *
 * Every date reaching this has been through a schema that checks it, so the
@@ -533,7 +557,7 @@ function reasonScope(reason) {
 function formatDate(iso, locale) {
 	const date = /* @__PURE__ */ new Date(`${iso}T00:00:00Z`);
 	if (Number.isNaN(date.getTime())) return iso;
-	return new Intl.DateTimeFormat(locale === "de" ? "de-AT" : "en-GB", {
+	return new Intl.DateTimeFormat(DATE_LOCALES[locale], {
 		day: "numeric",
 		month: "long",
 		year: "numeric",
@@ -549,14 +573,28 @@ function tidy(markdown) {
 	return `${markdown.replace(/[ \t]+$/gm, "").replace(/\n{3,}/g, "\n\n").trim()}\n`;
 }
 let templateDirectory;
-async function loadTemplate(name) {
+/**
+* The document for a country in a language, if there is one.
+*
+* The matrix is deliberately sparse: a country's statement is written under its
+* own law and published in the language the law is administered in, plus
+* English. Asking for a combination nobody wrote is an error naming the
+* languages that country does have — not a fall back to another language, which
+* would hand somebody a document in a language their readers may not have and
+* do it quietly.
+*/
+async function loadTemplate(country, locale) {
 	templateDirectory ??= await findTemplateDirectory();
 	const directory = templateDirectory;
+	const name = `${country.toLowerCase()}.${locale}`;
 	const file = path.join(directory, `${name}.md`);
 	try {
 		return await readFile(file, "utf8");
 	} catch {
-		throw new StatementError(`No statement template for ${name}. Available: ${(await readdir(directory)).filter((entry) => entry.endsWith(".md")).map((entry) => entry.replace(/\.md$/, "")).sort().join(", ")}`);
+		const templates = (await readdir(directory)).filter((entry) => entry.endsWith(".md")).map((entry) => entry.replace(/\.md$/, "")).sort();
+		const prefix = `${country.toLowerCase()}.`;
+		const forCountry = templates.filter((entry) => entry.startsWith(prefix)).map((entry) => entry.slice(prefix.length));
+		throw new StatementError(forCountry.length > 0 ? `No ${country} statement in ${locale}. ${country} has: ${forCountry.join(", ")}` : `No statement template for ${name}. Available: ${templates.join(", ")}`);
 	}
 }
 /**