eaa-kit 0.3.0 → 0.4.0

package/README.md

@@ -9,6 +9,7 @@ in Austria.
 
 ```bash
 npx eaa-kit audit                 # WCAG 2.2 AA report; finds your build itself
+npx eaa-kit diff a.json b.json    # what a change made worse, and what it fixed
 npx eaa-kit init                  # write an eaa.config.json
 npx eaa-kit statement             # Barrierefreiheitserklärung from that config
 ```
@@ -62,13 +63,54 @@ eaa-kit baseline ./dist
 eaa-kit audit ./dist --baseline eaa-baseline.json
 ```
 
+**Says what a change did.** Two reports, and the difference between them: what is new, what
+was fixed, and what the later run never looked at — which is kept apart, because a
+violation missing from a run that stopped early was not fixed by anybody.
+
+```bash
+eaa-kit diff before.json after.json
+```
+
+**Says what to do about it.** Not "images must have alternative text" and a link — who the
+barrier stops, what to change, and the corrected form of *your* markup, in your framework's
+idiom where that differs. Deterministic and offline: no model, no API key, nothing that
+could invent a fix that looks right and is not.
+
+```
+✗ image-alt critical, WCAG 1.1.1
+    A screen reader announces this image by its filename, or skips it entirely.
+    Fix: Add alt text describing what the image conveys…
+    → <img src="/assets/logo.svg" alt="What this image shows">
+    written in src/components/Header.astro:12
+```
+
+**Says how much of WCAG it could reach.** WCAG 2.2 has 55 success criteria at Levels A and
+AA. axe-core has rules touching 23 of them. Every run says so, and `--coverage` lists all
+55 with what this run reached on each — never as a percentage, because most of WCAG cannot
+be automated and a score would present that as a fact about your site.
+
+**Says what it did not measure.** A crawl that stopped at its page limit, or could not
+fetch forty URLs, no longer produces a report that looks like a complete one.
+
 **Reports in four shapes**: a console report for whoever ran it, JSON for other tools,
 SARIF for GitHub code scanning, and a self-contained HTML page for the client whose site
 it is.
 
-**Runs in your build**, as a [Vite plugin](docs/integrations.md#vite-plugin) — covering
-SvelteKit, Nuxt and Remix too — an [Astro integration](docs/integrations.md#astro-integration),
-or the bundled [GitHub Action](docs/integrations.md#github-actions).
+**Runs in your build**: a [Vite plugin](docs/integrations.md#vite-plugin) covering SvelteKit
+and Remix too, and integrations for
+[Astro](docs/integrations.md#astro-integration),
+[Nuxt](docs/integrations.md#nuxt-module),
+[Eleventy](docs/integrations.md#eleventy-plugin) and
+[webpack](docs/integrations.md#webpack-plugin) — or the bundled
+[GitHub Action](docs/integrations.md#github-actions).
+
+**Audits what a CMS serves.** WordPress, TYPO3, Craft, Laravel, Symfony, Rails and Django
+write no HTML to disk, so eaa-kit names the command that gets the site running and audits
+that instead — following the site's own sitemap, wherever it keeps it.
+
+```bash
+eaa-kit audit --url http://localhost:8000 --sitemap /sitemap_index.xml
+```
 
 ## Documentation
 
@@ -77,8 +119,10 @@ or the bundled [GitHub Action](docs/integrations.md#github-actions).
 | [Auditing a build](docs/audit.md) | The `audit` command, both engines, exit codes, and what an automated run can and cannot tell you |
 | [The statement command](docs/statement.md) | The config file, the three countries, and filling a statement from audit results |
 | [Baselines](docs/baseline.md) | Adopting the tool on a site that already has violations |
+| [Comparing two runs](docs/reports.md#comparing-two-runs) | The `diff` command, and what it refuses to call fixed |
+| [Coverage of WCAG](docs/audit.md#how-much-of-wcag-a-run-reaches) | What an automated engine can reach at all, and what it cannot |
 | [Report formats](docs/reports.md) | The JSON contract, SARIF, and the HTML report |
-| [Integrations](docs/integrations.md) | Astro and GitHub Actions |
+| [Integrations](docs/integrations.md) | The build plugins, the GitHub Action, and the two builders that get a command instead |
 
 Complete generated output for every format is checked in under [examples/](examples).
 
@@ -90,7 +134,9 @@ The two things worth knowing before you rely on any of it:
 text is accurate, whether a page makes sense in reading order, or whether a form can
 actually be completed with a screen reader. A clean report means nothing was found by this
 engine, which is not the same as a site being accessible — and none of the four output
-formats will say otherwise on your behalf.
+formats will say otherwise on your behalf. This is not a disclaimer the tool leaves you to
+take on faith: it counts it. Of the 55 WCAG 2.2 A and AA criteria, 34 have no automated
+rule at all, and every report says so.
 
 **The browserless engine cannot decide everything.** jsdom has no layout, so rules that
 depend on rendering — colour contrast, target size, computed overflow — cannot be

package/dist/astro/index.js

@@ -1,4 +1,4 @@
-import { n as auditBuild, t as BuildAuditError } from "../run-BW6CVuND.js";
+import { n as auditBuild, t as BuildAuditError } from "../run-DB34BSOZ.js";
 import { fileURLToPath } from "node:url";
 //#region src/astro/index.ts
 var AstroAuditError = class extends Error {

package/dist/audit/runners/worker.js

@@ -1,4 +1,4 @@
-import { n as auditPage } from "../../jsdom-BjpF-2V-.js";
+import { t as auditPage } from "../../jsdom-DCpGSLfW.js";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/audit/runners/worker.ts
 /**

package/dist/{audit-DcL73mOC.js → audit-CPoZMXGM.js}

@@ -1,8 +1,10 @@
-import { a as impactRank, i as impactLabel, r as countAtOrAbove } from "./impact-YdoOtFqm.js";
-import { n as count, t as collapse } from "./text-BFmNtMsV.js";
-import { a as groupIssues, i as coverageParts, n as understandingUrl, o as isShared, r as blindRules, t as manualCheckFor } from "./manual-Vz-oX1I_.js";
-import { a as runEngine, i as note, n as emitDocument, o as warn, r as fail, t as advise } from "./command-Dxpa00Ha.js";
-import { n as collectPages, r as emptyDirectoryHint, t as BuildDirectoryError } from "./collect-BkAQ0viT.js";
+import { a as impactRank, i as impactLabel, r as countAtOrAbove } from "./impact-DZt2oBCP.js";
+import { a as plural, n as count, t as collapse } from "./text-CKKpzkYM.js";
+import { a as isShared, c as runCompleteness, i as groupIssues, n as blindRules, r as coverageParts, t as remediationFor } from "./remediation-Dtowi2EC.js";
+import { r as componentPath } from "./component-C3GL1Mnu.js";
+import { i as understandingUrl, n as coverageSummary, r as manualCheckFor, t as buildCoverage } from "./coverage-B4IBKMO8.js";
+import { a as runEngine, i as note, n as emitDocument, o as warn, r as fail, t as advise } from "./command-D8l_oYbV.js";
+import { n as collectPages, r as emptyDirectoryHint, t as BuildDirectoryError } from "./collect-CFM8gEVv.js";
 import path from "node:path";
 import pc from "picocolors";
 //#region src/audit/report/console.ts
@@ -47,6 +49,9 @@ function context(options) {
 		sourceFor: options.sourceFor ?? (() => void 0),
 		componentFor: options.componentFor ?? (() => void 0),
 		manual: options.manual ?? false,
+		coverage: options.coverage ?? false,
+		framework: options.framework,
+		completeness: options.completeness,
 		c,
 		symbol: (kind) => {
 			switch (kind) {
@@ -182,9 +187,11 @@ function summary(audits, ctx) {
 	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 = count(audits.length, "page");
-	const lines = [line(ctx, "Summary", ctx.c.bold)];
-	if (ruleCount === 0) lines.push(line(ctx, `  No violations across ${pages}.`, ctx.c.green));
-	else {
+	const lines = [line(ctx, "Summary", ctx.c.bold), ...completenessLines(ctx)];
+	if (ruleCount === 0) {
+		const clean = ctx.completeness && !ctx.completeness.complete ? `  No violations across the ${pages} that were audited.` : `  No violations across ${pages}.`;
+		lines.push(line(ctx, clean, ctx.c.green));
+	} else {
 		lines.push(render(ctx, [{
 			text: `  ${count(ruleCount, "violation")} on ${withViolations.length} of ${pages}`,
 			paint: ctx.c.red
@@ -202,6 +209,73 @@ function summary(audits, ctx) {
 	const accepted = audits.reduce((total, audit) => total + (audit.accepted ?? []).reduce((sum, finding) => sum + finding.nodes.length, 0), 0);
 	if (accepted > 0) lines.push(line(ctx, `  ${count(accepted, "element")} accepted by the baseline, not counted above`, ctx.c.dim));
 	lines.push(...blindSection(audits, ctx));
+	lines.push(...coverageSection(audits, ctx));
+	return lines;
+}
+/**
+* How much of the standard this run could reach.
+*
+* One line by default. It is the sentence that stops a clean report reading as
+* a clean site: most of WCAG cannot be checked by any automated engine, and
+* until this was printed the report said so only in prose, in the footer, where
+* it could be read as boilerplate.
+*/
+function coverageSection(audits, ctx) {
+	const coverage = buildCoverage(audits);
+	const lines = ["", ...wrap(coverageSummary(coverage), ctx.width - 2).map((text) => line(ctx, `  ${text}`, ctx.c.dim))];
+	if (coverage.browserWouldAnswer > 0) {
+		const verb = coverage.browserWouldAnswer === 1 ? "criterion" : "criteria";
+		lines.push(line(ctx, `  --browser would answer ${coverage.browserWouldAnswer} more ${verb}.`, ctx.c.dim));
+	}
+	if (!ctx.coverage) {
+		lines.push(line(ctx, "  Run with --coverage for the criterion-by-criterion breakdown.", ctx.c.dim));
+		return lines;
+	}
+	lines.push("", line(ctx, "Coverage", ctx.c.bold));
+	for (const criterion of coverage.criteria) {
+		const paint = criterion.status === "evaluated" ? ctx.c.green : ctx.c.dim;
+		const note = criterion.browserWouldAnswer ? " (--browser would answer this)" : "";
+		lines.push(render(ctx, [
+			{
+				text: `  ${criterion.number} `,
+				paint: ctx.c.bold
+			},
+			{ text: `${criterion.title} (${criterion.level}) — ` },
+			{
+				text: `${STATUS_WORDS[criterion.status]}${note}`,
+				paint
+			}
+		]));
+	}
+	return lines;
+}
+/** What each outcome is called, in words rather than a symbol. */
+const STATUS_WORDS = {
+	evaluated: "evaluated here",
+	"not-evaluated": "this engine could not evaluate it",
+	"nothing-to-check": "rules ran and found nothing on this site to check",
+	"no-automated-rule": "no automated rule exists; a person must check it"
+};
+/**
+* What the run never looked at.
+*
+* Printed before the counts rather than after them, because it changes how they
+* read: "no violations" means one thing over a whole site and another over the
+* twelve pages of it a crawl managed to fetch before it hit its limit.
+*
+* Pages that errored are left to the summary's own line, which already names
+* them; repeating the number here would read as twice as many.
+*/
+function completenessLines(ctx) {
+	const completeness = ctx.completeness;
+	if (completeness === void 0 || completeness.complete) return [];
+	const lines = [];
+	if (completeness.unreachable.length > 0) {
+		const noun = plural(completeness.unreachable.length, "page");
+		lines.push(line(ctx, `  ${completeness.unreachable.length} ${noun} could not be reached, and were not audited`, ctx.c.yellow));
+	}
+	if (completeness.truncated) lines.push(line(ctx, "  The run stopped at its page limit; the site has more", ctx.c.yellow));
+	if (lines.length > 0) lines.push(line(ctx, "  This report describes what was audited, not the whole site.", ctx.c.dim));
 	return lines;
 }
 /**
@@ -296,6 +370,7 @@ function issuesSection(audits, ctx) {
 			}] : []
 		]));
 		lines.push(line(ctx, `      ${issue.help}`, ctx.c.dim));
+		lines.push(...remediationLines(issue.ruleId, issue.elements[0]?.html, ctx));
 		for (const element of issue.elements.slice(0, ctx.maxNodes)) {
 			lines.push(line(ctx, `      ${collapse(element.html)}`));
 			lines.push(...whereLines(element, ctx));
@@ -305,6 +380,27 @@ function issuesSection(audits, ctx) {
 	}
 	return lines;
 }
+/**
+* What to do about the rule, under the finding rather than in a link.
+*
+* axe-core's help text says what is wrong; this says who it stops and what to
+* change. The corrected line is built from the element that actually failed,
+* because a textbook snippet is a second thing to translate before anybody can
+* use it.
+*/
+function remediationLines(ruleId, html, ctx) {
+	const remediation = remediationFor(ruleId, ctx.framework);
+	if (remediation === void 0) return [];
+	const indent = "      ";
+	const width = ctx.width - 6 - 2;
+	const lines = [...wrap(remediation.why, width).map((text) => line(ctx, `${indent}${text}`, ctx.c.dim)), ...wrap(`Fix: ${remediation.fix}`, width).map((text) => line(ctx, `${indent}${text}`))];
+	const example = html === void 0 ? void 0 : remediation.example?.(html);
+	if (example !== void 0) lines.push(render(ctx, [{
+		text: `${indent}→ `,
+		paint: ctx.c.green
+	}, { text: collapse(example) }]));
+	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);
@@ -313,7 +409,7 @@ function whereLines(element, ctx) {
 	const lines = component === void 0 ? [] : [render(ctx, [{
 		text: "        written in ",
 		paint: ctx.c.dim
-	}, { text: component }])];
+	}, { text: componentPath(component) }])];
 	lines.push(line(ctx, `        on ${count(element.pages.length, "page")}:`, ctx.c.dim));
 	for (const page of shown) {
 		const source = ctx.sourceFor(page);
@@ -364,16 +460,22 @@ async function resolvePages(directory, options = {}) {
 		return {
 			pages: crawled.pages,
 			origin: crawled.origin,
-			label: options.url
+			label: options.url,
+			completeness: crawled.completeness
 		};
 	}
 	const cwd = options.cwd ?? process.cwd();
 	const shown = options.label ?? directory;
+	const unreachable = [];
 	let pages;
 	try {
 		pages = await collectPages(directory, {
 			...options.include ? { include: options.include } : {},
-			...options.exclude ? { exclude: options.exclude } : {}
+			...options.exclude ? { exclude: options.exclude } : {},
+			onUnreadable: (relativePath, reason) => unreachable.push({
+				location: relativePath,
+				reason
+			})
 		});
 	} catch (cause) {
 		if (!(cause instanceof BuildDirectoryError)) throw cause;
@@ -385,9 +487,21 @@ async function resolvePages(directory, options = {}) {
 		warn(await emptyDirectoryHint(shown, cwd));
 		return;
 	}
+	if (unreachable.length > 0) {
+		const verb = unreachable.length === 1 ? "file was" : "files were";
+		warn(`${unreachable.length} ${verb} not readable, and so not audited:`);
+		for (const file of unreachable.slice(0, 10)) note(`  ${file.location} — ${file.reason}`);
+		if (unreachable.length > 10) note(`  …and ${unreachable.length - 10} more`);
+	}
 	return {
 		pages,
-		label: shown
+		label: shown,
+		completeness: {
+			discovery: "directory",
+			collected: pages.length,
+			unreachable,
+			truncated: false
+		}
 	};
 }
 /**
@@ -397,7 +511,7 @@ async function resolvePages(directory, options = {}) {
 * exit 2 — a run that reached no verdict, not a clean one.
 */
 async function crawlPages(url, options) {
-	const { crawlSite, CrawlError, parseEntryUrl } = await import("./crawl-Oxt2Gaqo.js");
+	const { crawlSite, CrawlError, parseEntryUrl } = await import("./crawl-BiI1Lau_.js");
 	let entry;
 	try {
 		entry = parseEntryUrl(url, options.allowRemote ?? false);
@@ -412,6 +526,7 @@ async function crawlPages(url, options) {
 	const result = await crawlSite(entry, {
 		...options.allowRemote ? { allowRemote: true } : {},
 		...options.ignoreRobots ? { ignoreRobots: true } : {},
+		...options.sitemap === void 0 ? {} : { sitemap: options.sitemap },
 		...options.maxPages === void 0 ? {} : { maxPages: options.maxPages },
 		...options.maxDepth === void 0 ? {} : { maxDepth: options.maxDepth },
 		...options.timeoutMs === void 0 ? {} : { timeoutMs: options.timeoutMs }
@@ -432,7 +547,16 @@ async function crawlPages(url, options) {
 	if (result.truncated) warn(`Stopped at ${count(result.pages.length, "page")}; the site has more. Raise --max-pages to go further.`);
 	return {
 		pages: result.pages,
-		origin: result.origin
+		origin: result.origin,
+		completeness: {
+			discovery: result.discovery,
+			collected: result.pages.length,
+			unreachable: result.failures.map((failure) => ({
+				location: failure.url,
+				reason: failure.reason
+			})),
+			truncated: result.truncated
+		}
 	};
 }
 /**
@@ -444,7 +568,7 @@ async function crawlPages(url, options) {
 */
 async function resolveAutomatically(options) {
 	const cwd = options.cwd ?? process.cwd();
-	const { autoDetectSource } = await import("./project-DW08TseF.js");
+	const { autoDetectSource } = await import("./project-MFrXcw1M.js");
 	const detected = await autoDetectSource(cwd, {
 		...options.noBuild ? { noBuild: true } : {},
 		onStep: note
@@ -490,7 +614,7 @@ async function runAuditCommand(dir, options = {}) {
 		audits: [],
 		exitCode: 2
 	};
-	const { pages, origin, label, cleanup } = resolved;
+	const { pages, origin, label, cleanup, completeness: collection } = resolved;
 	try {
 		note(`Auditing ${count(pages.length, "page")} in ${label}${await describeEngine(pages, options)}…`);
 		const baseUrl = options.baseUrl ?? origin;
@@ -515,7 +639,8 @@ async function runAuditCommand(dir, options = {}) {
 			};
 			audits = applied;
 		}
-		await emit(audits, label, failOn, options);
+		const completeness = runCompleteness(audits, collection);
+		await emit(audits, label, failOn, completeness, options);
 		const unaudited = audits.filter((audit) => audit.error);
 		if (unaudited.length > 0) {
 			fail(`${unaudited.length} of ${audits.length} pages could not be audited`);
@@ -541,7 +666,7 @@ async function runAuditCommand(dir, options = {}) {
 * would be as wrong as silently passing.
 */
 async function acceptBaseline(audits, options) {
-	const { applyBaseline, BaselineError, readBaseline } = await import("./baseline-CuKFq4IF.js");
+	const { applyBaseline, BaselineError, readBaseline } = await import("./baseline-22Y1NWxM.js");
 	try {
 		const outcome = applyBaseline(audits, await readBaseline(options.baseline, options.cwd ?? process.cwd()));
 		if (outcome.accepted > 0) note(`Baseline accepted ${outcome.accepted} violating elements`);
@@ -568,7 +693,7 @@ async function acceptBaseline(audits, options) {
 */
 async function describeEngine(pages, options) {
 	if (options.browser) return " with Chromium";
-	const { plannedWorkers } = await import("./pool-BWkWZiJW.js");
+	const { plannedWorkers } = await import("./pool-BMevaLWD.js");
 	const workers = options.concurrency ?? plannedWorkers(pages);
 	return workers > 1 ? ` across ${workers} threads` : "";
 }
@@ -577,43 +702,56 @@ async function describeEngine(pages, options) {
 * 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);
+async function emit(audits, dir, failOn, completeness, options) {
+	const body = await renderReport(audits, dir, failOn, completeness, options.format ?? "console", typeof options.output === "string", options);
 	await emitDocument(body, options.output, options.cwd ?? process.cwd());
 	if (options.output !== void 0) note(`Report written to ${options.output}`);
 }
-async function renderReport(audits, dir, failOn, format, toFile, options) {
+async function renderReport(audits, dir, failOn, completeness, format, toFile, options) {
 	switch (format) {
 		case "json": {
-			const { buildJsonReport, serialiseJsonReport } = await import("./json-B0Y7rNjt.js");
+			const { buildJsonReport, serialiseJsonReport } = await import("./json-QQuFIw1W.js");
 			return serialiseJsonReport(buildJsonReport(audits, {
 				directory: dir,
 				...options.url === void 0 ? {} : { sourceKind: "url" },
 				failOn,
+				completeness,
 				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
 			}));
 		}
 		case "sarif": {
-			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-DB3WG7T9.js");
-			return serialiseSarifReport(buildSarifReport(audits, { directory: dir }));
+			const { buildSarifReport, serialiseSarifReport } = await import("./sarif-SR3_lLYd.js");
+			return serialiseSarifReport(buildSarifReport(audits, {
+				directory: dir,
+				completeness
+			}));
 		}
 		case "html": {
-			const { buildHtmlReport } = await import("./html-DKiI_3gs.js");
+			const { buildHtmlReport } = await import("./html-BGTO3ypW.js");
+			const framework = await detectedFramework(options.cwd ?? process.cwd());
 			return buildHtmlReport(audits, {
 				...await sourceLookups(options.cwd ?? process.cwd()),
 				directory: dir,
 				failOn,
+				completeness,
+				...framework === void 0 ? {} : { framework },
 				...options.baseUrl ? { baseUrl: options.baseUrl } : {}
 			});
 		}
-		case "console": return `${formatConsoleReport(audits, {
-			...await sourceLookups(options.cwd ?? process.cwd()),
-			dir,
-			failOn,
-			...options.perPage ? { perPage: true } : {},
-			...options.manual ? { manual: true } : {},
-			...toFile ? { color: false } : {}
-		})}\n`;
+		case "console": {
+			const framework = await detectedFramework(options.cwd ?? process.cwd());
+			return `${formatConsoleReport(audits, {
+				...await sourceLookups(options.cwd ?? process.cwd()),
+				dir,
+				failOn,
+				completeness,
+				...options.perPage ? { perPage: true } : {},
+				...options.manual ? { manual: true } : {},
+				...options.coverage ? { coverage: true } : {},
+				...framework === void 0 ? {} : { framework },
+				...toFile ? { color: false } : {}
+			})}\n`;
+		}
 	}
 }
 /**
@@ -621,9 +759,15 @@ async function renderReport(audits, dir, failOn, format, toFile, options) {
 * so. Best-effort: a project using no convention this recognises gets the
 * report it always got, with no source named.
 */
+/** The registry id of whatever built this project, for framework-shaped advice. */
+async function detectedFramework(cwd) {
+	const { detectFramework } = await import("./frameworks-etFg_O8K.js");
+	const { readPackageJson } = await import("./project-MFrXcw1M.js");
+	return (await detectFramework(cwd, await readPackageJson(cwd)))?.framework.id;
+}
 async function sourceLookups(cwd) {
-	const { buildRouteMap, sourceFor } = await import("./routes-C2Cgf6Ko.js");
-	const { buildComponentIndex, componentFor } = await import("./component-7kEBjv_y.js");
+	const { buildRouteMap, sourceFor } = await import("./routes-CmdRUuOs.js");
+	const { buildComponentIndex, componentFor } = await import("./component-DKd3EHOg.js");
 	const routes = await buildRouteMap(cwd);
 	const components = await buildComponentIndex(cwd);
 	return {

package/dist/audit-CpXH2Mk8.js

@@ -0,0 +1,2 @@
+import { n as runAuditCommand } from "./audit-CPoZMXGM.js";
+export { runAuditCommand };

package/dist/{baseline-CuKFq4IF.js → baseline-22Y1NWxM.js}

@@ -1,2 +1,2 @@
-import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-s9F3fXTN.js";
+import { a as readBaseline, r as applyBaseline, t as BaselineError } from "./baseline-DB9CZGnV.js";
 export { BaselineError, applyBaseline, readBaseline };

package/dist/{baseline-s9F3fXTN.js → baseline-DB9CZGnV.js}

@@ -1,6 +1,6 @@
-import { _ as withDefault, c as object, f as safeParse, i as isoDate$1, l as optional, o as nullable, p as string, s as number, t as array } from "./schema-CMZ8ItGk.js";
+import { a as isoDate$1, c as number, l as object, m as string, p as safeParse, s as nullable, t as array, u as optional, v as withDefault } from "./schema-is6CGX2D.js";
 import { t as elementFingerprint } from "./fingerprint-DRoneAjj.js";
-import { r as findingElements } from "./result-DLxd2Eip.js";
+import { a as findingElements } from "./result-DoamKFsp.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 /** Default filename, used by the CLI when no path is given. */