vortix-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,3112 @@
+#!/usr/bin/env node
+import {
+  CONFIG_DIR,
+  defineCheck,
+  getConfigPath,
+  loadConfig,
+  t
+} from "./chunk-KNVCFVGJ.js";
+
+// src/commands/check.ts
+import * as p3 from "@clack/prompts";
+
+// src/utils/box.ts
+var ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+function visibleLength(str) {
+  return str.replace(ANSI_PATTERN, "").length;
+}
+function padVisible(str, width) {
+  return str + " ".repeat(Math.max(0, width - visibleLength(str)));
+}
+function wrapPlainText(text, maxWidth) {
+  if (visibleLength(text) <= maxWidth) return [text];
+  const words = text.split(" ");
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (current && visibleLength(candidate) > maxWidth) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) lines.push(current);
+  return lines;
+}
+function renderBox(lines, options = {}) {
+  const padding = options.padding ?? 1;
+  const contentWidth = Math.max(options.minWidth ?? 0, ...lines.map(visibleLength), options.title ? visibleLength(options.title) + 2 : 0);
+  const innerWidth = contentWidth + padding * 2;
+  const top = options.title ? `\u250C\u2500 ${options.title} ${"\u2500".repeat(Math.max(1, innerWidth - visibleLength(options.title) - 3))}\u2510` : `\u250C${"\u2500".repeat(innerWidth)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(innerWidth)}\u2518`;
+  const body = lines.map((line) => {
+    const fill = " ".repeat(Math.max(0, contentWidth - visibleLength(line)));
+    return `\u2502${" ".repeat(padding)}${line}${fill}${" ".repeat(padding)}\u2502`;
+  });
+  return [top, ...body, bottom].join("\n");
+}
+function divider(width = 44) {
+  return "\u2500".repeat(width);
+}
+
+// src/core/report.ts
+import pc from "picocolors";
+
+// src/core/score.ts
+var CHECK_SCORE = {
+  pass: 100,
+  info: 90,
+  warn: 60,
+  error: 20
+};
+var SEVERITY_RANK = { info: 0, warn: 1, error: 2 };
+var GRADE_RANK = { A: 4, B: 3, C: 2, D: 1, F: 0 };
+function computeScore(checks, findings, skippedCheckIds = /* @__PURE__ */ new Set()) {
+  const scoredChecks = checks.filter((check) => !skippedCheckIds.has(check.id));
+  if (scoredChecks.length === 0) return { value: 100, grade: "A", cappedByError: false };
+  const worstByCheck = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    if (skippedCheckIds.has(finding.checkId)) continue;
+    const current = worstByCheck.get(finding.checkId);
+    if (!current || SEVERITY_RANK[finding.severity] > SEVERITY_RANK[current]) {
+      worstByCheck.set(finding.checkId, finding.severity);
+    }
+  }
+  const checksByCategory = /* @__PURE__ */ new Map();
+  for (const check of scoredChecks) {
+    const list = checksByCategory.get(check.category);
+    if (list) list.push(check);
+    else checksByCategory.set(check.category, [check]);
+  }
+  const categoryScores = [...checksByCategory.values()].map((categoryChecks) => {
+    const total = categoryChecks.reduce((sum, check) => {
+      const worst = worstByCheck.get(check.id);
+      return sum + (worst ? CHECK_SCORE[worst] : CHECK_SCORE.pass);
+    }, 0);
+    return total / categoryChecks.length;
+  });
+  const value = Math.round(categoryScores.reduce((sum, s) => sum + s, 0) / categoryScores.length);
+  const hasErrorFinding = [...worstByCheck.values()].some((severity) => severity === "error");
+  const naturalGrade = toGrade(value);
+  const grade = hasErrorFinding ? worseOf(naturalGrade, "C") : naturalGrade;
+  return { value, grade, cappedByError: hasErrorFinding && GRADE_RANK[naturalGrade] > GRADE_RANK.C };
+}
+function toGrade(value) {
+  if (value >= 90) return "A";
+  if (value >= 80) return "B";
+  if (value >= 70) return "C";
+  if (value >= 60) return "D";
+  return "F";
+}
+function worseOf(a, b) {
+  return GRADE_RANK[a] <= GRADE_RANK[b] ? a : b;
+}
+
+// src/core/types.ts
+var CATEGORIES = ["performance", "security", "accessibility", "bugs", "seo", "maintainability", "privacy"];
+
+// src/core/report.ts
+var SEVERITY_COLOR = {
+  error: pc.red,
+  warn: pc.yellow,
+  info: pc.gray
+};
+var SEVERITY_ICON = { error: "\u2716", warn: "\u26A0", info: "\u2139" };
+var PASS_ICON = pc.green("\u2714");
+var SKIP_ICON = pc.gray("\u2298");
+var MODE_COLOR = {
+  static: pc.cyan,
+  dynamic: pc.magenta,
+  live: pc.blue
+};
+function modeBadge(mode) {
+  return MODE_COLOR[mode](`[${mode}]`);
+}
+var GRADE_COLOR = {
+  A: pc.green,
+  B: pc.green,
+  C: pc.yellow,
+  D: pc.yellow,
+  F: pc.red
+};
+var GRADE_ART = {
+  A: [" \u2588\u2588 ", "\u2588  \u2588", "\u2588\u2588\u2588\u2588", "\u2588  \u2588", "\u2588  \u2588"],
+  B: ["\u2588\u2588\u2588 ", "\u2588  \u2588", "\u2588\u2588\u2588 ", "\u2588  \u2588", "\u2588\u2588\u2588 "],
+  C: ["\u2588\u2588\u2588 ", "\u2588   ", "\u2588   ", "\u2588   ", "\u2588\u2588\u2588 "],
+  D: ["\u2588\u2588\u2588 ", "\u2588  \u2588", "\u2588  \u2588", "\u2588  \u2588", "\u2588\u2588\u2588 "],
+  F: ["\u2588\u2588\u2588\u2588", "\u2588   ", "\u2588\u2588\u2588 ", "\u2588   ", "\u2588   "]
+};
+var MAX_EXAMPLE_MESSAGE_LENGTH = 70;
+var SCORECARD_WIDTH = 64;
+function printReport(result) {
+  const lines = [];
+  for (const message of result.configErrors) {
+    lines.push(pc.yellow(`\u26A0 ${t("report.configErrorPrefix")}: ${message}`));
+  }
+  if (result.configErrors.length > 0) lines.push("");
+  lines.push(pc.bold(`
+${buildHeader(result)}
+`));
+  lines.push(buildScoreCard(result));
+  lines.push("");
+  const findingsByCheck = groupBy(result.findings, (f) => f.checkId);
+  const checksByCategory = groupBy(result.checks, (c) => c.category);
+  for (const category of CATEGORIES) {
+    const checks = checksByCategory.get(category);
+    if (!checks) continue;
+    lines.push(pc.bold(category.toUpperCase()));
+    for (const check of checks) {
+      const skipReason = result.skipped[check.id];
+      lines.push(skipReason ? skipLine(check, skipReason) : checkLine(check, findingsByCheck.get(check.id) ?? []));
+    }
+    lines.push("");
+  }
+  console.log(lines.join("\n"));
+}
+var GRADE_ART_GAP = "    ";
+var CATEGORY_GRID_COLUMNS = 3;
+var CATEGORY_GRID_GAP = "   ";
+function buildScoreCard(result, color = true) {
+  const skippedIds = new Set(Object.keys(result.skipped));
+  const score = computeScore(result.checks, result.findings, skippedIds);
+  const counts = countBySeverity(result.findings);
+  const gradeColor = GRADE_COLOR[score.grade];
+  const infoLines = [
+    color ? pc.bold(`${score.value}/100`) : `${score.value}/100`,
+    color ? gradeColor(pc.bold(`Grade ${score.grade}`)) : `Grade ${score.grade}`,
+    `${pluralize(counts.error, "error", "errors")}, ${pluralize(counts.warn, "warning", "warnings")}, ${pluralize(counts.info, "notice", "notices")}`
+  ];
+  const art = GRADE_ART[score.grade];
+  const topPad = Math.floor((art.length - infoLines.length) / 2);
+  const lines = [];
+  for (let i = 0; i < art.length; i++) {
+    const artLine = color ? gradeColor(art[i]) : art[i];
+    const info = infoLines[i - topPad] ?? "";
+    lines.push(`${artLine}${GRADE_ART_GAP}${info}`);
+  }
+  lines.push("");
+  lines.push(color ? pc.dim(t("report.byCategoryLabel")) : t("report.byCategoryLabel"));
+  lines.push(...buildCategoryGrid(result, color));
+  const notes = scoreNotes(result, score);
+  if (notes.length > 0) {
+    lines.push("");
+    for (const note2 of notes) {
+      for (const wrapped of wrapPlainText(note2, SCORECARD_WIDTH)) lines.push(color ? pc.dim(wrapped) : wrapped);
+    }
+  }
+  return renderBox(lines, { title: t("report.overallScoreLabel").toUpperCase(), minWidth: SCORECARD_WIDTH, padding: 2 });
+}
+function buildCategoryGrid(result, color) {
+  const findingsByCheck = groupBy(result.findings, (f) => f.checkId);
+  const checksByCategory = groupBy(result.checks, (c) => c.category);
+  const cells = [];
+  for (const category of CATEGORIES) {
+    const checks = checksByCategory.get(category);
+    if (!checks) continue;
+    const active = checks.filter((c) => !result.skipped[c.id]);
+    if (active.length === 0) {
+      cells.push(color ? pc.gray(`${SKIP_ICON} ${category}`) : `\u2298 ${category}`);
+      continue;
+    }
+    let worst;
+    for (const check of active) {
+      for (const finding of findingsByCheck.get(check.id) ?? []) {
+        if (!worst || SEVERITY_RANK[finding.severity] > SEVERITY_RANK[worst]) worst = finding.severity;
+      }
+    }
+    const icon = worst ? SEVERITY_ICON[worst] : "\u2714";
+    const text = `${icon} ${category}`;
+    cells.push(color ? worst ? SEVERITY_COLOR[worst](text) : pc.green(text) : text);
+  }
+  const columnWidth = Math.max(...cells.map(visibleLength));
+  const rows = [];
+  for (let i = 0; i < cells.length; i += CATEGORY_GRID_COLUMNS) {
+    const rowCells = cells.slice(i, i + CATEGORY_GRID_COLUMNS);
+    rows.push(rowCells.map((cell, j) => j === rowCells.length - 1 ? cell : padVisible(cell, columnWidth)).join(CATEGORY_GRID_GAP));
+  }
+  return rows;
+}
+var STATUS_TAG = {
+  error: "[FAILED]",
+  warn: "[WARN]  ",
+  info: "[INFO]  ",
+  pass: "[PASS]  ",
+  skip: "[SKIP]  "
+};
+var STATUS_COLOR = {
+  error: pc.red,
+  warn: pc.yellow,
+  info: pc.cyan,
+  pass: pc.green,
+  skip: pc.gray
+};
+function checkOptionLabel(check, findings, skipReason) {
+  const key = skipReason ? "skip" : findings.length === 0 ? "pass" : worstSeverity(countBySeverity(findings));
+  const status = skipReason ? "skipped" : findings.length === 0 ? "passed" : severitySummary(countBySeverity(findings));
+  return { label: `${STATUS_COLOR[key](STATUS_TAG[key])} ${check.name}`, hint: `${check.category} \xB7 ${check.mode} \xB7 ${status}` };
+}
+function buildFullReport(result) {
+  const lines = [];
+  for (const message of result.configErrors) {
+    lines.push(`\u26A0 ${t("report.configErrorPrefix")}: ${message}`);
+  }
+  if (result.configErrors.length > 0) lines.push("");
+  lines.push(t("report.header", { adapter: result.adapterName, totalPages: result.totalPages, pagesChecked: result.pagesChecked }));
+  lines.push("");
+  lines.push(buildScoreCard(result, false));
+  lines.push("");
+  const findingsByCheck = groupBy(result.findings, (f) => f.checkId);
+  const checksByCategory = groupBy(result.checks, (c) => c.category);
+  for (const category of CATEGORIES) {
+    const checks = checksByCategory.get(category);
+    if (!checks) continue;
+    lines.push(category.toUpperCase());
+    for (const check of checks) {
+      const skipReason = result.skipped[check.id];
+      if (skipReason) {
+        lines.push(`  \u2298 ${check.name} [${check.mode}] \u2014 skipped: ${skipReason}`);
+        continue;
+      }
+      const findings = findingsByCheck.get(check.id) ?? [];
+      if (findings.length === 0) {
+        lines.push(`  \u2714 ${check.name} [${check.mode}]`);
+        continue;
+      }
+      lines.push(`  ${SEVERITY_ICON[worstSeverity(countBySeverity(findings))]} ${check.name} [${check.mode}]`);
+      for (const finding of findings) {
+        const location = [finding.file, finding.url].filter(Boolean).join(" ");
+        lines.push(`      - [${finding.severity}] ${finding.message}${location ? ` (${location})` : ""}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildHeader(result) {
+  const header = t("report.header", { adapter: result.adapterName, totalPages: result.totalPages, pagesChecked: result.pagesChecked });
+  const hasLiveChecks = result.checks.some((c) => c.mode === "live");
+  if (hasLiveChecks && result.liveUrl) {
+    return header + t("report.headerLiveSuffix", { url: result.liveUrl });
+  }
+  return header;
+}
+function scoreNotes(result, score) {
+  const notes = [];
+  if (score.cappedByError) notes.push(`(${t("report.scoreCappedNote")})`);
+  if (result.pagesChecked < result.totalPages) {
+    notes.push(t("report.scorePartialPagesNote", { pagesChecked: result.pagesChecked, totalPages: result.totalPages }));
+  }
+  const hasLiveChecks = result.checks.some((c) => c.mode === "live");
+  if (hasLiveChecks && !result.liveUrl) {
+    notes.push(t("report.scoreLiveSkippedNote"));
+  }
+  return notes;
+}
+function skipLine(check, reason) {
+  return `  ${SKIP_ICON} ${check.name} ${modeBadge(check.mode)} ${pc.dim(`\u2014 skipped: ${reason}`)}`;
+}
+function checkLine(check, findings) {
+  if (findings.length === 0) {
+    return `  ${PASS_ICON} ${check.name} ${modeBadge(check.mode)}`;
+  }
+  const counts = countBySeverity(findings);
+  const worst = worstSeverity(counts);
+  const summary = severitySummary(counts);
+  const topFinding = findings.find((f) => f.severity === worst) ?? findings[0];
+  const more = findings.length > 1 ? pc.dim(t("report.moreFindingsSuffix", { count: findings.length - 1 })) : "";
+  return `  ${SEVERITY_COLOR[worst](SEVERITY_ICON[worst])} ${check.name} ${modeBadge(check.mode)} ${pc.dim(`\u2014 ${summary}:`)} ${truncate(topFinding.message, MAX_EXAMPLE_MESSAGE_LENGTH)}${more}`;
+}
+function buildCheckDetail(check, findings, details, skipReason) {
+  const counts = countBySeverity(findings);
+  const statusKey = skipReason ? "skip" : findings.length === 0 ? "pass" : worstSeverity(counts);
+  const statusText = skipReason ? t("report.detailStatusSkipped", { reason: skipReason }) : findings.length === 0 ? t("report.detailStatusPass") : t("report.detailStatusIssues", { summary: severitySummary(counts) });
+  const lines = [];
+  lines.push(`${STATUS_COLOR[statusKey](STATUS_TAG[statusKey].trim())}  ${pc.bold(check.name)}`);
+  lines.push(pc.dim(`${check.category} \xB7 ${modeBadge(check.mode)}${check.description ? ` \xB7 ${check.description}` : ""}`));
+  lines.push(statusText);
+  lines.push(pc.dim(divider()));
+  lines.push(pc.bold(t("report.detailFindingsHeader")));
+  if (findings.length === 0) {
+    lines.push(`  ${t("report.detailNoFindings")}`);
+  } else {
+    for (const finding of findings) {
+      const location = [finding.file, finding.url].filter(Boolean).join(" ");
+      lines.push(
+        `  ${SEVERITY_COLOR[finding.severity](SEVERITY_ICON[finding.severity])} [${finding.severity}] ${finding.message}${location ? ` ${pc.dim(`(${location})`)}` : ""}`
+      );
+    }
+  }
+  lines.push(pc.dim(divider()));
+  lines.push(pc.bold(t("report.detailValuesHeader")));
+  if (details.length === 0) {
+    lines.push(`  ${t("report.detailNoValues")}`);
+  } else {
+    for (const line of aggregateDetailLines(details)) lines.push(`  ${line}`);
+  }
+  return lines.join("\n");
+}
+function aggregateDetailLines(details) {
+  const byLabel = groupBy(details, (d) => d.label);
+  const lines = [];
+  for (const [label, group] of byLabel) {
+    if (group.length === 1) {
+      lines.push(`${label}: ${pc.bold(group[0].value)}`);
+      continue;
+    }
+    const parsed = group.map((entry) => parseLeadingNumber(entry.value));
+    if (parsed.every((p6) => p6 !== null)) {
+      const nums = parsed.map((p6) => p6?.num);
+      const rest = parsed[0]?.rest;
+      const med = formatNum(median(nums));
+      const avg = formatNum(nums.reduce((a, b) => a + b, 0) / nums.length);
+      lines.push(`${label}: median ${pc.bold(med + rest)}, avg ${pc.bold(avg + rest)} ${pc.dim(`(${group.length} pages)`)}`);
+      continue;
+    }
+    const distinct = [...new Set(group.map((entry) => entry.value))];
+    if (distinct.length === 1) {
+      lines.push(`${label}: ${pc.bold(distinct[0])} ${pc.dim(`(${group.length} pages)`)}`);
+    } else {
+      const sample = distinct.slice(0, 3).map((v) => `"${v}"`).join(", ");
+      lines.push(
+        `${label}: ${distinct.length} different values ${pc.dim(`across ${group.length} pages, e.g. ${sample}${distinct.length > 3 ? ", ..." : ""}`)}`
+      );
+    }
+  }
+  return lines;
+}
+function parseLeadingNumber(value) {
+  const match = value.match(/^(-?\d+(?:\.\d+)?)(.*)$/);
+  if (!match) return null;
+  return { num: Number(match[1]), rest: match[2] };
+}
+function median(nums) {
+  const sorted = [...nums].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function formatNum(n) {
+  return Number.isInteger(n) ? String(n) : String(Math.round(n * 100) / 100);
+}
+function worstSeverity(counts) {
+  if (counts.error > 0) return "error";
+  if (counts.warn > 0) return "warn";
+  return "info";
+}
+function severitySummary(counts) {
+  return [
+    counts.error > 0 && pluralize(counts.error, "error", "errors"),
+    counts.warn > 0 && pluralize(counts.warn, "warning", "warnings"),
+    counts.info > 0 && pluralize(counts.info, "notice", "notices")
+  ].filter(Boolean).join(", ");
+}
+function truncate(message, max) {
+  return message.length > max ? `${message.slice(0, max - 1)}\u2026` : message;
+}
+function pluralize(count, singular, plural) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function groupBy(items, keyFn) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const list = map.get(key) ?? [];
+    list.push(item);
+    map.set(key, list);
+  }
+  return map;
+}
+function countBySeverity(findings) {
+  const counts = { error: 0, warn: 0, info: 0 };
+  for (const finding of findings) counts[finding.severity]++;
+  return counts;
+}
+
+// src/core/runner.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
+import path14 from "path";
+
+// src/adapters/index.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+function hasAny(cwd, files) {
+  return files.some((f) => existsSync(path.join(cwd, f)));
+}
+function hasDir(cwd, dirs) {
+  return dirs.some((d) => {
+    try {
+      return statSync(path.join(cwd, d)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+function readFirst(cwd, files, maxBytes = 8192) {
+  for (const f of files) {
+    const full = path.join(cwd, f);
+    try {
+      if (!statSync(full).isFile()) continue;
+      const content = readFileSync(full, "utf-8");
+      return content.slice(0, maxBytes);
+    } catch {
+    }
+  }
+  return "";
+}
+function hasPackageDependency(cwd, names) {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(cwd, "package.json"), "utf-8"));
+    const all = { ...pkg.dependencies, ...pkg.devDependencies };
+    return names.some((n) => n in all);
+  } catch {
+    return false;
+  }
+}
+var COMMON_OUTPUT_DIRS = ["dist", "build", "public", "_site", "output", "out", ".output/public", "site", "www"];
+function findExistingOutputDir(cwd) {
+  return COMMON_OUTPUT_DIRS.find((dir) => {
+    try {
+      return statSync(path.join(cwd, dir)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+var astro = {
+  name: "astro",
+  detect: (cwd) => hasAny(cwd, ["astro.config.mjs", "astro.config.ts", "astro.config.js", "astro.config.cjs"]),
+  buildCommand: "npx astro build",
+  outputDir: "dist",
+  resolveServeDir: (outputDir) => {
+    const clientDir = path.join(outputDir, "client");
+    const serverDir = path.join(outputDir, "server");
+    if (existsSync(clientDir) && existsSync(serverDir)) return clientDir;
+    return outputDir;
+  }
+};
+var eleventy = {
+  name: "eleventy",
+  detect: (cwd) => hasAny(cwd, [".eleventy.js", ".eleventy.cjs", "eleventy.config.js", "eleventy.config.mjs", "eleventy.config.cjs"]),
+  buildCommand: "npx @11ty/eleventy",
+  outputDir: "_site"
+};
+var nextjs = {
+  name: "nextjs",
+  // Static export only (`output: "export"` in next.config.*) produces servable HTML in `out/`;
+  // a default Next.js build is server-rendered and out of scope for this tool.
+  detect: (cwd) => {
+    if (!hasAny(cwd, ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"])) return false;
+    const content = readFirst(cwd, ["next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"]);
+    return /output\s*:\s*["']export["']/.test(content);
+  },
+  buildCommand: "npx next build",
+  outputDir: "out"
+};
+var nuxt = {
+  name: "nuxt",
+  detect: (cwd) => hasAny(cwd, ["nuxt.config.js", "nuxt.config.ts", "nuxt.config.mjs"]),
+  buildCommand: "npx nuxi generate",
+  outputDir: ".output/public",
+  resolveServeDir: (outputDir) => {
+    if (!existsSync(outputDir) && existsSync(path.join(path.dirname(path.dirname(outputDir)), "dist"))) {
+      return path.join(path.dirname(path.dirname(outputDir)), "dist");
+    }
+    return outputDir;
+  }
+};
+var sveltekit = {
+  name: "sveltekit",
+  // A static build requires @sveltejs/adapter-static. That cannot be verified from the config
+  // alone, so a missing outputDir is reported as an explicit error later on.
+  detect: (cwd) => hasAny(cwd, ["svelte.config.js", "svelte.config.mjs", "svelte.config.ts"]) && hasPackageDependency(cwd, ["@sveltejs/adapter-static"]),
+  buildCommand: "npx vite build",
+  outputDir: "build"
+};
+var gatsby = {
+  name: "gatsby",
+  detect: (cwd) => hasAny(cwd, ["gatsby-config.js", "gatsby-config.ts", "gatsby-config.mjs"]),
+  buildCommand: "npx gatsby build",
+  outputDir: "public"
+};
+var docusaurus = {
+  name: "docusaurus",
+  detect: (cwd) => hasAny(cwd, ["docusaurus.config.js", "docusaurus.config.ts"]),
+  buildCommand: "npx docusaurus build",
+  outputDir: "build"
+};
+var vuepress = {
+  name: "vuepress",
+  detect: (cwd) => hasAny(cwd, ["docs/.vuepress/config.js", "docs/.vuepress/config.ts", "docs/.vuepress/config.mjs"]) || hasAny(cwd, [".vuepress/config.js", ".vuepress/config.ts", ".vuepress/config.mjs"]),
+  buildCommand: "npx vuepress build docs",
+  outputDir: "docs/.vuepress/dist",
+  resolveServeDir: (outputDir) => {
+    if (!existsSync(outputDir)) {
+      const root = path.join(path.dirname(path.dirname(path.dirname(outputDir))), ".vuepress", "dist");
+      if (existsSync(root)) return root;
+    }
+    return outputDir;
+  }
+};
+var gridsome = {
+  name: "gridsome",
+  detect: (cwd) => hasAny(cwd, ["gridsome.config.js"]),
+  buildCommand: "npx gridsome build",
+  outputDir: "dist"
+};
+var mkdocs = {
+  name: "mkdocs",
+  detect: (cwd) => hasAny(cwd, ["mkdocs.yml", "mkdocs.yaml"]),
+  buildCommand: "mkdocs build",
+  outputDir: "site"
+};
+var zola = {
+  name: "zola",
+  // Zola's config.toml uses `base_url` (snake_case), Hugo's uses `baseURL` (camelCase). That
+  // distinction is what separates the two on their shared generic filename.
+  detect: (cwd) => /base_url\s*=/.test(readFirst(cwd, ["config.toml"])),
+  buildCommand: "zola build",
+  outputDir: "public"
+};
+var hugo = {
+  name: "hugo",
+  detect: (cwd) => {
+    if (hasAny(cwd, ["hugo.toml", "hugo.yaml", "hugo.yml"])) return true;
+    const content = readFirst(cwd, ["config.toml", "config.yaml", "config.yml"]);
+    return /\bbaseURL\s*[:=]/.test(content) || /\blanguageCode\s*[:=]/.test(content);
+  },
+  buildCommand: "hugo",
+  outputDir: "public"
+};
+var hexo = {
+  name: "hexo",
+  // Hexo defaults to `_config.yml` just like Jekyll. package.json, or the `scaffolds/`
+  // convention, is the reliable disambiguator, so hexo must precede jekyll in
+  // BUILT_IN_ADAPTERS.
+  detect: (cwd) => hasAny(cwd, ["_config.yml"]) && (hasPackageDependency(cwd, ["hexo", "hexo-cli"]) || hasDir(cwd, ["scaffolds"])),
+  buildCommand: "npx hexo generate",
+  outputDir: "public"
+};
+var jekyll = {
+  name: "jekyll",
+  detect: (cwd) => hasAny(cwd, ["_config.yml"]),
+  buildCommand: "bundle exec jekyll build",
+  outputDir: "_site"
+};
+var vite = {
+  name: "vite",
+  detect: (cwd) => hasAny(cwd, ["vite.config.js", "vite.config.ts", "vite.config.mjs", "vite.config.cjs"]),
+  buildCommand: "npx vite build",
+  outputDir: "dist"
+};
+var BUILT_IN_ADAPTERS = [
+  astro,
+  eleventy,
+  nextjs,
+  nuxt,
+  sveltekit,
+  gatsby,
+  docusaurus,
+  vuepress,
+  gridsome,
+  vite,
+  mkdocs,
+  zola,
+  hugo,
+  hexo,
+  jekyll
+];
+function detectAdapter(cwd) {
+  return BUILT_IN_ADAPTERS.find((a) => a.detect(cwd));
+}
+function resolveAdapter(cwd, target, build) {
+  let base;
+  if (target.adapter) {
+    base = BUILT_IN_ADAPTERS.find((a) => a.name === target.adapter);
+    if (!base) {
+      throw new Error(t("errors.unknownAdapter", { name: target.adapter, available: BUILT_IN_ADAPTERS.map((a) => a.name).join(", ") }));
+    }
+  } else {
+    base = detectAdapter(cwd);
+  }
+  let fallbackOutputDir;
+  if (!base && !build && !target.outputDir) {
+    fallbackOutputDir = findExistingOutputDir(cwd);
+  }
+  const resolvedOutputDir = target.outputDir ?? base?.outputDir ?? fallbackOutputDir;
+  if (!resolvedOutputDir) {
+    throw new Error(t("errors.noGeneratorOutputDir"));
+  }
+  if (!base && build && !target.buildCommand) {
+    throw new Error(t("errors.noGeneratorBuildCommand"));
+  }
+  return {
+    name: base?.name ?? (fallbackOutputDir ? "static" : "manual"),
+    detect: () => true,
+    buildCommand: target.buildCommand ?? base?.buildCommand ?? "",
+    outputDir: resolvedOutputDir,
+    // Apply the adapter's own output-layout heuristic only while its declared outputDir is in
+    // play. An explicit target.outputDir override takes precedence over the heuristic.
+    resolveServeDir: target.outputDir ? void 0 : base?.resolveServeDir
+  };
+}
+
+// src/dynamic/serve.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile } from "fs/promises";
+import http from "http";
+import path2 from "path";
+var MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css",
+  ".js": "text/javascript",
+  ".mjs": "text/javascript",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ico": "image/x-icon",
+  ".xml": "application/xml",
+  ".txt": "text/plain"
+};
+function startStaticServer(root) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer(async (req, res) => {
+      let urlPath;
+      try {
+        urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
+      } catch {
+        res.statusCode = 400;
+        res.end("Bad request");
+        return;
+      }
+      const resolved = path2.resolve(root, `.${urlPath}`);
+      if (resolved !== root && !resolved.startsWith(root + path2.sep)) {
+        res.statusCode = 403;
+        res.end("Forbidden");
+        return;
+      }
+      let filePath = resolved;
+      if (urlPath.endsWith("/") || !path2.extname(filePath)) {
+        const indexCandidate = path2.join(filePath, "index.html");
+        filePath = existsSync2(indexCandidate) ? indexCandidate : `${filePath}.html`;
+      }
+      try {
+        const data = await readFile(filePath);
+        res.setHeader("Content-Type", MIME_TYPES[path2.extname(filePath)] ?? "application/octet-stream");
+        res.end(data);
+      } catch {
+        res.statusCode = 404;
+        res.end("Not found");
+      }
+    });
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const { port } = server.address();
+      resolve({
+        url: `http://127.0.0.1:${port}`,
+        close: () => new Promise((closeResolve) => server.close(() => closeResolve()))
+      });
+    });
+  });
+}
+
+// src/dynamic/session.ts
+function attachCapture(page) {
+  const consoleMessages = [];
+  const networkRequests = [];
+  const onConsole = (msg) => {
+    consoleMessages.push({ type: msg.type(), text: msg.text() });
+  };
+  const onPageError = (error) => {
+    consoleMessages.push({ type: "pageerror", text: error.message });
+  };
+  const onResponse = async (response) => {
+    try {
+      const headers = await response.allHeaders();
+      let bodySize = Number(headers["content-length"] ?? 0);
+      if (!bodySize) {
+        try {
+          bodySize = (await response.body()).length;
+        } catch {
+        }
+      }
+      const request = response.request();
+      networkRequests.push({
+        url: response.url(),
+        status: response.status(),
+        contentType: headers["content-type"] ?? null,
+        bodySize,
+        isMainFrame: request.frame() === page.mainFrame(),
+        resourceType: request.resourceType()
+      });
+    } catch {
+    }
+  };
+  page.on("console", onConsole);
+  page.on("pageerror", onPageError);
+  page.on("response", onResponse);
+  return {
+    consoleMessages,
+    networkRequests,
+    detach() {
+      page.off("console", onConsole);
+      page.off("pageerror", onPageError);
+      page.off("response", onResponse);
+    }
+  };
+}
+
+// src/utils/exec.ts
+import { exec as execCallback } from "child_process";
+var DEFAULT_TIMEOUT_MS = 5 * 6e4;
+function exec(command, options) {
+  const { cwd, timeoutMs = DEFAULT_TIMEOUT_MS, allowNonZeroExit = false } = options;
+  return new Promise((resolve, reject) => {
+    execCallback(command, { cwd, maxBuffer: 1024 * 1024 * 20, timeout: timeoutMs, killSignal: "SIGKILL" }, (error, stdout, stderr) => {
+      if (error) {
+        if (allowNonZeroExit && (stdout || stderr)) {
+          resolve(stdout || stderr || "");
+          return;
+        }
+        const execException = error;
+        const timedOut = execException.killed === true && execException.signal === "SIGKILL";
+        const reason = timedOut ? `timed out after ${Math.round(timeoutMs / 1e3)}s` : stderr.trim() || stdout.trim() || error.message;
+        const execError = new Error(`Command "${command}" failed: ${reason}`);
+        execError.stdout = stdout ?? "";
+        execError.stderr = stderr ?? "";
+        execError.code = execException.code ?? null;
+        reject(execError);
+        return;
+      }
+      resolve(stdout || stderr || "");
+    });
+  });
+}
+
+// src/utils/glob.ts
+import { glob } from "tinyglobby";
+async function globFiles(pattern, options) {
+  return glob(pattern, { cwd: options.cwd, absolute: true });
+}
+
+// src/utils/humanize.ts
+function humanizeCheckId(id) {
+  const lastSegment = id.split(".").pop() ?? id;
+  return lastSegment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// src/utils/pages.ts
+import path3 from "path";
+async function collectPages(outputDir) {
+  const files = await globFiles("**/*.html", { cwd: outputDir });
+  return files.map((file) => {
+    const relativeFile = path3.relative(outputDir, file);
+    return { file, relativeFile, urlPath: toUrlPath(relativeFile) };
+  }).sort((a, b) => a.urlPath.localeCompare(b.urlPath));
+}
+function toUrlPath(relativeFile) {
+  const posix = relativeFile.split(path3.sep).join("/");
+  if (posix === "index.html") return "/";
+  if (posix.endsWith("/index.html")) return `/${posix.slice(0, -"index.html".length)}`;
+  return `/${posix}`;
+}
+
+// src/core/runner.ts
+import { chromium } from "playwright";
+
+// src/core/detail.ts
+function createDetailFactory(check, push) {
+  return (input) => {
+    push({
+      checkId: check.id,
+      category: check.category,
+      label: input.label,
+      value: input.value,
+      url: input.url
+    });
+  };
+}
+
+// src/core/finding.ts
+function createFindingFactory(check, configuredSeverity) {
+  return (input) => ({
+    checkId: check.id,
+    category: check.category,
+    severity: configuredSeverity ?? input.severity ?? check.severity ?? "warn",
+    message: input.message,
+    file: input.file,
+    url: input.url
+  });
+}
+
+// src/core/load-checks.ts
+import path13 from "path";
+import { pathToFileURL } from "url";
+
+// src/checks/accessibility/run-axe.ts
+import { AxeBuilder } from "@axe-core/playwright";
+var IMPACT_SEVERITY = {
+  critical: "error",
+  serious: "error",
+  moderate: "warn",
+  minor: "info"
+};
+var cache = /* @__PURE__ */ new WeakMap();
+function runAxe(page) {
+  let results = cache.get(page);
+  if (!results) {
+    results = new AxeBuilder({ page }).withTags(["wcag2a", "wcag2aa", "wcag21a", "wcag21aa"]).exclude("iframe").analyze();
+    cache.set(page, results);
+  }
+  return results;
+}
+
+// src/checks/accessibility/axe.ts
+var axe_default = defineCheck({
+  id: "accessibility.axe",
+  name: "WCAG Accessibility (axe-core)",
+  category: "accessibility",
+  mode: "dynamic",
+  severity: "warn",
+  description: "WCAG 2.1 A/AA violations via axe-core.",
+  async run(ctx) {
+    const results = await runAxe(ctx.page);
+    ctx.detail({
+      label: "Rules checked / passed / violated",
+      value: `${results.passes.length + results.violations.length} / ${results.passes.length} / ${results.violations.length}`,
+      url: ctx.pageInfo.urlPath
+    });
+    return results.violations.map(
+      (violation) => ctx.finding({
+        message: `${violation.help} (${violation.id}, affects ${violation.nodes.length} element(s))`,
+        url: ctx.pageInfo.urlPath,
+        severity: IMPACT_SEVERITY[violation.impact ?? "moderate"] ?? "warn"
+      })
+    );
+  }
+});
+
+// src/checks/accessibility/color-contrast.ts
+var color_contrast_default = defineCheck({
+  id: "accessibility.color-contrast",
+  name: "Color Contrast",
+  category: "accessibility",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Checks color contrast ratios using axe-core.",
+  async run(ctx) {
+    const findings = [];
+    const results = await runAxe(ctx.page);
+    let elementsChecked = 0;
+    let elementsFailed = 0;
+    for (const violation of results.violations) {
+      if (violation.id === "color-contrast") {
+        elementsFailed += violation.nodes.length;
+        for (const node of violation.nodes) {
+          findings.push(
+            ctx.finding({
+              message: `Color contrast: ${node.html.substring(0, 100)}`,
+              url: ctx.pageInfo.urlPath,
+              severity: IMPACT_SEVERITY[violation.impact ?? "moderate"] ?? "warn"
+            })
+          );
+        }
+      }
+    }
+    for (const pass of results.passes) {
+      if (pass.id === "color-contrast") elementsChecked += pass.nodes.length;
+    }
+    elementsChecked += elementsFailed;
+    ctx.detail({
+      label: "Elements checked / failing contrast",
+      value: `${elementsChecked} / ${elementsFailed}`,
+      url: ctx.pageInfo.urlPath
+    });
+    return findings;
+  }
+});
+
+// src/utils/html.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { parse } from "node-html-parser";
+var cache2 = /* @__PURE__ */ new Map();
+function parseHtmlFile(filePath) {
+  let root = cache2.get(filePath);
+  if (!root) {
+    root = parse(readFileSync2(filePath, "utf-8"));
+    cache2.set(filePath, root);
+  }
+  return root;
+}
+
+// src/checks/bugs/anchor-links.ts
+var anchor_links_default = defineCheck({
+  id: "bugs.anchor-links",
+  name: "Anchor Links",
+  category: "bugs",
+  mode: "static",
+  severity: "warn",
+  description: "Validates internal anchor links (#id) point to existing elements.",
+  async run(ctx) {
+    const findings = [];
+    let checked = 0;
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const links = root.querySelectorAll("a[href^='#']");
+      for (const link of links) {
+        const href = link.getAttribute("href") ?? "";
+        const id = href.slice(1);
+        if (!id) continue;
+        checked++;
+        const target = root.querySelector(`[id="${id}"]`);
+        if (!target) {
+          findings.push(
+            ctx.finding({
+              message: `Anchor "${href}" points to non-existent element`,
+              file: page.relativeFile
+            })
+          );
+        }
+      }
+    }
+    ctx.detail({ label: "Anchor links checked", value: String(checked) });
+    return findings;
+  }
+});
+
+// src/checks/bugs/broken-links.ts
+import { readdirSync } from "fs";
+import path4 from "path";
+function isInternal(href) {
+  if (!href || href.startsWith("#") || href.startsWith("//")) return false;
+  return !/^[a-z][a-z0-9+.-]*:/i.test(href);
+}
+function existsExactCase(fullPath) {
+  const segments = fullPath.split(path4.sep).filter(Boolean);
+  let current = path4.parse(fullPath).root || path4.sep;
+  for (const segment of segments) {
+    let entries;
+    try {
+      entries = readdirSync(current);
+    } catch {
+      return false;
+    }
+    if (!entries.includes(segment)) return false;
+    current = path4.join(current, segment);
+  }
+  return true;
+}
+function targetExists(target, ctx) {
+  const candidates = [target, path4.join(target, "index.html"), `${target}.html`];
+  return candidates.some((candidate) => ctx.fileExists(candidate) && existsExactCase(candidate));
+}
+var REFERENCE_ATTRIBUTES = [
+  { selector: "a[href]", attr: "href", label: "link" },
+  { selector: "img[src]", attr: "src", label: "image" },
+  { selector: "link[href]", attr: "href", label: "stylesheet/link" },
+  { selector: "script[src]", attr: "src", label: "script" }
+];
+var broken_links_default = defineCheck({
+  id: "bugs.broken-links",
+  name: "Broken Links & Assets",
+  category: "bugs",
+  mode: "static",
+  severity: "error",
+  description: "Checks that internal links, images, stylesheets, and scripts in the built output resolve to existing files.",
+  async run(ctx) {
+    const findings = [];
+    let checked = 0;
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      for (const { selector, attr, label } of REFERENCE_ATTRIBUTES) {
+        for (const el of root.querySelectorAll(selector)) {
+          const value = el.getAttribute(attr) ?? "";
+          if (!isInternal(value)) continue;
+          const cleanValue = value.split(/[?#]/)[0];
+          if (!cleanValue) continue;
+          checked++;
+          const target = cleanValue.startsWith("/") ? path4.join(ctx.outputDir, cleanValue) : path4.join(path4.dirname(page.file), cleanValue);
+          if (!targetExists(target, ctx)) {
+            findings.push(ctx.finding({ message: `Broken internal ${label} reference "${value}"`, file: page.relativeFile }));
+          }
+        }
+      }
+    }
+    ctx.detail({ label: "Internal references checked", value: String(checked) });
+    return findings;
+  }
+});
+
+// src/checks/bugs/console-errors.ts
+var console_errors_default = defineCheck({
+  id: "bugs.console-errors",
+  name: "Console Errors",
+  category: "bugs",
+  mode: "dynamic",
+  severity: "error",
+  description: "Reports console errors that occur while the page loads.",
+  async run(ctx) {
+    ctx.detail({ label: "Console messages captured", value: String(ctx.consoleMessages.length), url: ctx.pageInfo.urlPath });
+    return ctx.consoleMessages.filter((msg) => msg.type === "error" || msg.type === "pageerror").map(
+      (msg) => ctx.finding({
+        message: msg.type === "pageerror" ? `Uncaught exception: ${msg.text}` : `Console error: ${msg.text}`,
+        url: ctx.pageInfo.urlPath
+      })
+    );
+  }
+});
+
+// src/checks/bugs/nested-block-elements.ts
+import { HTMLElement } from "node-html-parser";
+var BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "blockquote",
+  "details",
+  "dialog",
+  "dd",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "hgroup",
+  "hr",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "p",
+  "pre",
+  "section",
+  "table",
+  "ul"
+]);
+var INLINE_ELEMENTS = "span, em, strong, b, i, u, small, sub, sup";
+var INTERACTIVE_ELEMENTS = /* @__PURE__ */ new Set(["a", "button", "input", "select", "textarea", "label", "details", "audio", "video", "iframe"]);
+var nested_block_elements_default = defineCheck({
+  id: "bugs.nested-block-elements",
+  name: "Nested Block Elements",
+  category: "bugs",
+  mode: "static",
+  severity: "info",
+  description: "Detects invalid nesting: block elements inside genuinely inline elements, and interactive elements nested inside an <a>.",
+  async run(ctx) {
+    const findings = [];
+    let elementsChecked = 0;
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      for (const el of root.querySelectorAll(INLINE_ELEMENTS)) {
+        elementsChecked++;
+        for (const child of el.childNodes) {
+          if (child.nodeType === 1 && child instanceof HTMLElement) {
+            const tagName = child.tagName.toLowerCase();
+            if (BLOCK_ELEMENTS.has(tagName)) {
+              findings.push(
+                ctx.finding({
+                  message: `Block element "<${child.tagName}>" nested inside inline "<${el.tagName}>"`,
+                  file: page.relativeFile,
+                  severity: "info"
+                })
+              );
+            }
+          }
+        }
+      }
+      for (const anchor of root.querySelectorAll("a")) {
+        elementsChecked++;
+        for (const descendant of anchor.querySelectorAll([...INTERACTIVE_ELEMENTS].filter((tag) => tag !== "a").join(", "))) {
+          findings.push(
+            ctx.finding({
+              message: `Interactive element "<${descendant.tagName}>" nested inside "<a>" \u2014 invalid, and most browsers will break the outer link`,
+              file: page.relativeFile,
+              severity: "warn"
+            })
+          );
+        }
+        for (const _nestedAnchor of anchor.querySelectorAll("a")) {
+          findings.push(
+            ctx.finding({
+              message: `Nested "<a>" inside another "<a>" \u2014 invalid, and most browsers will break the outer link`,
+              file: page.relativeFile,
+              severity: "warn"
+            })
+          );
+        }
+      }
+    }
+    ctx.detail({ label: "Elements checked", value: String(elementsChecked) });
+    return findings;
+  }
+});
+
+// src/checks/bugs/viewport-meta.ts
+var viewport_meta_default = defineCheck({
+  id: "bugs.viewport-meta",
+  name: "Viewport Meta Tag",
+  category: "bugs",
+  mode: "static",
+  severity: "warn",
+  description: 'Checks that every page declares <meta name="viewport">, required for mobile-responsive rendering.',
+  async run(ctx) {
+    const findings = [];
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const viewport = root.querySelector('meta[name="viewport"]')?.getAttribute("content");
+      if (!viewport) {
+        findings.push(
+          ctx.finding({
+            message: 'Missing <meta name="viewport"> \u2014 page may not render correctly on mobile devices',
+            file: page.relativeFile
+          })
+        );
+      } else {
+        ctx.detail({ label: "viewport content", value: viewport, url: page.urlPath });
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/maintainability/dead-css.ts
+import path5 from "path";
+var MAX_FINDINGS = 20;
+var SOURCE_EXTENSIONS = "html,htm,js,jsx,mjs,cjs,ts,tsx,vue,svelte,astro,mdx,php,twig,liquid,njk,hbs,handlebars,ejs,pug";
+var IGNORE_MARKERS = ["node_modules", "/.astro/", "/.vercel/", "/.netlify/", "/.cache/", ".min.js"];
+var CLASS_SELECTOR_PATTERN = /\.([a-zA-Z_-][\w-]*)/g;
+var WORD_PATTERN = /[a-zA-Z_][\w-]*/g;
+function stripCssNoise(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/url\([^)]*\)/gi, " ").replace(/(['"])(?:(?!\1)[^\\]|\\.)*\1/g, " ");
+}
+var dead_css_default = defineCheck({
+  id: "maintainability.dead-css",
+  name: "Dead CSS",
+  category: "maintainability",
+  mode: "static",
+  severity: "info",
+  description: "Finds CSS classes defined in stylesheets that show up neither in the built pages nor anywhere in the project's own source files (templates, scripts, components) \u2014 a good signal they're safe to delete. Classes assembled purely from dynamic strings at runtime can still slip through undetected.",
+  async run(ctx) {
+    const cssFiles = (await globFiles("**/*.{css,scss,less}", { cwd: ctx.siteRoot })).filter(
+      (file) => !file.includes("node_modules") && !file.endsWith(".min.css")
+    );
+    if (cssFiles.length === 0) {
+      ctx.detail({ label: "CSS files scanned", value: "0" });
+      return [];
+    }
+    const definedClasses = /* @__PURE__ */ new Map();
+    for (const cssFile of cssFiles) {
+      let content;
+      try {
+        content = ctx.readFile(cssFile);
+      } catch {
+        continue;
+      }
+      const cleaned = stripCssNoise(content);
+      for (const match of cleaned.matchAll(CLASS_SELECTOR_PATTERN)) {
+        const nextChar = cleaned[match.index + match[0].length];
+        if (nextChar === "#" || nextChar === "$" || nextChar === "@") continue;
+        if (!definedClasses.has(match[1])) {
+          definedClasses.set(match[1], path5.relative(ctx.siteRoot, cssFile));
+        }
+      }
+    }
+    if (definedClasses.size === 0) {
+      ctx.detail({ label: "CSS classes defined", value: "0" });
+      return [];
+    }
+    const usedClasses = /* @__PURE__ */ new Set();
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      for (const el of root.querySelectorAll("[class]")) {
+        for (const cls of el.getAttribute("class")?.split(/\s+/) ?? []) {
+          if (cls) usedClasses.add(cls);
+        }
+      }
+    }
+    const unresolved = [...definedClasses.keys()].filter((cls) => !usedClasses.has(cls));
+    if (unresolved.length === 0) {
+      ctx.detail({ label: "CSS classes defined", value: String(definedClasses.size) });
+      return [];
+    }
+    const sourceFiles = (await globFiles(`**/*.{${SOURCE_EXTENSIONS}}`, { cwd: ctx.siteRoot })).filter(
+      (file) => !IGNORE_MARKERS.some((marker) => file.includes(marker))
+    );
+    const sourceTokens = /* @__PURE__ */ new Set();
+    for (const file of sourceFiles) {
+      let content;
+      try {
+        content = ctx.readFile(file);
+      } catch {
+        continue;
+      }
+      for (const match of content.matchAll(WORD_PATTERN)) {
+        sourceTokens.add(match[0]);
+      }
+    }
+    const findings = [];
+    for (const className of unresolved) {
+      if (sourceTokens.has(className)) continue;
+      findings.push(
+        ctx.finding({
+          message: `CSS class ".${className}" in "${definedClasses.get(className)}" not used in HTML or source`,
+          file: definedClasses.get(className),
+          severity: "info"
+        })
+      );
+    }
+    ctx.detail({ label: "CSS classes defined / unused", value: `${definedClasses.size} / ${unresolved.length}` });
+    return findings.slice(0, MAX_FINDINGS);
+  }
+});
+
+// src/checks/maintainability/duplication.ts
+import { mkdtemp, rm } from "fs/promises";
+import os from "os";
+import path7 from "path";
+
+// src/utils/resolve-bin.ts
+import { createRequire } from "module";
+import path6 from "path";
+var require2 = createRequire(import.meta.url);
+function resolvePackageBin(pkgName, binRelativePath) {
+  const pkgJsonPath = require2.resolve(`${pkgName}/package.json`);
+  return path6.join(path6.dirname(pkgJsonPath), binRelativePath);
+}
+
+// src/checks/maintainability/duplication.ts
+var MAX_FINDINGS2 = 20;
+var SOURCE_FORMATS = "javascript,typescript,jsx,tsx,vue,svelte,astro,css,scss,less,markup";
+var IGNORE_PATTERNS = [
+  // Dependencies, lockfiles and generated or minified assets.
+  "**/node_modules/**",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml",
+  "**/*.min.js",
+  "**/*.svg",
+  // Framework and deployment build caches.
+  "**/.astro/**",
+  "**/.vercel/**",
+  "**/.netlify/**",
+  "**/.cache/**",
+  // Type declarations, which are repetitive by nature.
+  "**/*.d.ts",
+  // Tests, fixtures and snapshots, where repetition is intentional.
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/__tests__/**",
+  "**/__mocks__/**",
+  "**/__snapshots__/**",
+  "**/*.snap",
+  "**/fixtures/**",
+  // Vendored third-party code.
+  "**/vendor/**"
+];
+var MIN_LINES = 15;
+var MIN_TOKENS = 150;
+var duplication_default = defineCheck({
+  id: "maintainability.duplication",
+  name: "Code Duplication (jscpd)",
+  category: "maintainability",
+  mode: "static",
+  severity: "warn",
+  description: "Finds duplicated code in the source folder via jscpd.",
+  async run(ctx) {
+    const jscpdBin = resolvePackageBin("jscpd", "run-jscpd.js");
+    const reportDir = await mkdtemp(path7.join(os.tmpdir(), "vortix-jscpd-"));
+    try {
+      const outputIsSiteRoot = path7.resolve(ctx.outputDir) === path7.resolve(ctx.siteRoot);
+      const ignore = [...IGNORE_PATTERNS, ...outputIsSiteRoot ? [] : [`**/${path7.basename(ctx.outputDir)}/**`]].join(",");
+      const escapedSiteRoot = ctx.siteRoot.replace(/'/g, "'\\''");
+      const escapedReportDir = reportDir.replace(/'/g, "'\\''");
+      await ctx.exec(
+        `node '${jscpdBin}' '${escapedSiteRoot}' --reporters json --output '${escapedReportDir}' --silent --min-lines ${MIN_LINES} --min-tokens ${MIN_TOKENS} --format "${SOURCE_FORMATS}" --ignore "${ignore}"`
+      );
+      const reportPath = path7.join(reportDir, "jscpd-report.json");
+      if (!ctx.fileExists(reportPath)) {
+        ctx.skip("jscpd did not produce a report \u2014 it may have failed to run");
+      }
+      let report = {};
+      try {
+        report = JSON.parse(ctx.readFile(reportPath));
+      } catch (error) {
+        ctx.skip(`jscpd produced an unreadable report: ${error.message}`);
+      }
+      const duplicates = report.duplicates ?? [];
+      ctx.detail({ label: "Duplicate code blocks found", value: String(duplicates.length) });
+      return duplicates.slice(0, MAX_FINDINGS2).map(
+        (dup) => ctx.finding({
+          message: `Duplicate code (${dup.lines} lines) between "${formatFileRef(dup.firstFile)}" and "${formatFileRef(dup.secondFile)}"`,
+          file: stripFormatSuffix(dup.firstFile?.name)
+        })
+      );
+    } finally {
+      await rm(reportDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+  }
+});
+function stripFormatSuffix(name) {
+  return name?.replace(/:[a-z]+$/, "");
+}
+function formatFileRef(ref) {
+  const name = stripFormatSuffix(ref?.name) ?? "?";
+  return ref?.start && ref?.end ? `${name}:${ref.start}-${ref.end}` : name;
+}
+
+// src/checks/maintainability/license-check.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import path8 from "path";
+var PROBLEMATIC_LICENSES = /* @__PURE__ */ new Set(["GPL-2.0", "GPL-3.0", "AGPL-3.0", "SSPL-1.0", "EUPL-1.1"]);
+var license_check_default = defineCheck({
+  id: "maintainability.license-check",
+  name: "License Check",
+  category: "maintainability",
+  mode: "static",
+  severity: "info",
+  description: "Checks dependencies for copyleft licenses that may conflict with proprietary code.",
+  async run(ctx) {
+    const findings = [];
+    const pkgPath = path8.join(ctx.siteRoot, "package.json");
+    if (!existsSync3(pkgPath)) {
+      ctx.skip("No package.json found");
+    }
+    const nodeModules = path8.join(ctx.siteRoot, "node_modules");
+    if (!existsSync3(nodeModules)) {
+      ctx.skip("node_modules not found \u2014 install dependencies first");
+    }
+    const lockPath = path8.join(ctx.siteRoot, "package-lock.json");
+    const npmPath = path8.join(ctx.siteRoot, "node_modules", ".package-lock.json");
+    const lockExists = existsSync3(lockPath) || existsSync3(npmPath);
+    if (!lockExists) {
+      ctx.skip("No lockfile found");
+    }
+    const deps = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    const allDeps = { ...deps.dependencies, ...deps.devDependencies };
+    let checked = 0;
+    for (const [name] of Object.entries(allDeps)) {
+      const licensePath = path8.join(nodeModules, name, "package.json");
+      if (!existsSync3(licensePath)) continue;
+      try {
+        const pkg = JSON.parse(readFileSync3(licensePath, "utf-8"));
+        const license = typeof pkg.license === "string" ? pkg.license : pkg.license?.type;
+        checked++;
+        if (license && PROBLEMATIC_LICENSES.has(license)) {
+          findings.push(
+            ctx.finding({
+              message: `Dependency "${name}" uses license "${license}" \u2014 may have copyleft restrictions`,
+              severity: "warn"
+            })
+          );
+        }
+      } catch {
+      }
+    }
+    ctx.detail({ label: "Dependencies with a resolvable license / flagged", value: `${checked} / ${findings.length}` });
+    return findings;
+  }
+});
+
+// src/checks/maintainability/outdated-dependencies.ts
+import path9 from "path";
+var outdated_dependencies_default = defineCheck({
+  id: "maintainability.outdated-dependencies",
+  name: "Outdated Dependencies (npm outdated)",
+  category: "maintainability",
+  mode: "static",
+  severity: "info",
+  description: 'Lists outdated npm dependencies via "npm outdated" (not a security signal \u2014 see security.dependency-vulnerabilities).',
+  async run(ctx) {
+    if (!ctx.fileExists(path9.join(ctx.siteRoot, "package.json"))) ctx.skip("no package.json found");
+    const output = await ctx.exec("npm outdated --json");
+    if (!output.trim()) {
+      ctx.detail({ label: "Outdated dependencies", value: "0" });
+      return [];
+    }
+    let report = {};
+    try {
+      report = JSON.parse(output);
+    } catch (error) {
+      ctx.skip(`npm outdated produced unreadable output: ${error.message}`);
+    }
+    ctx.detail({ label: "Outdated dependencies", value: String(Object.keys(report).length) });
+    return Object.entries(report).map(
+      ([name, info]) => ctx.finding({
+        message: `${name}: current ${info.current ?? "not installed"}, latest ${info.latest ?? "unknown"}`
+      })
+    );
+  }
+});
+
+// src/utils/budget.ts
+function severityForOverage(actual, budget) {
+  if (budget <= 0) return "error";
+  return actual >= budget * 1.5 ? "error" : "warn";
+}
+
+// src/checks/performance/asset-weight.ts
+var IMAGE_TYPES = ["image/png", "image/jpeg", "image/webp", "image/gif", "image/avif"];
+function assetPath(url) {
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function isImageRequest(req) {
+  return req.contentType ? IMAGE_TYPES.includes(req.contentType.split(";")[0].trim()) : false;
+}
+var asset_weight_default = defineCheck({
+  id: "performance.asset-weight",
+  name: "Asset Weight & Image Sizes",
+  category: "performance",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Checks total page weight and individual oversized images.",
+  async run(ctx) {
+    const budgets = ctx.config.performance.budgets;
+    const findings = [];
+    const totalKb = ctx.networkRequests.reduce((sum, r) => sum + r.bodySize, 0) / 1024;
+    ctx.detail({
+      label: "Page weight",
+      value: `${Math.round(totalKb)}KB (budget: ${budgets.maxPageWeightKb}KB)`,
+      url: ctx.pageInfo.urlPath
+    });
+    const images = ctx.networkRequests.filter(isImageRequest);
+    if (images.length > 0) {
+      const largestKb = Math.max(...images.map((r) => r.bodySize)) / 1024;
+      ctx.detail({
+        label: "Largest image",
+        value: `${Math.round(largestKb)}KB (budget: ${budgets.maxImageKb}KB)`,
+        url: ctx.pageInfo.urlPath
+      });
+    }
+    if (totalKb > budgets.maxPageWeightKb) {
+      findings.push(
+        ctx.finding({
+          message: `Page weight ${Math.round(totalKb)}KB exceeds budget of ${budgets.maxPageWeightKb}KB`,
+          url: ctx.pageInfo.urlPath,
+          severity: severityForOverage(totalKb, budgets.maxPageWeightKb)
+        })
+      );
+    }
+    for (const req of images) {
+      const sizeKb = req.bodySize / 1024;
+      if (sizeKb > budgets.maxImageKb) {
+        findings.push(
+          ctx.finding({
+            message: `Image "${assetPath(req.url)}" is ${Math.round(sizeKb)}KB (budget: ${budgets.maxImageKb}KB)`,
+            url: ctx.pageInfo.urlPath,
+            severity: severityForOverage(sizeKb, budgets.maxImageKb)
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/performance/core-web-vitals.ts
+var core_web_vitals_default = defineCheck({
+  id: "performance.core-web-vitals",
+  name: "Core Web Vitals Budget",
+  category: "performance",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Checks LCP and CLS against configured budgets.",
+  async run(ctx) {
+    const budgets = ctx.config.performance.budgets;
+    const metrics = await ctx.page.evaluate(
+      () => new Promise((resolve) => {
+        let lcp = 0;
+        let lastLcpAt = performance.now();
+        const shifts = [];
+        let lcpObserver;
+        let clsObserver;
+        try {
+          lcpObserver = new PerformanceObserver((list) => {
+            const entries = list.getEntries();
+            const last = entries[entries.length - 1];
+            if (last) {
+              lcp = last.renderTime || last.loadTime || last.startTime;
+              lastLcpAt = performance.now();
+            }
+          });
+          lcpObserver.observe({ type: "largest-contentful-paint", buffered: true });
+          clsObserver = new PerformanceObserver((list) => {
+            for (const entry of list.getEntries()) {
+              if (!entry.hadRecentInput) shifts.push({ value: entry.value ?? 0, startTime: entry.startTime });
+            }
+          });
+          clsObserver.observe({ type: "layout-shift", buffered: true });
+        } catch {
+        }
+        function maxSessionWindowCls(entries) {
+          let maxSum = 0;
+          let windowSum = 0;
+          let windowStart = -1;
+          let windowEnd = -1;
+          for (const shift of [...entries].sort((a, b) => a.startTime - b.startTime)) {
+            const startsNewWindow = windowStart === -1 || shift.startTime - windowEnd > 1e3 || shift.startTime - windowStart > 5e3;
+            if (startsNewWindow) {
+              windowStart = shift.startTime;
+              windowSum = 0;
+            }
+            windowEnd = shift.startTime;
+            windowSum += shift.value;
+            maxSum = Math.max(maxSum, windowSum);
+          }
+          return maxSum;
+        }
+        const start = performance.now();
+        const poll = () => {
+          const now = performance.now();
+          if (now - lastLcpAt >= 500 || now - start >= 3e3) {
+            lcpObserver?.disconnect();
+            clsObserver?.disconnect();
+            resolve({ lcp, cls: maxSessionWindowCls(shifts) });
+            return;
+          }
+          setTimeout(poll, 100);
+        };
+        poll();
+      })
+    );
+    const findings = [];
+    ctx.detail({ label: "LCP", value: `${Math.round(metrics.lcp)}ms (budget: ${budgets.lcpMs}ms)`, url: ctx.pageInfo.urlPath });
+    ctx.detail({ label: "CLS", value: `${metrics.cls.toFixed(3)} (budget: ${budgets.cls})`, url: ctx.pageInfo.urlPath });
+    if (metrics.lcp > budgets.lcpMs) {
+      findings.push(
+        ctx.finding({
+          message: `LCP ${Math.round(metrics.lcp)}ms exceeds budget of ${budgets.lcpMs}ms`,
+          url: ctx.pageInfo.urlPath,
+          severity: severityForOverage(metrics.lcp, budgets.lcpMs)
+        })
+      );
+    }
+    if (metrics.cls > budgets.cls) {
+      findings.push(
+        ctx.finding({
+          message: `CLS ${metrics.cls.toFixed(3)} exceeds budget of ${budgets.cls}`,
+          url: ctx.pageInfo.urlPath,
+          severity: severityForOverage(metrics.cls, budgets.cls)
+        })
+      );
+    }
+    return findings;
+  }
+});
+
+// src/checks/performance/image-format.ts
+var MODERN_FORMATS = /* @__PURE__ */ new Set(["webp", "avif", "svg"]);
+var image_format_default = defineCheck({
+  id: "performance.image-format",
+  name: "Image Format",
+  category: "performance",
+  mode: "static",
+  severity: "info",
+  description: "Checks if images use modern formats (WebP/AVIF) instead of legacy formats.",
+  async run(ctx) {
+    const findings = [];
+    let total = 0;
+    let modern = 0;
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const images = root.querySelectorAll("img[src]");
+      for (const img of images) {
+        const src = img.getAttribute("src") ?? "";
+        const ext = src.split(".").pop()?.split("?")[0]?.toLowerCase();
+        if (!ext) continue;
+        total++;
+        if (MODERN_FORMATS.has(ext)) modern++;
+        if (!MODERN_FORMATS.has(ext) && ["jpg", "jpeg", "png", "gif"].includes(ext)) {
+          findings.push(
+            ctx.finding({
+              message: `Image "${src}" uses legacy format "${ext}" \u2014 consider WebP or AVIF`,
+              file: page.relativeFile
+            })
+          );
+        }
+      }
+    }
+    ctx.detail({ label: "Images using a modern format", value: `${modern} / ${total}` });
+    return findings;
+  }
+});
+
+// src/checks/performance/lazy-loading.ts
+var lazy_loading_default = defineCheck({
+  id: "performance.lazy-loading",
+  name: "Lazy Loading",
+  category: "performance",
+  mode: "dynamic",
+  severity: "info",
+  description: 'Checks that images below the fold use loading="lazy", and flags the opposite mistake: an image visible without scrolling marked loading="lazy", which delays it and can hurt LCP. Needs real layout, so this runs in a browser rather than scanning the HTML.',
+  async run(ctx) {
+    const viewportHeight = ctx.page.viewportSize()?.height ?? 720;
+    const images = await ctx.page.$$eval(
+      "img[src]",
+      (elements) => elements.map((el) => {
+        const rect = el.getBoundingClientRect();
+        return {
+          src: el.getAttribute("src") ?? "",
+          loading: el.getAttribute("loading"),
+          top: rect.top,
+          width: rect.width,
+          height: rect.height
+        };
+      })
+    );
+    const eligible = images.filter((img) => img.width > 0 && img.height > 0);
+    const lazyCount = eligible.filter((img) => img.loading === "lazy").length;
+    ctx.detail({ label: "Images checked / marked lazy", value: `${eligible.length} / ${lazyCount}`, url: ctx.pageInfo.urlPath });
+    const findings = [];
+    for (const img of images) {
+      if (img.width === 0 || img.height === 0) continue;
+      const isAboveTheFold = img.top < viewportHeight;
+      if (isAboveTheFold && img.loading === "lazy") {
+        findings.push(
+          ctx.finding({
+            message: `Image "${img.src}" is visible without scrolling but marked loading="lazy" \u2014 delays it behind the loading queue and can hurt LCP`,
+            url: ctx.pageInfo.urlPath,
+            severity: "warn"
+          })
+        );
+      } else if (!isAboveTheFold && img.loading !== "lazy") {
+        findings.push(
+          ctx.finding({
+            message: `Image "${img.src}" is below the fold but missing loading="lazy"`,
+            url: ctx.pageInfo.urlPath
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/performance/third-party-impact.ts
+var third_party_impact_default = defineCheck({
+  id: "performance.third-party-impact",
+  name: "Third-Party Impact",
+  category: "performance",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Detects render-blocking third-party resources that may impact performance.",
+  async run(ctx) {
+    const findings = [];
+    const firstPartyHost = new URL(ctx.page.url()).hostname;
+    const thirdPartyRequests = ctx.networkRequests.filter((req) => {
+      if (!req.isMainFrame) return false;
+      try {
+        const host = new URL(req.url).hostname;
+        return host !== firstPartyHost && !host.endsWith(`.${firstPartyHost}`);
+      } catch {
+        return false;
+      }
+    });
+    const nonBlockingScriptUrls = new Set(
+      await ctx.page.$$eval("script[src][async], script[src][defer]", (els) => els.map((el) => el.src))
+    );
+    const blockingTypes = ["text/html", "text/css", "application/javascript", "text/javascript"];
+    const blockingRequests = thirdPartyRequests.filter((req) => {
+      const contentType = req.contentType?.split(";")[0]?.trim() ?? "";
+      if (!blockingTypes.includes(contentType)) return false;
+      if (req.resourceType === "script" && nonBlockingScriptUrls.has(req.url)) return false;
+      return true;
+    });
+    for (const req of blockingRequests) {
+      findings.push(
+        ctx.finding({
+          message: `Third-party blocking resource: "${req.url}"`,
+          url: ctx.pageInfo.urlPath
+        })
+      );
+    }
+    ctx.detail({
+      label: "Third-party requests / render-blocking",
+      value: `${thirdPartyRequests.length} / ${blockingRequests.length}`,
+      url: ctx.pageInfo.urlPath
+    });
+    return findings;
+  }
+});
+
+// src/checks/privacy/match-domains.ts
+function uniqueUrlsMatchingDomains(requests, domains) {
+  const matches = requests.filter((r) => {
+    try {
+      const host = new URL(r.url).hostname;
+      return domains.some((domain) => host === domain || host.endsWith(`.${domain}`));
+    } catch {
+      return false;
+    }
+  });
+  return [...new Set(matches.map((r) => r.url))];
+}
+
+// src/checks/privacy/external-fonts.ts
+var EXTERNAL_FONT_HOSTS = ["fonts.googleapis.com", "fonts.gstatic.com", "use.typekit.net", "fonts.adobe.com"];
+var external_fonts_default = defineCheck({
+  id: "privacy.external-fonts",
+  name: "External Fonts/APIs",
+  category: "privacy",
+  mode: "dynamic",
+  severity: "info",
+  description: "Detects externally loaded fonts/APIs (a GDPR consideration \u2014 self-hosting is recommended).",
+  async run(ctx) {
+    const uniqueUrls = uniqueUrlsMatchingDomains(ctx.networkRequests, EXTERNAL_FONT_HOSTS);
+    ctx.detail({ label: "Externally loaded fonts/APIs", value: String(uniqueUrls.length), url: ctx.pageInfo.urlPath });
+    return uniqueUrls.map((url) => ctx.finding({ message: `Externally loaded resource "${url}"`, url: ctx.pageInfo.urlPath }));
+  }
+});
+
+// src/checks/privacy/fingerprinting.ts
+var FINGERPRINTING_APIS = [
+  "canvas.toDataURL",
+  "canvas.toBlob",
+  "canvas.getContext('webgl')",
+  "canvas.getContext('experimental-webgl')",
+  "webgl.getParameter",
+  "audioContext.createOscillator",
+  "AudioContext",
+  "OfflineAudioContext"
+];
+var fingerprinting_default = defineCheck({
+  id: "privacy.fingerprinting",
+  name: "Fingerprinting",
+  category: "privacy",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Detects browser fingerprinting APIs (Canvas, WebGL, Audio).",
+  async run(ctx) {
+    const findings = [];
+    const scripts = await ctx.page.$$eval("script:not([src])", (els) => els.map((el) => el.textContent ?? "").join("\n"));
+    for (const api of FINGERPRINTING_APIS) {
+      if (scripts.includes(api)) {
+        findings.push(
+          ctx.finding({
+            message: `Potential fingerprinting API detected: "${api}"`,
+            url: ctx.pageInfo.urlPath
+          })
+        );
+      }
+    }
+    ctx.detail({
+      label: "Fingerprinting APIs checked / found",
+      value: `${FINGERPRINTING_APIS.length} / ${findings.length}`,
+      url: ctx.pageInfo.urlPath
+    });
+    return findings;
+  }
+});
+
+// src/checks/privacy/tracker-requests.ts
+var BUILT_IN_TRACKER_DOMAINS = [
+  "google-analytics.com",
+  "googletagmanager.com",
+  "doubleclick.net",
+  "connect.facebook.net",
+  "facebook.com/tr",
+  "hotjar.com",
+  "segment.io",
+  "mixpanel.com",
+  "analytics.tiktok.com"
+];
+var CONSENT_HINTS = ["cookieconsent", "cookiebot", "usercentrics", "klaro", "cookie-consent", "cmp"];
+var tracker_requests_default = defineCheck({
+  id: "privacy.tracker-requests",
+  name: "Tracking Without Consent",
+  category: "privacy",
+  mode: "dynamic",
+  severity: "warn",
+  description: "Heuristic: tracking requests on initial load without a detectable consent mechanism.",
+  async run(ctx) {
+    const trackerDomains = [...BUILT_IN_TRACKER_DOMAINS, ...ctx.config.privacy.trackerDomains];
+    const uniqueUrls = uniqueUrlsMatchingDomains(ctx.networkRequests, trackerDomains);
+    if (uniqueUrls.length === 0) {
+      ctx.detail({ label: "Tracker requests detected", value: "0", url: ctx.pageInfo.urlPath });
+      return [];
+    }
+    const html = (await ctx.page.content()).toLowerCase();
+    const hasConsentHint = CONSENT_HINTS.some((hint) => html.includes(hint));
+    ctx.detail({
+      label: "Tracker requests / consent mechanism detected",
+      value: `${uniqueUrls.length} / ${hasConsentHint ? "yes" : "no"}`,
+      url: ctx.pageInfo.urlPath
+    });
+    if (hasConsentHint) return [];
+    return uniqueUrls.map(
+      (url) => ctx.finding({
+        message: `Tracking request to "${url}" on load without a detectable consent mechanism (heuristic)`,
+        url: ctx.pageInfo.urlPath
+      })
+    );
+  }
+});
+
+// src/checks/security/cookie-security.ts
+function cookieName(setCookieHeader) {
+  return setCookieHeader.split(";")[0]?.split("=")[0]?.trim() || "(unnamed)";
+}
+function hasAttribute(setCookieHeader, attribute) {
+  return setCookieHeader.split(";").slice(1).some((part) => part.trim().toLowerCase().startsWith(attribute));
+}
+var cookie_security_default = defineCheck({
+  id: "security.cookie-security",
+  name: "Cookie Security",
+  category: "security",
+  mode: "live",
+  severity: "warn",
+  description: "Checks Set-Cookie headers on the live response for missing Secure, HttpOnly, and SameSite attributes.",
+  run(ctx) {
+    ctx.detail({ label: "Cookies set", value: String(ctx.setCookieHeaders.length) });
+    if (ctx.setCookieHeaders.length === 0) return [];
+    const isHttps = ctx.isHttps;
+    const findings = [];
+    for (const setCookie of ctx.setCookieHeaders) {
+      const name = cookieName(setCookie);
+      ctx.detail({
+        label: name,
+        value: `Secure: ${hasAttribute(setCookie, "secure")}, HttpOnly: ${hasAttribute(setCookie, "httponly")}, SameSite: ${hasAttribute(setCookie, "samesite")}`
+      });
+      if (isHttps && !hasAttribute(setCookie, "secure")) {
+        findings.push(
+          ctx.finding({ message: `Cookie "${name}" is missing the Secure attribute \u2014 it can be sent over an unencrypted connection` })
+        );
+      }
+      if (!hasAttribute(setCookie, "httponly")) {
+        findings.push(
+          ctx.finding({
+            message: `Cookie "${name}" is missing the HttpOnly attribute \u2014 it's readable from JavaScript, widening the blast radius of an XSS bug`
+          })
+        );
+      }
+      if (!hasAttribute(setCookie, "samesite")) {
+        findings.push(
+          ctx.finding({
+            message: `Cookie "${name}" is missing the SameSite attribute \u2014 it defaults to a lax policy that still allows some cross-site requests`,
+            severity: "info"
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/security/dependency-vulnerabilities.ts
+import path10 from "path";
+var SEVERITY_MAP = {
+  critical: "error",
+  high: "error",
+  moderate: "warn",
+  low: "info",
+  info: "info"
+};
+var dependency_vulnerabilities_default = defineCheck({
+  id: "security.dependency-vulnerabilities",
+  name: "Dependency Vulnerabilities (npm audit)",
+  category: "security",
+  mode: "static",
+  severity: "error",
+  description: 'Checks for known vulnerabilities in npm dependencies via "npm audit".',
+  async run(ctx) {
+    if (!ctx.fileExists(path10.join(ctx.siteRoot, "package.json"))) ctx.skip("no package.json found");
+    const hasNpmLock = ctx.fileExists(path10.join(ctx.siteRoot, "package-lock.json"));
+    if (!hasNpmLock) {
+      if (ctx.fileExists(path10.join(ctx.siteRoot, "pnpm-lock.yaml"))) {
+        ctx.skip("project uses a pnpm lockfile \u2014 npm audit can't read it; run `pnpm audit` manually");
+      }
+      if (ctx.fileExists(path10.join(ctx.siteRoot, "yarn.lock"))) {
+        ctx.skip("project uses a yarn lockfile \u2014 npm audit can't read it; run `yarn audit` manually");
+      }
+      ctx.skip("no package-lock.json found \u2014 run `npm install` so dependencies can be audited");
+    }
+    const output = await ctx.exec("npm audit --json");
+    let report = {};
+    try {
+      report = JSON.parse(output);
+    } catch (error) {
+      ctx.skip(`npm audit produced unreadable output: ${error.message}`);
+    }
+    if (report.error) {
+      ctx.skip(`npm audit failed: ${report.error.summary ?? report.error.code ?? "unknown error"}`);
+    }
+    const vulnerabilities = Object.entries(report.vulnerabilities ?? {});
+    ctx.detail({ label: "Vulnerable dependencies found", value: String(vulnerabilities.length) });
+    return vulnerabilities.map(
+      ([name, info]) => ctx.finding({
+        message: `${name}: ${info.severity} severity vulnerability${info.via?.[0]?.title ? ` (${info.via[0].title})` : ""}`,
+        severity: SEVERITY_MAP[info.severity] ?? "warn"
+      })
+    );
+  }
+});
+
+// src/checks/security/https-enforced.ts
+var https_enforced_default = defineCheck({
+  id: "security.https-enforced",
+  name: "HTTPS Enforced",
+  category: "security",
+  mode: "live",
+  severity: "error",
+  description: "Checks that the site is served over HTTPS, or at least redirects HTTP requests to HTTPS.",
+  run(ctx) {
+    ctx.detail({ label: "Protocol", value: ctx.parsedUrl.protocol.replace(":", "") });
+    ctx.detail({ label: "Final URL", value: ctx.finalUrl });
+    if (ctx.parsedUrl.protocol === "https:") return [];
+    if (ctx.redirected && ctx.finalUrl.startsWith("https://")) {
+      return [
+        ctx.finding({
+          message: `HTTP requests redirect to HTTPS (ended up at "${ctx.finalUrl}"), but the initial connection is still unencrypted \u2014 link directly to the HTTPS URL and add a Strict-Transport-Security header`,
+          severity: "info"
+        })
+      ];
+    }
+    return [
+      ctx.finding({
+        message: "Site is served over plain HTTP and does not redirect to HTTPS \u2014 traffic (including any credentials) can be intercepted or modified in transit",
+        severity: "error"
+      })
+    ];
+  }
+});
+
+// src/checks/security/mixed-content.ts
+import { parse as parse2 } from "node-html-parser";
+var RESOURCE_ATTRS = [
+  ["img[src]", "src"],
+  ["script[src]", "src"],
+  ["iframe[src]", "src"],
+  ["source[src]", "src"],
+  ["video[src]", "src"],
+  ["audio[src]", "src"],
+  ["embed[src]", "src"],
+  ["object[data]", "data"],
+  ['link[rel="stylesheet"][href]', "href"]
+];
+var CSS_URL_PATTERN = /url\(\s*['"]?(http:\/\/[^)'"]+)['"]?\s*\)/gi;
+var mixed_content_default = defineCheck({
+  id: "security.mixed-content",
+  name: "Mixed Content",
+  category: "security",
+  mode: "live",
+  severity: "warn",
+  description: "Scans the fetched HTML of an HTTPS page for hardcoded HTTP resource references (img/script/iframe/stylesheet/etc., and url(http://...) in CSS). Resources injected by client-side JavaScript after load aren't visible here.",
+  run(ctx) {
+    if (!ctx.isHttps) {
+      ctx.skip("Mixed content only applies to HTTPS pages \u2014 this URL is HTTP");
+    }
+    const root = parse2(ctx.html);
+    const findings = [];
+    let checked = 0;
+    for (const [selector, attribute] of RESOURCE_ATTRS) {
+      for (const el of root.querySelectorAll(selector)) {
+        const url = el.getAttribute(attribute);
+        if (!url) continue;
+        checked++;
+        if (/^http:\/\//i.test(url)) {
+          findings.push(ctx.finding({ message: `Mixed content: HTTP resource "${url}" referenced on an HTTPS page` }));
+        }
+      }
+    }
+    for (const styleEl of root.querySelectorAll("style")) {
+      for (const match of styleEl.text.matchAll(CSS_URL_PATTERN)) {
+        checked++;
+        findings.push(ctx.finding({ message: `Mixed content: HTTP resource "${match[1]}" referenced in an inline <style> block` }));
+      }
+    }
+    for (const el of root.querySelectorAll("[style]")) {
+      for (const match of (el.getAttribute("style") ?? "").matchAll(CSS_URL_PATTERN)) {
+        checked++;
+        findings.push(ctx.finding({ message: `Mixed content: HTTP resource "${match[1]}" referenced in a style attribute` }));
+      }
+    }
+    ctx.detail({ label: "Resource references checked", value: String(checked) });
+    return findings;
+  }
+});
+
+// src/checks/security/security-headers.ts
+var HEADER_RULES = [
+  {
+    header: "strict-transport-security",
+    severity: "warn",
+    message: "Missing Strict-Transport-Security header \u2014 browsers can't be told to always use HTTPS for this site",
+    httpsOnly: true
+  },
+  {
+    header: "content-security-policy",
+    severity: "warn",
+    message: "Missing Content-Security-Policy header \u2014 no baseline defense against XSS/data-injection attacks"
+  },
+  {
+    header: "x-content-type-options",
+    severity: "warn",
+    message: "Missing X-Content-Type-Options header \u2014 browsers may MIME-sniff responses into an unintended content type"
+  },
+  {
+    header: "referrer-policy",
+    severity: "info",
+    message: "Missing Referrer-Policy header \u2014 full URLs (query strings included) may leak to third parties via the Referer header"
+  },
+  {
+    header: "permissions-policy",
+    severity: "info",
+    message: "Missing Permissions-Policy header \u2014 no explicit restriction on powerful browser features (camera, geolocation, ...)"
+  }
+];
+var security_headers_default = defineCheck({
+  id: "security.security-headers",
+  name: "Security Headers",
+  category: "security",
+  mode: "live",
+  severity: "warn",
+  description: "Checks the live response for standard security headers (HSTS, CSP, X-Content-Type-Options, Referrer-Policy, Permissions-Policy, X-Frame-Options/frame-ancestors).",
+  run(ctx) {
+    const findings = [];
+    const isHttps = ctx.isHttps;
+    const csp = ctx.headers["content-security-policy"];
+    for (const rule of HEADER_RULES) {
+      if (rule.httpsOnly && !isHttps) continue;
+      const value = ctx.headers[rule.header];
+      ctx.detail({ label: rule.header, value: value ?? "(missing)" });
+      if (!value) {
+        findings.push(ctx.finding({ message: rule.message, severity: rule.severity }));
+      }
+    }
+    const hasFrameAncestors = csp?.toLowerCase().includes("frame-ancestors") ?? false;
+    ctx.detail({
+      label: "x-frame-options",
+      value: ctx.headers["x-frame-options"] ?? (hasFrameAncestors ? "(covered by CSP frame-ancestors)" : "(missing)")
+    });
+    if (!ctx.headers["x-frame-options"] && !hasFrameAncestors) {
+      findings.push(
+        ctx.finding({
+          message: "Missing X-Frame-Options header (and no CSP frame-ancestors directive) \u2014 page can be embedded in a clickjacking iframe",
+          severity: "warn"
+        })
+      );
+    }
+    return findings;
+  }
+});
+
+// src/checks/security/server-info-disclosure.ts
+var DISCLOSURE_HEADERS = ["server", "x-powered-by", "x-aspnet-version", "x-aspnetmvc-version"];
+var VERSION_PATTERN = /\d+\.\d+/;
+var server_info_disclosure_default = defineCheck({
+  id: "security.server-info-disclosure",
+  name: "Server Info Disclosure",
+  category: "security",
+  mode: "live",
+  severity: "info",
+  description: "Flags response headers (Server, X-Powered-By, ...) that disclose server software or version numbers to attackers.",
+  run(ctx) {
+    const findings = [];
+    for (const header of DISCLOSURE_HEADERS) {
+      const value = ctx.headers[header];
+      ctx.detail({ label: header, value: value ?? "(not sent)" });
+      if (!value) continue;
+      const revealsVersion = VERSION_PATTERN.test(value);
+      findings.push(
+        ctx.finding({
+          message: `"${header}" header discloses ${revealsVersion ? "a specific software version" : "server software"}: "${value}"`,
+          severity: revealsVersion ? "warn" : "info"
+        })
+      );
+    }
+    return findings;
+  }
+});
+
+// src/checks/seo/canonical-url.ts
+var canonical_url_default = defineCheck({
+  id: "seo.canonical-url",
+  name: "Canonical URL",
+  category: "seo",
+  mode: "static",
+  severity: "warn",
+  description: "Checks for missing or duplicate canonical URLs.",
+  async run(ctx) {
+    const findings = [];
+    const seen = /* @__PURE__ */ new Map();
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const canonical = root.querySelector('link[rel="canonical"]')?.getAttribute("href");
+      if (!canonical) {
+        findings.push(
+          ctx.finding({
+            message: "Missing canonical URL",
+            file: page.relativeFile
+          })
+        );
+        continue;
+      }
+      ctx.detail({ label: "Canonical URL", value: canonical, url: page.urlPath });
+      const existing = seen.get(canonical);
+      if (existing && existing !== page.relativeFile) {
+        findings.push(
+          ctx.finding({
+            message: `Duplicate canonical URL "${canonical}" used by "${existing}"`,
+            file: page.relativeFile,
+            severity: "warn"
+          })
+        );
+      } else {
+        seen.set(canonical, page.relativeFile);
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/seo/meta-tags.ts
+var OG_PROPERTIES = ["og:title", "og:description", "og:image"];
+var TITLE_TRUNCATION_LENGTH = 70;
+var meta_tags_default = defineCheck({
+  id: "seo.meta-tags",
+  name: "Meta/Title/OG Tags",
+  category: "seo",
+  mode: "static",
+  severity: "warn",
+  description: "Checks title, meta description, and Open Graph tags per page.",
+  async run(ctx) {
+    const findings = [];
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const title = root.querySelector("title")?.text?.trim();
+      if (!title) {
+        findings.push(ctx.finding({ message: "Missing <title>", file: page.relativeFile }));
+      } else {
+        ctx.detail({ label: "Title", value: `"${title}" (${title.length} chars)`, url: page.urlPath });
+        if (title.length > TITLE_TRUNCATION_LENGTH) {
+          findings.push(
+            ctx.finding({
+              message: `Title is ${title.length} characters long \u2014 likely truncated in search results (~${TITLE_TRUNCATION_LENGTH}+ chars)`,
+              file: page.relativeFile
+            })
+          );
+        }
+      }
+      const description = root.querySelector('meta[name="description"]')?.getAttribute("content")?.trim();
+      if (!description) {
+        findings.push(ctx.finding({ message: 'Missing <meta name="description">', file: page.relativeFile }));
+      } else {
+        ctx.detail({ label: "Meta description", value: `"${description}" (${description.length} chars)`, url: page.urlPath });
+      }
+      const foundOg = OG_PROPERTIES.filter((property) => root.querySelector(`meta[property="${property}"]`)?.getAttribute("content"));
+      ctx.detail({ label: "Open Graph tags found", value: foundOg.length > 0 ? foundOg.join(", ") : "(none)", url: page.urlPath });
+      const missingOg = OG_PROPERTIES.filter((property) => !foundOg.includes(property));
+      if (missingOg.length > 0) {
+        findings.push(
+          ctx.finding({
+            message: `Missing Open Graph tag${missingOg.length > 1 ? "s" : ""}: ${missingOg.join(", ")}`,
+            file: page.relativeFile
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/seo/og-images.ts
+import { existsSync as existsSync4 } from "fs";
+import path11 from "path";
+var og_images_default = defineCheck({
+  id: "seo.og-images",
+  name: "Open Graph Images",
+  category: "seo",
+  mode: "static",
+  severity: "info",
+  description: "Validates Open Graph images exist and are accessible.",
+  async run(ctx) {
+    const findings = [];
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const ogImage = root.querySelector('meta[property="og:image"]')?.getAttribute("content");
+      if (!ogImage) {
+        findings.push(
+          ctx.finding({
+            message: "Missing og:image tag",
+            file: page.relativeFile,
+            severity: "info"
+          })
+        );
+        continue;
+      }
+      ctx.detail({ label: "og:image", value: ogImage, url: page.urlPath });
+      if (ogImage.startsWith("http")) continue;
+      const imagePath = path11.join(path11.dirname(page.file), ogImage);
+      if (!existsSync4(imagePath)) {
+        findings.push(
+          ctx.finding({
+            message: `og:image "${ogImage}" not found`,
+            file: page.relativeFile
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/seo/robots-sitemap.ts
+import path12 from "path";
+function isBlanketDisallow(content) {
+  let currentAgentIsWildcard = false;
+  for (const rawLine of content.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (/^user-agent\s*:/i.test(line)) {
+      currentAgentIsWildcard = line.split(":")[1]?.trim() === "*";
+      continue;
+    }
+    if (currentAgentIsWildcard && /^disallow\s*:\s*\/\s*$/i.test(line)) return true;
+  }
+  return false;
+}
+function extractSitemapUrls(content) {
+  return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^sitemap\s*:/i.test(line)).map((line) => line.slice(line.indexOf(":") + 1).trim());
+}
+var robots_sitemap_default = defineCheck({
+  id: "seo.robots-sitemap",
+  name: "robots.txt & Sitemap",
+  category: "seo",
+  mode: "static",
+  severity: "error",
+  description: "Flags an accidental site-wide crawl block in robots.txt and Sitemap references that don't resolve.",
+  async run(ctx) {
+    const findings = [];
+    const robotsPath = path12.join(ctx.outputDir, "robots.txt");
+    if (!ctx.fileExists(robotsPath)) {
+      ctx.detail({ label: "robots.txt found", value: "no" });
+      return findings;
+    }
+    const content = ctx.readFile(robotsPath);
+    const sitemapUrls = extractSitemapUrls(content);
+    ctx.detail({ label: "Sitemap references in robots.txt", value: sitemapUrls.length > 0 ? sitemapUrls.join(", ") : "(none)" });
+    if (isBlanketDisallow(content)) {
+      findings.push(
+        ctx.finding({
+          message: 'robots.txt blocks all crawlers ("User-agent: *" + "Disallow: /") \u2014 the site is invisible to search engines',
+          file: "robots.txt"
+        })
+      );
+    }
+    for (const sitemapUrl of sitemapUrls) {
+      let sitemapPath;
+      try {
+        sitemapPath = new URL(sitemapUrl).pathname;
+      } catch {
+        sitemapPath = sitemapUrl;
+      }
+      if (!ctx.fileExists(path12.join(ctx.outputDir, sitemapPath))) {
+        findings.push(
+          ctx.finding({
+            message: `robots.txt references a Sitemap that doesn't exist in the build output: "${sitemapUrl}"`,
+            file: "robots.txt",
+            severity: "warn"
+          })
+        );
+      }
+    }
+    return findings;
+  }
+});
+
+// src/checks/seo/structured-data.ts
+var structured_data_default = defineCheck({
+  id: "seo.structured-data",
+  name: "Structured Data",
+  category: "seo",
+  mode: "static",
+  severity: "info",
+  description: "Validates JSON-LD structured data exists and has basic structure.",
+  async run(ctx) {
+    const findings = [];
+    for (const page of ctx.pages) {
+      const root = parseHtmlFile(page.file);
+      const scripts = root.querySelectorAll('script[type="application/ld+json"]');
+      if (scripts.length === 0) {
+        ctx.detail({ label: "JSON-LD blocks found", value: "0", url: page.urlPath });
+        findings.push(
+          ctx.finding({
+            message: "No JSON-LD structured data found",
+            file: page.relativeFile,
+            severity: "info"
+          })
+        );
+        continue;
+      }
+      const types = [];
+      for (const script of scripts) {
+        try {
+          const data = JSON.parse(script.textContent ?? "");
+          if (data["@type"]) types.push(String(data["@type"]));
+          if (!data["@type"]) {
+            findings.push(
+              ctx.finding({
+                message: "JSON-LD missing @type property",
+                file: page.relativeFile,
+                severity: "warn"
+              })
+            );
+          }
+        } catch {
+          findings.push(
+            ctx.finding({
+              message: "Invalid JSON-LD syntax",
+              file: page.relativeFile,
+              severity: "warn"
+            })
+          );
+        }
+      }
+      ctx.detail({
+        label: "JSON-LD blocks / @types found",
+        value: `${scripts.length} / ${types.length > 0 ? types.join(", ") : "(none)"}`,
+        url: page.urlPath
+      });
+    }
+    return findings;
+  }
+});
+
+// src/checks/index.ts
+var BUILT_IN_CHECKS = [
+  core_web_vitals_default,
+  asset_weight_default,
+  image_format_default,
+  lazy_loading_default,
+  third_party_impact_default,
+  dependency_vulnerabilities_default,
+  mixed_content_default,
+  security_headers_default,
+  https_enforced_default,
+  server_info_disclosure_default,
+  cookie_security_default,
+  axe_default,
+  color_contrast_default,
+  broken_links_default,
+  console_errors_default,
+  viewport_meta_default,
+  anchor_links_default,
+  nested_block_elements_default,
+  meta_tags_default,
+  robots_sitemap_default,
+  structured_data_default,
+  canonical_url_default,
+  og_images_default,
+  duplication_default,
+  outdated_dependencies_default,
+  license_check_default,
+  dead_css_default,
+  tracker_requests_default,
+  external_fonts_default,
+  fingerprinting_default
+];
+
+// src/core/load-checks.ts
+async function loadChecks(config) {
+  const builtins = BUILT_IN_CHECKS.filter((check) => config.categories[check.category] && !config.disabledChecks.includes(check.id));
+  const custom = [];
+  const loadErrors = [];
+  for (const specifier of config.checks) {
+    try {
+      const resolved = specifier.startsWith(".") ? pathToFileURL(path13.resolve(config.cwd, specifier)).href : specifier;
+      const mod = await import(resolved);
+      const exported = mod.default;
+      if (!exported) {
+        throw new Error(`Check module "${specifier}" has no default export`);
+      }
+      const defs = Array.isArray(exported) ? exported : [exported];
+      for (const def of defs) {
+        if (def && !config.disabledChecks.includes(def.id)) custom.push(def);
+      }
+    } catch (error) {
+      loadErrors.push({ specifier, message: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  const allChecks = [...builtins, ...custom];
+  const seenIds = /* @__PURE__ */ new Set();
+  const checks = [];
+  for (const check of allChecks) {
+    if (seenIds.has(check.id)) {
+      loadErrors.push({ specifier: check.id, message: `Duplicate check id "${check.id}" \u2014 the later definition was ignored` });
+      continue;
+    }
+    seenIds.add(check.id);
+    checks.push(check);
+  }
+  return { checks, loadErrors };
+}
+
+// src/core/runner.ts
+var BUILD_TIMEOUT_MS = 10 * 6e4;
+var CHECK_EXEC_TIMEOUT_MS = 3 * 6e4;
+var PAGE_NAV_TIMEOUT_MS = 15e3;
+var LIVE_FETCH_TIMEOUT_MS = 15e3;
+var CheckSkipped = class extends Error {
+};
+function computeExitCode(findings, config) {
+  return findings.some((f) => SEVERITY_RANK[f.severity] >= SEVERITY_RANK[config.failOn]) ? 1 : 0;
+}
+async function runVortix(config, onProgress = () => {
+}, liveUrl) {
+  const adapter = resolveAdapter(config.cwd, config.target, config.build);
+  const declaredOutputDir = path14.resolve(config.cwd, adapter.outputDir);
+  if (config.build) {
+    onProgress({ type: "build-start" });
+    try {
+      await exec(adapter.buildCommand, { cwd: config.cwd, timeoutMs: BUILD_TIMEOUT_MS });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(t("errors.buildFailed", { command: adapter.buildCommand, message }));
+    }
+    onProgress({ type: "build-done" });
+  }
+  if (!existsSync5(declaredOutputDir)) {
+    throw new Error(t("errors.outputDirMissing", { dir: declaredOutputDir }));
+  }
+  const outputDir = adapter.resolveServeDir?.(declaredOutputDir) ?? declaredOutputDir;
+  const { checks, loadErrors } = await loadChecks(config);
+  const configErrors = loadErrors.map((e) => `${e.specifier}: ${e.message}`);
+  const staticChecks = checks.filter((c) => c.mode === "static");
+  const dynamicChecks = checks.filter((c) => c.mode === "dynamic");
+  const liveChecks = checks.filter((c) => c.mode === "live");
+  const checkSummaries = new Map(checks.map((c) => [c.id, toSummary(c)]));
+  const pages = await collectPages(outputDir);
+  if (pages.length === 0) {
+    throw new Error(t("errors.noPagesFound", { dir: outputDir }));
+  }
+  const findings = [];
+  const details = [];
+  const skipped = /* @__PURE__ */ new Map();
+  const skip = (reason) => {
+    throw new CheckSkipped(reason);
+  };
+  const baseHelpers = {
+    siteRoot: config.cwd,
+    outputDir,
+    config,
+    exec: (command) => exec(command, { cwd: config.cwd, timeoutMs: CHECK_EXEC_TIMEOUT_MS, allowNonZeroExit: true }),
+    glob: (pattern, options) => globFiles(pattern, { cwd: options?.cwd ?? config.cwd }),
+    readFile: (filePath) => {
+      const ext = filePath.split(".").pop()?.toLowerCase();
+      if (ext && [
+        "png",
+        "jpg",
+        "jpeg",
+        "gif",
+        "webp",
+        "avif",
+        "svg",
+        "ico",
+        "woff",
+        "woff2",
+        "ttf",
+        "eot",
+        "otf",
+        "pdf",
+        "zip",
+        "gz",
+        "mp3",
+        "mp4",
+        "webm"
+      ].includes(ext)) {
+        throw new Error(`Cannot read binary file: ${filePath}`);
+      }
+      return readFileSync4(filePath, "utf-8");
+    },
+    fileExists: (filePath) => {
+      try {
+        return statSync2(filePath).isFile();
+      } catch {
+        return false;
+      }
+    },
+    skip
+  };
+  onProgress({ type: "static-start", index: 0, total: staticChecks.length });
+  for (const [index, check] of staticChecks.entries()) {
+    onProgress({ type: "static-check", check: toSummary(check), index: index + 1, total: staticChecks.length });
+    const ctx = {
+      ...baseHelpers,
+      mode: "static",
+      pages,
+      finding: createFindingFactory(check, config.severity[check.id]),
+      detail: createDetailFactory(check, (d) => details.push(d))
+    };
+    const result = await safeRun(check, ctx, config);
+    findings.push(...result.findings);
+    if (result.skipped) skipped.set(check.id, result.skipped);
+  }
+  onProgress({ type: "static-done", total: staticChecks.length });
+  let pagesChecked = 0;
+  if (dynamicChecks.length > 0 && pages.length > 0) {
+    onProgress({ type: "dynamic-start", index: 0, total: pages.length });
+    const server = await startStaticServer(outputDir);
+    let browser;
+    try {
+      browser = await chromium.launch({ headless: true });
+    } catch {
+      for (const check of dynamicChecks) skipped.set(check.id, t("progress.playwrightMissing"));
+    }
+    if (browser) {
+      try {
+        const browserContext = await browser.newContext();
+        try {
+          for (const [index, pageInfo] of pages.entries()) {
+            onProgress({ type: "dynamic-page-start", pageInfo, index: index + 1, total: pages.length });
+            let page;
+            let capture;
+            try {
+              page = await browserContext.newPage();
+              capture = attachCapture(page);
+              try {
+                await page.goto(server.url + pageInfo.urlPath, { waitUntil: "networkidle", timeout: PAGE_NAV_TIMEOUT_MS });
+              } catch {
+                await page.goto(server.url + pageInfo.urlPath, { waitUntil: "load", timeout: PAGE_NAV_TIMEOUT_MS });
+              }
+              pagesChecked++;
+              for (const check of dynamicChecks) {
+                const ctx = {
+                  ...baseHelpers,
+                  mode: "dynamic",
+                  page,
+                  pageInfo,
+                  consoleMessages: capture.consoleMessages,
+                  networkRequests: capture.networkRequests,
+                  finding: createFindingFactory(check, config.severity[check.id]),
+                  detail: createDetailFactory(check, (d) => details.push(d))
+                };
+                const result = await safeRun(check, ctx, config);
+                findings.push(...result.findings);
+                if (result.skipped) skipped.set(check.id, result.skipped);
+              }
+            } catch (error) {
+              const message = t("errors.pageCrashed", {
+                url: pageInfo.urlPath,
+                message: error instanceof Error ? error.message : String(error)
+              });
+              for (const check of dynamicChecks) {
+                findings.push({
+                  checkId: check.id,
+                  category: check.category,
+                  severity: resolveSeverity(check, config),
+                  message,
+                  url: pageInfo.urlPath
+                });
+              }
+            } finally {
+              capture?.detach();
+              await page?.close().catch(() => {
+              });
+            }
+            onProgress({ type: "dynamic-page-done", pageInfo, index: index + 1, total: pages.length });
+          }
+        } finally {
+          await browserContext.close();
+        }
+      } finally {
+        await browser.close();
+      }
+    }
+    await server.close();
+    onProgress({ type: "dynamic-done", total: browser ? pages.length : 0 });
+  }
+  if (liveChecks.length > 0) {
+    if (!liveUrl) {
+      for (const check of liveChecks) skipped.set(check.id, t("progress.liveNoUrl"));
+    } else {
+      onProgress({ type: "live-start", url: liveUrl, index: 0, total: liveChecks.length });
+      try {
+        const response = await fetch(liveUrl, { signal: AbortSignal.timeout(LIVE_FETCH_TIMEOUT_MS) });
+        const html = await response.text();
+        const headers = {};
+        response.headers.forEach((value, key) => {
+          headers[key.toLowerCase()] = value;
+        });
+        const setCookieHeaders = response.headers.getSetCookie?.() ?? [];
+        const parsedUrl = new URL(liveUrl);
+        const isHttps = new URL(response.url).protocol === "https:";
+        for (const [index, check] of liveChecks.entries()) {
+          onProgress({ type: "live-check", check: toSummary(check), index: index + 1, total: liveChecks.length });
+          const ctx = {
+            url: liveUrl,
+            parsedUrl,
+            headers,
+            setCookieHeaders,
+            status: response.status,
+            redirected: response.redirected,
+            finalUrl: response.url,
+            isHttps,
+            html,
+            config,
+            finding: createFindingFactory(check, config.severity[check.id]),
+            detail: createDetailFactory(check, (d) => details.push(d)),
+            skip
+          };
+          const result = await safeRun(check, ctx, config);
+          findings.push(...result.findings);
+          if (result.skipped) skipped.set(check.id, result.skipped);
+        }
+      } catch (error) {
+        const message = t("errors.checkCrashed", { message: error instanceof Error ? error.message : String(error) });
+        for (const check of liveChecks) {
+          findings.push({ checkId: check.id, category: check.category, severity: resolveSeverity(check, config), message });
+          skipped.set(check.id, message);
+        }
+      }
+      onProgress({ type: "live-done", total: liveChecks.length });
+    }
+  }
+  const exitCode = computeExitCode(findings, config);
+  return {
+    findings,
+    details,
+    checks: [...checkSummaries.values()],
+    skipped: Object.fromEntries(skipped),
+    adapterName: adapter.name,
+    outputDir,
+    pagesChecked,
+    totalPages: pages.length,
+    liveUrl,
+    exitCode,
+    configErrors
+  };
+}
+function toSummary(check) {
+  return {
+    id: check.id,
+    name: check.name ?? humanizeCheckId(check.id),
+    category: check.category,
+    mode: check.mode,
+    description: check.description
+  };
+}
+function resolveSeverity(check, config) {
+  return config.severity[check.id] ?? check.severity ?? "warn";
+}
+async function safeRun(check, ctx, config) {
+  try {
+    const result = await check.run(
+      ctx
+    );
+    return { findings: result ?? [] };
+  } catch (error) {
+    if (error instanceof CheckSkipped) {
+      return { findings: [], skipped: error.message };
+    }
+    const message = t("errors.checkCrashed", { message: error instanceof Error ? error.message : String(error) });
+    return {
+      findings: [{ checkId: check.id, category: check.category, severity: resolveSeverity(check, config), message }],
+      skipped: message
+    };
+  }
+}
+
+// src/utils/clipboard.ts
+import { spawnSync } from "child_process";
+function candidateCommands() {
+  switch (process.platform) {
+    case "darwin":
+      return [{ command: "pbcopy", args: [] }];
+    case "win32":
+      return [{ command: "clip", args: [] }];
+    case "linux":
+      return [
+        { command: "wl-copy", args: [] },
+        { command: "xclip", args: ["-selection", "clipboard"] },
+        { command: "xsel", args: ["--clipboard", "--input"] }
+      ];
+    default:
+      return [];
+  }
+}
+function copyToClipboard(text) {
+  for (const { command, args } of candidateCommands()) {
+    const result = spawnSync(command, args, { input: text, stdio: ["pipe", "ignore", "ignore"] });
+    if (!result.error && result.status === 0) return true;
+  }
+  return false;
+}
+
+// src/commands/detail-ui.ts
+import * as p from "@clack/prompts";
+import pc2 from "picocolors";
+var DONE = "__done__";
+async function runInteractiveReport(result) {
+  for (const message of result.configErrors) {
+    console.log(pc2.yellow(`\u26A0 ${t("report.configErrorPrefix")}: ${message}`));
+  }
+  console.log(`
+${pc2.bold(buildHeader(result))}
+`);
+  console.log(buildScoreCard(result));
+  console.log("");
+  const findingsByCheck = groupByCheckId(result.findings);
+  const detailsByCheck = groupByCheckId(result.details);
+  for (; ; ) {
+    const options = result.checks.map((check2) => {
+      const { label, hint } = checkOptionLabel(check2, findingsByCheck.get(check2.id) ?? [], result.skipped[check2.id]);
+      return { value: check2.id, label, hint };
+    });
+    options.push({ value: DONE, label: t("report.detailDoneOption"), hint: "" });
+    const selected = await p.select({ message: t("report.detailSelectPrompt"), options });
+    if (p.isCancel(selected) || selected === DONE) break;
+    const check = result.checks.find((c) => c.id === selected);
+    if (!check) continue;
+    const text = buildCheckDetail(check, findingsByCheck.get(check.id) ?? [], detailsByCheck.get(check.id) ?? [], result.skipped[check.id]);
+    p.note(text, check.name);
+    const goBack = await p.select({
+      message: t("report.detailContinuePrompt"),
+      options: [{ value: true, label: t("report.detailBackOption") }]
+    });
+    if (p.isCancel(goBack)) break;
+  }
+}
+function groupByCheckId(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const list = map.get(item.checkId) ?? [];
+    list.push(item);
+    map.set(item.checkId, list);
+  }
+  return map;
+}
+
+// src/commands/progress-ui.ts
+import * as p2 from "@clack/prompts";
+var PROGRESS_BAR_OVERHEAD = 50;
+var MIN_TEXT_WIDTH = 20;
+var DEFAULT_COLUMNS = 80;
+function truncateForLine(text, prefixLength, output) {
+  const columns = output && "columns" in output && typeof output.columns === "number" ? output.columns : process.stdout.columns ?? DEFAULT_COLUMNS;
+  const available = Math.max(MIN_TEXT_WIDTH, columns - PROGRESS_BAR_OVERHEAD - prefixLength);
+  return text.length > available ? `${text.slice(0, available - 1)}\u2026` : text;
+}
+function createProgressHandler(output) {
+  const spin = p2.spinner({ output, indicator: "timer" });
+  let bar;
+  return (event) => {
+    switch (event.type) {
+      case "build-start":
+        spin.start(t("progress.building"));
+        break;
+      case "build-done":
+        spin.stop(t("progress.buildDone"));
+        break;
+      case "static-start":
+        if (event.total > 0) spin.start(t("progress.staticStart", { total: event.total }));
+        break;
+      case "static-check":
+        spin.message(t("progress.staticRunning", { index: event.index, total: event.total, name: event.check.name }));
+        break;
+      case "static-done":
+        if (event.total > 0) spin.stop(t("progress.staticDone", { total: event.total }));
+        break;
+      case "dynamic-start":
+        bar = p2.progress({ max: event.total, size: 30, output, indicator: "timer" });
+        bar.start(t("progress.dynamicStart", { total: event.total }));
+        break;
+      case "dynamic-page-start": {
+        const prefix = t("progress.dynamicPageRunning", { index: event.index, total: event.total, urlPath: "" });
+        const urlPath = truncateForLine(event.pageInfo.urlPath, prefix.length, output);
+        bar?.message(t("progress.dynamicPageRunning", { index: event.index, total: event.total, urlPath }));
+        break;
+      }
+      case "dynamic-page-done":
+        bar?.advance(1, t("progress.dynamicPageDone", { index: event.index, total: event.total }));
+        break;
+      case "dynamic-done":
+        bar?.stop(t("progress.dynamicDone", { total: event.total }));
+        break;
+      case "live-start":
+        if (event.total > 0) spin.start(t("progress.liveStart", { url: event.url, total: event.total }));
+        break;
+      case "live-check":
+        spin.message(t("progress.liveRunning", { index: event.index, total: event.total, name: event.check.name }));
+        break;
+      case "live-done":
+        if (event.total > 0) spin.stop(t("progress.liveDone", { total: event.total }));
+        break;
+    }
+  };
+}
+
+// src/commands/check.ts
+async function checkCommand(options = {}) {
+  const config = loadConfig(process.cwd());
+  const result = await runVortix(config, createProgressHandler(), options.url);
+  if (process.stdout.isTTY) {
+    await runInteractiveReport(result);
+    const shouldCopy = await p3.confirm({ message: t("report.copyPrompt"), initialValue: true });
+    if (!p3.isCancel(shouldCopy) && shouldCopy) {
+      const copied = copyToClipboard(buildFullReport(result));
+      if (copied) {
+        p3.log.success(t("report.copied"));
+      } else {
+        p3.log.error(t("report.copyFailed"));
+      }
+    }
+  } else {
+    printReport(result);
+  }
+  process.exitCode = result.exitCode;
+}
+
+// src/commands/ci.ts
+async function ciCommand(options = {}) {
+  const config = loadConfig(process.cwd());
+  const result = await runVortix(config, createProgressHandler(process.stderr), options.url);
+  console.log(
+    JSON.stringify(
+      {
+        adapter: result.adapterName,
+        pagesChecked: result.pagesChecked,
+        totalPages: result.totalPages,
+        liveUrl: result.liveUrl,
+        checks: result.checks,
+        findings: result.findings,
+        details: result.details,
+        skipped: result.skipped,
+        configErrors: result.configErrors
+      },
+      null,
+      2
+    )
+  );
+  process.exitCode = result.exitCode;
+}
+
+// src/commands/config.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync5, writeFileSync as writeFileSync2 } from "fs";
+import path18 from "path";
+import * as p5 from "@clack/prompts";
+import pc4 from "picocolors";
+
+// src/commands/init.ts
+import { existsSync as existsSync7, mkdirSync, writeFileSync } from "fs";
+import path17 from "path";
+import * as p4 from "@clack/prompts";
+
+// src/utils/github-workflow.ts
+import path15 from "path";
+var GITHUB_WORKFLOW_PATH = ".github/workflows/vortix.yml";
+function getGithubWorkflowPath(cwd) {
+  return path15.join(cwd, GITHUB_WORKFLOW_PATH);
+}
+var SETUP_STEPS = {
+  npm: `      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+      - run: npm ci`,
+  yarn: `      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: yarn
+      - run: yarn install --frozen-lockfile`,
+  pnpm: `      - uses: pnpm/action-setup@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile`,
+  bun: `      - uses: oven-sh/setup-bun@v2
+      - run: bun install --frozen-lockfile`
+};
+var RUN_COMMAND = {
+  npm: "npx vortix ci",
+  yarn: "npx vortix ci",
+  pnpm: "npx vortix ci",
+  bun: "bunx vortix ci"
+};
+function buildGithubWorkflowYaml(pm) {
+  return `name: Vortix
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  vortix:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+${SETUP_STEPS[pm]}
+      - run: ${RUN_COMMAND[pm]}
+        # Pass a deployed URL as an argument to also run live checks (HSTS, cookies, redirects):
+        # - run: ${RUN_COMMAND[pm]} https://your-deployed-url.example.com
+`;
+}
+
+// src/utils/package-manager.ts
+import { existsSync as existsSync6 } from "fs";
+import path16 from "path";
+function detectPackageManager(cwd) {
+  if (existsSync6(path16.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync6(path16.join(cwd, "yarn.lock"))) return "yarn";
+  if (existsSync6(path16.join(cwd, "bun.lockb")) || existsSync6(path16.join(cwd, "bun.lock"))) return "bun";
+  return "npm";
+}
+
+// src/commands/init.ts
+import pc3 from "picocolors";
+async function initCommand() {
+  const cwd = process.cwd();
+  p4.intro(pc3.bold(t("init.intro")));
+  const configPath = getConfigPath(cwd);
+  if (existsSync7(configPath)) {
+    const overwrite = await p4.confirm({ message: t("init.configExists"), initialValue: false });
+    if (p4.isCancel(overwrite) || !overwrite) return abort(t("init.abortedKept"));
+  }
+  const result = await runPrompts(cwd, null);
+  if (result === void 0) return;
+  mkdirSync(path17.join(cwd, CONFIG_DIR), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(result, null, 2)}
+`, "utf-8");
+  await promptGithubWorkflow(cwd);
+  p4.outro(pc3.green(t("init.done", { cmd: pc3.bold("npx vortix check") })));
+}
+async function promptGithubWorkflow(cwd) {
+  const setup = await p4.confirm({ message: t("init.pickGithubWorkflow"), initialValue: true });
+  if (p4.isCancel(setup) || !setup) return;
+  const workflowPath = getGithubWorkflowPath(cwd);
+  const relativePath = path17.relative(cwd, workflowPath);
+  if (existsSync7(workflowPath)) {
+    const overwrite = await p4.confirm({ message: t("init.githubWorkflowExists", { path: relativePath }), initialValue: false });
+    if (p4.isCancel(overwrite) || !overwrite) {
+      p4.log.info(t("init.githubWorkflowSkipped"));
+      return;
+    }
+  }
+  mkdirSync(path17.dirname(workflowPath), { recursive: true });
+  writeFileSync(workflowPath, buildGithubWorkflowYaml(detectPackageManager(cwd)), "utf-8");
+  p4.log.success(t("init.githubWorkflowDone", { path: relativePath }));
+}
+async function runPrompts(cwd, existing) {
+  const adapterName = await resolveAdapterChoice(cwd, existing?.target?.adapter);
+  if (adapterName === void 0) return void 0;
+  const initialCategories = existing?.categories ? CATEGORIES.filter((c) => existing.categories?.[c] !== false) : [...CATEGORIES];
+  const categories = await p4.multiselect({
+    message: t("init.pickCategories"),
+    options: CATEGORIES.map((category) => ({ value: category, label: category })),
+    initialValues: initialCategories
+  });
+  if (p4.isCancel(categories)) return abort();
+  const failOn = await p4.select({
+    message: t("init.pickFailOn"),
+    options: [
+      { value: "error", label: t("init.failOnRecommended") },
+      { value: "warn", label: "warn" },
+      { value: "info", label: "info" }
+    ],
+    initialValue: existing?.failOn ?? "error"
+  });
+  if (p4.isCancel(failOn)) return abort();
+  const isKnownAdapter = BUILT_IN_ADAPTERS.some((a) => a.name === adapterName);
+  return {
+    ...existing,
+    target: isKnownAdapter ? { adapter: adapterName } : {
+      buildCommand: existing?.target?.buildCommand ?? "<your build command>",
+      outputDir: existing?.target?.outputDir ?? "<your output folder>"
+    },
+    categories: Object.fromEntries(CATEGORIES.map((c) => [c, categories.includes(c)])),
+    failOn
+  };
+}
+async function resolveAdapterChoice(cwd, currentAdapter) {
+  const detected = detectAdapter(cwd);
+  if (detected && !currentAdapter) {
+    const useDetected = await p4.confirm({ message: t("init.detectedStack", { name: detected.name }), initialValue: true });
+    if (p4.isCancel(useDetected)) return void 0;
+    if (useDetected) return detected.name;
+  } else if (currentAdapter) {
+    return currentAdapter;
+  } else {
+    p4.log.warn(t("init.noGeneratorDetected"));
+  }
+  const choice = await p4.select({
+    message: t("init.pickStack"),
+    options: [
+      ...BUILT_IN_ADAPTERS.map((adapter) => ({ value: adapter.name, label: adapter.name })),
+      { value: "manual", label: t("init.manualOption") }
+    ]
+  });
+  if (p4.isCancel(choice)) return void 0;
+  return choice;
+}
+function abort(message = t("init.aborted")) {
+  p4.cancel(message);
+  process.exitCode = 1;
+  return void 0;
+}
+
+// src/commands/config.ts
+async function configCommand() {
+  const cwd = process.cwd();
+  const configPath = getConfigPath(cwd);
+  p5.intro(pc4.bold(t("config.intro")));
+  let existing = null;
+  if (existsSync8(configPath)) {
+    try {
+      existing = JSON.parse(readFileSync5(configPath, "utf-8"));
+    } catch {
+      p5.log.warn(t("config.corrupt"));
+    }
+  } else {
+    p5.log.warn(t("config.noConfig"));
+  }
+  const result = await runPrompts(cwd, existing);
+  if (result === void 0) return;
+  mkdirSync2(path18.join(cwd, CONFIG_DIR), { recursive: true });
+  writeFileSync2(configPath, `${JSON.stringify(result, null, 2)}
+`, "utf-8");
+  p5.outro(pc4.green(t("config.done")));
+}
+
+// src/cli.ts
+import { Command } from "commander";
+import pc5 from "picocolors";
+var program = new Command();
+program.name("vortix").description(t("cli.description")).version("0.1.0");
+program.command("init").description(t("cli.init.description")).action(async () => {
+  await initCommand();
+});
+program.command("config").description(t("cli.config.description")).action(async () => {
+  await configCommand();
+});
+program.command("check").description(t("cli.check.description")).argument("[url]", "Optional live URL to check against").action(async (url) => {
+  await checkCommand({ url });
+});
+program.command("ci").description(t("cli.ci.description")).argument("[url]", "Optional live URL to check against").action(async (url) => {
+  await ciCommand({ url });
+});
+program.parseAsync(process.argv).catch((error) => {
+  console.error(pc5.red(`
+${error.message}
+`));
+  process.exitCode = 1;
+});