blume 1.6.4 → 1.6.6

package/dist/cli/chunk-x1vrdjyk.js

@@ -0,0 +1,1967 @@
+#!/usr/bin/env node
+import {
+  AGENTS,
+  CHECKS,
+  finding,
+  fixPrompt,
+  formatCatalog,
+  formatReport,
+  launchAgent,
+  reportJson,
+  writeAgentReport
+} from "./chunk-8gnpdsn1.js";
+import {
+  gradeExternal,
+  probeAll
+} from "./chunk-cbjnx4s8.js";
+import {
+  reportInternalError
+} from "./chunk-btfr9yvw.js";
+import {
+  deployStaticDir,
+  examplesRouteBase
+} from "./chunk-aerwpe14.js";
+import"./chunk-3k0kzs6d.js";
+import"./chunk-vxv4x1n8.js";
+import"./chunk-wd27zjcz.js";
+import {
+  frontmatter_default,
+  scanProject
+} from "./chunk-etsqspj6.js";
+import {
+  SITE_INFERRING_ADAPTERS
+} from "./chunk-vv3f8mb6.js";
+import {
+  normalizeBasePath,
+  normalizePath,
+  stripBasePath,
+  withBasePath
+} from "./chunk-27gtm2ym.js";
+import"./chunk-4xyggvgf.js";
+import"./chunk-6kzzpsx8.js";
+import {
+  BlumeError,
+  flushStdout,
+  locateFrontmatterKey,
+  logger
+} from "./chunk-ey89bjj1.js";
+import {
+  commandMeta
+} from "./chunk-2aj8ddew.js";
+
+// src/cli/commands/audit.ts
+import { defineCommand } from "citty";
+
+// src/audit/run.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import pMap2 from "p-map";
+
+// src/audit/locate.ts
+var pageSite = (context, page, key) => {
+  const file = page.source;
+  if (!file) {
+    return { url: page.url };
+  }
+  const source = key ? context.sources.get(file) : undefined;
+  const position = source ? locateFrontmatterKey(source, key ?? []) : undefined;
+  return {
+    column: position?.column,
+    file,
+    line: position?.line,
+    url: page.url
+  };
+};
+
+// src/audit/url.ts
+var serverRoutes = (context) => {
+  const mcp = context.project.config.ai?.mcp;
+  return mcp?.enabled ? [normalizePath(mcp.route)] : [];
+};
+var isServed = (context, path) => context.byUrl.has(path) || context.files.has(path) || context.files.has(`${path}/index.html`) || serverRoutes(context).includes(path);
+var NON_HTTP_SCHEME = /^(?!https?:)[a-z][a-z0-9+.-]*:/iu;
+var decodePath = (path) => {
+  try {
+    return decodeURI(path);
+  } catch {
+    return path;
+  }
+};
+var siteOrigin = (site) => {
+  if (!site) {
+    return null;
+  }
+  try {
+    return new URL(site).origin;
+  } catch {
+    return null;
+  }
+};
+var resolveHref = (pageUrl, href, origin, deployBase = "") => {
+  const target = href.trim();
+  if (target === "" || target.startsWith("#")) {
+    return { kind: "ignored" };
+  }
+  if (NON_HTTP_SCHEME.test(target)) {
+    return { kind: "ignored" };
+  }
+  const absolute = /^https?:\/\//iu.test(target) || target.startsWith("//");
+  if (absolute) {
+    let parsed;
+    try {
+      parsed = new URL(target.startsWith("//") ? `https:${target}` : target);
+    } catch {
+      return { kind: "ignored" };
+    }
+    if (origin && parsed.origin === origin) {
+      return {
+        hash: parsed.hash.slice(1),
+        kind: "self-origin",
+        path: normalizePath(stripBasePath(deployBase, decodePath(parsed.pathname)))
+      };
+    }
+    return { kind: "external", url: parsed.toString() };
+  }
+  const base = pageUrl === "/" ? "https://blume.invalid/" : `https://blume.invalid${pageUrl}/`;
+  let resolved;
+  try {
+    resolved = new URL(target, base);
+  } catch {
+    return { kind: "ignored" };
+  }
+  return {
+    hash: resolved.hash.slice(1),
+    kind: "internal",
+    path: normalizePath(stripBasePath(deployBase, decodePath(resolved.pathname)))
+  };
+};
+
+// src/audit/checks/assets.ts
+var formatBytes = (bytes) => bytes < 1024 * 1024 ? `${Math.round(bytes / 1024)} kB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+var resolveAsset = (context, page, asset, missingId, kind, found) => {
+  if (asset.src.startsWith("http://")) {
+    found.push(finding("BLUME_AUDIT_MIXED_CONTENT", pageSite(context, page), `Page loads ${kind} over plain HTTP: ${asset.src}`));
+    return null;
+  }
+  if (asset.src.startsWith("data:")) {
+    return null;
+  }
+  const origin = siteOrigin(context.project.config.deployment.site);
+  const resolved = resolveHref(page.url, asset.src, origin, normalizeBasePath(context.project.config.deployment.base));
+  if (resolved.kind === "external" || resolved.kind === "ignored") {
+    return null;
+  }
+  const bytes = context.files.get(resolved.path);
+  if (bytes === undefined) {
+    found.push(finding(missingId, pageSite(context, page), `Page references ${asset.src}, which is not in the build.`));
+    return null;
+  }
+  return bytes;
+};
+var assetChecks = {
+  category: "assets",
+  run(context) {
+    const found = [];
+    const { maxAssetBytes } = context.thresholds;
+    const weigh = (page, asset, bytes, kind) => {
+      if (bytes !== null && bytes > maxAssetBytes) {
+        found.push(finding("BLUME_AUDIT_ASSET_TOO_LARGE", pageSite(context, page), `${kind} ${asset.src} is ${formatBytes(bytes)} (over ${formatBytes(maxAssetBytes)}).`));
+      }
+    };
+    for (const page of context.pages) {
+      for (const image of page.images) {
+        const bytes = resolveAsset(context, page, image, "BLUME_AUDIT_IMAGE_BROKEN", "an image", found);
+        weigh(page, image, bytes, "Image");
+        if (image.alt === null) {
+          found.push(finding("BLUME_AUDIT_IMAGE_ALT_MISSING", pageSite(context, page), `Image ${image.src} has no alt attribute.`));
+        }
+        if (!(image.width && image.height)) {
+          found.push(finding("BLUME_AUDIT_IMAGE_MISSING_DIMENSIONS", pageSite(context, page), `Image ${image.src} has no width/height, so it will shift the layout as it loads.`));
+        }
+      }
+      for (const script of page.scripts) {
+        weigh(page, script, resolveAsset(context, page, script, "BLUME_AUDIT_SUBRESOURCE_MISSING", "a script", found), "Script");
+      }
+      for (const style of page.styles) {
+        weigh(page, style, resolveAsset(context, page, style, "BLUME_AUDIT_SUBRESOURCE_MISSING", "a stylesheet", found), "Stylesheet");
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/content.ts
+import stringWidth from "string-width";
+
+// src/audit/types.ts
+var ERROR_ROUTES = new Set(["/404", "/500"]);
+var DEFAULT_THRESHOLDS = {
+  descriptionMax: 160,
+  descriptionMin: 110,
+  maxAssetBytes: 500 * 1024,
+  maxHtmlBytes: 2 * 1024 * 1024,
+  maxRedirectHops: 3,
+  minWordCount: 50,
+  titleMax: 60,
+  titleMin: 10
+};
+
+// src/audit/checks/content.ts
+var WHITESPACE = /\s+/gu;
+var isDateValue = (value) => typeof value === "string" || value instanceof Date;
+var frontmatterDate = (source) => {
+  try {
+    const { date } = frontmatter_default(source).data;
+    if (!isDateValue(date)) {
+      return null;
+    }
+    const parsed = date instanceof Date ? date : new Date(date);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+  } catch {
+    return null;
+  }
+};
+var titleChecks = (context, page) => {
+  const { titleMin, titleMax } = context.thresholds;
+  const [title] = page.titles;
+  if (!title) {
+    return [
+      finding("BLUME_AUDIT_TITLE_MISSING", pageSite(context, page), "Page has no <title>.")
+    ];
+  }
+  const found = [];
+  if (page.titles.length > 1) {
+    found.push(finding("BLUME_AUDIT_TITLE_MULTIPLE", pageSite(context, page), `Page has ${page.titles.length} <title> tags; search engines use only the first.`));
+  }
+  const width = stringWidth(title.replaceAll(WHITESPACE, " "));
+  if (width > titleMax || width < titleMin) {
+    const direction = width > titleMax ? "long" : "short";
+    found.push(finding("BLUME_AUDIT_TITLE_LENGTH", pageSite(context, page, ["title"]), `Title renders ${width} columns wide — too ${direction} (aim for ${titleMin}–${titleMax}).`));
+  }
+  return found;
+};
+var descriptionChecks = (context, page) => {
+  if (ERROR_ROUTES.has(page.url)) {
+    return [];
+  }
+  const { descriptionMin, descriptionMax } = context.thresholds;
+  const [description] = page.descriptions;
+  if (!description) {
+    return [
+      finding("BLUME_AUDIT_DESCRIPTION_MISSING", pageSite(context, page), "Page has no meta description.")
+    ];
+  }
+  const found = [];
+  if (page.descriptions.length > 1) {
+    found.push(finding("BLUME_AUDIT_DESCRIPTION_MULTIPLE", pageSite(context, page), `Page has ${page.descriptions.length} meta description tags.`));
+  }
+  const width = stringWidth(description.replaceAll(WHITESPACE, " "));
+  if (width > descriptionMax || width < descriptionMin) {
+    const direction = width > descriptionMax ? "long" : "short";
+    found.push(finding("BLUME_AUDIT_DESCRIPTION_LENGTH", pageSite(context, page, ["description"]), `Meta description renders ${width} columns wide — too ${direction} (aim for ${descriptionMin}–${descriptionMax}).`));
+  }
+  return found;
+};
+var headingChecks = (context, page) => {
+  const h1s = page.headings.filter((heading) => heading.depth === 1);
+  if (h1s.length === 0) {
+    return [
+      finding("BLUME_AUDIT_H1_MISSING", pageSite(context, page), "Page has no <h1>.")
+    ];
+  }
+  if (h1s.length > 1) {
+    return [
+      finding("BLUME_AUDIT_H1_MULTIPLE", pageSite(context, page), `Page has ${h1s.length} <h1> tags: ${h1s.map((h) => `"${h.text}"`).join(", ")}.`)
+    ];
+  }
+  let previous = null;
+  for (const heading of page.headings) {
+    if (previous !== null && heading.depth > previous + 1) {
+      return [
+        finding("BLUME_AUDIT_HEADING_SKIP", pageSite(context, page), `Headings jump from h${previous} to h${heading.depth} at "${heading.text}".`)
+      ];
+    }
+    previous = heading.depth;
+  }
+  return [];
+};
+var futureDateChecks = (context, page) => {
+  const source = page.source && context.sources.get(page.source);
+  if (!source) {
+    return [];
+  }
+  const date = frontmatterDate(source);
+  if (date && date.getTime() > Date.now()) {
+    return [
+      finding("BLUME_AUDIT_FUTURE_DATED_PAGE", pageSite(context, page, ["date"]), `Page is dated ${date.toISOString().slice(0, 10)}, which is in the future.`)
+    ];
+  }
+  return [];
+};
+var contentChecks = {
+  category: "content",
+  run(context) {
+    const found = [];
+    for (const page of context.pages) {
+      found.push(...titleChecks(context, page), ...descriptionChecks(context, page), ...headingChecks(context, page), ...futureDateChecks(context, page));
+      if (page.wordCount < context.thresholds.minWordCount && page.indexable) {
+        found.push(finding("BLUME_AUDIT_LOW_WORD_COUNT", pageSite(context, page), `Page has ${page.wordCount} words of prose (excluding code blocks).`));
+      }
+      if (!page.viewport) {
+        found.push(finding("BLUME_AUDIT_VIEWPORT_MISSING", pageSite(context, page), "Page has no viewport <meta> — it will not render correctly on mobile."));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/dns-aid.ts
+var RR_SVCB = 64;
+var RR_HTTPS = 65;
+var DOH_TIMEOUT_MS = 5000;
+var DOH_RESOLVERS = [
+  "https://dns.google/resolve",
+  "https://cloudflare-dns.com/dns-query"
+];
+var resolvers = () => {
+  const override = process.env.BLUME_DOH_URL;
+  return override ? [override] : DOH_RESOLVERS;
+};
+var fetchDohJson = async (base, name, type, fetchFn) => {
+  try {
+    const response = await fetchFn(`${base}?name=${encodeURIComponent(name)}&type=${type}`, {
+      headers: { accept: "application/dns-json" },
+      signal: AbortSignal.timeout(DOH_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return null;
+    }
+    return await response.json();
+  } catch {
+    return null;
+  }
+};
+var queryDoh = async (name, type, fetchFn) => {
+  for (const base of resolvers()) {
+    const response = await fetchDohJson(base, name, type, fetchFn);
+    if (response) {
+      return response;
+    }
+  }
+  return null;
+};
+var lookupDnsAid = async (host, fetchFn = fetch) => {
+  const name = `_index._agents.${host}`;
+  let answered = false;
+  let found = false;
+  let authenticated = true;
+  const responses = await Promise.all([RR_HTTPS, RR_SVCB].map((type) => queryDoh(name, type, fetchFn)));
+  for (const response of responses) {
+    if (!response) {
+      continue;
+    }
+    answered = true;
+    const records = (response.Answer ?? []).filter((answer) => answer.type === RR_SVCB || answer.type === RR_HTTPS);
+    if (records.length > 0) {
+      found = true;
+      authenticated &&= response.AD === true;
+    }
+  }
+  return answered ? { authenticated, found } : null;
+};
+var dnsAidFindings = (host, result) => {
+  if (!result.found) {
+    return [
+      finding("BLUME_AUDIT_DNS_AID_MISSING", { url: "/" }, `No SVCB or HTTPS records at _index._agents.${host} — agents probing DNS for AI Discovery (DNS-AID) find nothing.`, `Publish a ServiceMode record with your DNS provider, e.g. \`_index._agents.${host}. 3600 IN HTTPS 1 ${host}. alpn=h2\`, and sign the zone with DNSSEC if the provider supports it.`)
+    ];
+  }
+  if (!result.authenticated) {
+    return [
+      finding("BLUME_AUDIT_DNS_AID_UNSIGNED", { url: "/" }, `The DNS-AID records at _index._agents.${host} exist but are not DNSSEC-authenticated, so validating resolvers can't prove they're genuine.`)
+    ];
+  }
+  return [];
+};
+var dnsAidHost = (site) => {
+  if (!site) {
+    return null;
+  }
+  let hostname;
+  try {
+    ({ hostname } = new URL(site));
+  } catch {
+    return null;
+  }
+  if (hostname === "localhost" || hostname.endsWith(".local") || !hostname.includes(".")) {
+    return null;
+  }
+  return hostname;
+};
+var dnsAidChecks = {
+  category: "ai",
+  async run(context) {
+    if (!context.origin) {
+      return [];
+    }
+    const host = dnsAidHost(context.project.config.deployment.site);
+    if (!host) {
+      return [];
+    }
+    const result = await lookupDnsAid(host);
+    return result ? dnsAidFindings(host, result) : [];
+  },
+  tier: "network"
+};
+
+// src/audit/checks/duplicates.ts
+var isNonCanonical = (page, deployBase) => {
+  if (!page.canonical) {
+    return false;
+  }
+  try {
+    return stripBasePath(deployBase, decodePath(new URL(page.canonical).pathname)).replace(/\/$/u, "") !== page.url.replace(/\/$/u, "");
+  } catch {
+    return false;
+  }
+};
+var comparable = (context) => {
+  const deployBase = normalizeBasePath(context.project.config.deployment.base);
+  return context.pages.filter((page) => page.indexable && !page.route?.fallback && !isNonCanonical(page, deployBase));
+};
+var reportGroups = (context, pages, id, key, describe, frontmatterKey) => {
+  const groups = new Map;
+  for (const page of pages) {
+    const value = key(page);
+    if (!value) {
+      continue;
+    }
+    const groupKey = `${page.route?.locale ?? ""}\x00${value}`;
+    const group = groups.get(groupKey);
+    if (group) {
+      group.push(page);
+    } else {
+      groups.set(groupKey, [page]);
+    }
+  }
+  const found = [];
+  for (const group of groups.values()) {
+    if (group.length < 2) {
+      continue;
+    }
+    for (const page of group) {
+      const others = group.filter((other) => other !== page);
+      found.push(finding(id, pageSite(context, page, frontmatterKey), describe(key(page) ?? "", others)));
+    }
+  }
+  return found;
+};
+var list = (pages) => {
+  const shown = pages.slice(0, 3).map((page) => page.url);
+  const rest = pages.length - shown.length;
+  return rest > 0 ? `${shown.join(", ")} and ${rest} more` : shown.join(", ");
+};
+var duplicateChecks = {
+  category: "duplicates",
+  run(context) {
+    const pages = comparable(context);
+    return [
+      ...reportGroups(context, pages, "BLUME_AUDIT_DUPLICATE_TITLE", (page) => page.titles[0], (value, others) => `Title "${value}" is also used by ${list(others)}.`, ["title"]),
+      ...reportGroups(context, pages, "BLUME_AUDIT_DUPLICATE_DESCRIPTION", (page) => page.descriptions[0], (_value, others) => `Meta description is identical to ${list(others)}.`, ["description"]),
+      ...reportGroups(context, pages.filter((page) => page.wordCount > 0), "BLUME_AUDIT_DUPLICATE_CONTENT", (page) => page.contentHash, (_value, others) => `Page content is byte-identical to ${list(others)}, and none declares a canonical.`)
+    ];
+  },
+  tier: "static"
+};
+
+// src/audit/checks/i18n.ts
+var deployBaseOf = (context) => normalizeBasePath(context.project.config.deployment.base);
+var X_DEFAULT = "x-default";
+var isValidBcp47 = (tag) => {
+  try {
+    Intl.getCanonicalLocales(tag);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var alternatePath = (href, deployBase) => {
+  try {
+    return normalizePath(stripBasePath(deployBase, new URL(href).pathname));
+  } catch {
+    return null;
+  }
+};
+var langChecks = (context, page) => {
+  if (!page.lang) {
+    return [
+      finding("BLUME_AUDIT_HTML_LANG_MISSING", pageSite(context, page), "The <html> element has no lang attribute.")
+    ];
+  }
+  if (!isValidBcp47(page.lang)) {
+    return [
+      finding("BLUME_AUDIT_HTML_LANG_INVALID", pageSite(context, page), `"${page.lang}" is not a valid BCP 47 language tag.`)
+    ];
+  }
+  return [];
+};
+var hreflangChecks = (context, page) => {
+  const found = [];
+  const seen = new Map;
+  const deployBase = deployBaseOf(context);
+  for (const alternate of page.hreflang) {
+    if (alternate.lang !== X_DEFAULT && !isValidBcp47(alternate.lang)) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_INVALID", pageSite(context, page), `hreflang="${alternate.lang}" is not a valid BCP 47 language tag.`));
+      continue;
+    }
+    const hrefs = seen.get(alternate.lang) ?? [];
+    hrefs.push(alternate.href);
+    seen.set(alternate.lang, hrefs);
+    const path = alternatePath(alternate.href, deployBase);
+    if (path === null) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_BAD_TARGET", pageSite(context, page), `hreflang="${alternate.lang}" points at "${alternate.href}", which is not an absolute URL.`));
+      continue;
+    }
+    const target = context.byUrl.get(path);
+    const redirect = context.redirects.find((entry) => normalizePath(entry.from) === path);
+    if (redirect) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_BAD_TARGET", pageSite(context, page), `hreflang="${alternate.lang}" points at ${path}, which redirects to ${redirect.to}.`));
+    } else if (!target) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_BAD_TARGET", pageSite(context, page), `hreflang="${alternate.lang}" points at ${path}, which the build does not serve.`));
+    } else if (target.canonical && alternatePath(target.canonical, deployBase) !== normalizePath(target.url)) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_BAD_TARGET", pageSite(context, page), `hreflang="${alternate.lang}" points at ${path}, which canonicalizes elsewhere.`));
+    }
+  }
+  for (const [lang, hrefs] of seen) {
+    if (hrefs.length > 1) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_CONFLICT", pageSite(context, page), `hreflang="${lang}" is declared ${hrefs.length} times, pointing at ${hrefs.join(", ")}.`));
+    }
+  }
+  const self = page.hreflang.find((alternate) => alternatePath(alternate.href, deployBase) === normalizePath(page.url));
+  if (self) {
+    if (page.lang && self.lang !== X_DEFAULT && self.lang !== page.lang) {
+      found.push(finding("BLUME_AUDIT_HREFLANG_LANG_MISMATCH", pageSite(context, page), `Page declares <html lang="${page.lang}"> but its own hreflang is "${self.lang}".`));
+    }
+  } else {
+    found.push(finding("BLUME_AUDIT_HREFLANG_SELF_MISSING", pageSite(context, page), "Page's hreflang set does not include a self-reference."));
+  }
+  if (!page.hreflang.some((alternate) => alternate.lang === X_DEFAULT)) {
+    found.push(finding("BLUME_AUDIT_HREFLANG_XDEFAULT_MISSING", pageSite(context, page), "Page's hreflang set has no x-default alternate."));
+  }
+  return found;
+};
+var returnTagChecks = (context) => {
+  const found = [];
+  const deployBase = deployBaseOf(context);
+  for (const page of context.pages) {
+    for (const alternate of page.hreflang) {
+      if (alternate.lang === X_DEFAULT) {
+        continue;
+      }
+      const path = alternatePath(alternate.href, deployBase);
+      if (path === null || path === normalizePath(page.url)) {
+        continue;
+      }
+      const target = context.byUrl.get(path);
+      if (!target || target.hreflang.length === 0) {
+        continue;
+      }
+      const returns = target.hreflang.some((back) => alternatePath(back.href, deployBase) === normalizePath(page.url));
+      if (!returns) {
+        found.push(finding("BLUME_AUDIT_HREFLANG_NO_RETURN_TAG", pageSite(context, page), `Page names ${path} as its "${alternate.lang}" alternate, but ${path} does not name it back.`));
+      }
+    }
+  }
+  return found;
+};
+var i18nChecks = {
+  category: "i18n",
+  run(context) {
+    const found = [];
+    for (const page of context.pages) {
+      found.push(...langChecks(context, page));
+      if (page.hreflang.length > 0) {
+        found.push(...hreflangChecks(context, page));
+      }
+    }
+    found.push(...returnTagChecks(context));
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/indexability.ts
+var parseCanonical = (canonical) => {
+  try {
+    return new URL(canonical);
+  } catch {
+    return null;
+  }
+};
+var canonicalChecks = (context, page) => {
+  const { site } = context.project.config.deployment;
+  const origin = siteOrigin(site);
+  if (ERROR_ROUTES.has(page.url)) {
+    return [];
+  }
+  if (!page.canonical) {
+    return site ? [
+      finding("BLUME_AUDIT_CANONICAL_MISSING", pageSite(context, page), "Page has no canonical URL.")
+    ] : [];
+  }
+  const canonical = parseCanonical(page.canonical);
+  if (!canonical) {
+    return [
+      finding("BLUME_AUDIT_CANONICAL_BAD_TARGET", pageSite(context, page, ["seo", "canonical"]), `Canonical "${page.canonical}" is not a valid absolute URL.`)
+    ];
+  }
+  const found = [];
+  if (origin && canonical.origin !== origin) {
+    const sameHost = canonical.host === new URL(origin).host;
+    if (sameHost) {
+      found.push(finding("BLUME_AUDIT_CANONICAL_PROTOCOL_MISMATCH", pageSite(context, page, ["seo", "canonical"]), `Canonical uses ${canonical.protocol}// but the site is ${new URL(origin).protocol}//.`));
+    }
+    return found;
+  }
+  const target = normalizePath(stripBasePath(normalizeBasePath(context.project.config.deployment.base), decodePath(canonical.pathname)));
+  if (target === normalizePath(page.url)) {
+    return found;
+  }
+  const redirect = context.redirects.find((entry) => normalizePath(entry.from) === target);
+  if (redirect) {
+    found.push(finding("BLUME_AUDIT_CANONICAL_BAD_TARGET", pageSite(context, page, ["seo", "canonical"]), `Canonical points at ${target}, which is a redirect to ${redirect.to}.`));
+  } else if (context.byUrl.has(target)) {
+    const version = page.route?.version;
+    const archived = version ? context.project.config.versions?.archived.find((entry) => entry.id === version) : undefined;
+    const latestAlternate = page.route?.versionAlternates.find((alternate) => alternate.version === "");
+    const intentional = archived?.canonical === "latest" && latestAlternate !== undefined && normalizePath(latestAlternate.path) === target;
+    if (!intentional) {
+      found.push(finding("BLUME_AUDIT_CANONICAL_NOT_SELF", pageSite(context, page, ["seo", "canonical"]), `Page declares ${target} as its canonical, so it will not be indexed itself.`));
+    }
+  } else {
+    found.push(finding("BLUME_AUDIT_CANONICAL_BAD_TARGET", pageSite(context, page, ["seo", "canonical"]), `Canonical points at ${target}, which is not a page on this site.`));
+  }
+  return found;
+};
+var indexabilityChecks = {
+  category: "indexability",
+  run(context) {
+    const found = [];
+    if (!context.project.config.deployment.site) {
+      const { adapter } = context.project.config.deployment;
+      const site = {
+        file: context.project.context.configFile ?? undefined,
+        url: "/"
+      };
+      found.push(adapter && SITE_INFERRING_ADAPTERS.has(adapter) ? finding("BLUME_AUDIT_SITE_INFERRED_AT_DEPLOY", site, `deployment.site is not set in this build — on ${adapter} it is inferred from the platform env at deploy time, so canonical URLs, Open Graph images, and the sitemap are only missing from this local artifact.`) : finding("BLUME_AUDIT_SITE_NOT_SET", site, "deployment.site is not set, so no canonical URLs, Open Graph images, or sitemap can be generated."));
+    }
+    for (const page of context.pages) {
+      found.push(...canonicalChecks(context, page));
+      if (page.robots && !page.indexable && !ERROR_ROUTES.has(page.url)) {
+        found.push(finding("BLUME_AUDIT_ROBOTS_META_UNEXPECTED", pageSite(context, page, ["noindex"]), `Page declares robots "${page.robots}" and will not be indexed.`));
+        if (!page.indexable && page.canonical) {
+          found.push(finding("BLUME_AUDIT_CANONICAL_ON_NOINDEX", pageSite(context, page, ["noindex"]), `Page is noindex but declares ${page.canonical} as its canonical.`));
+        }
+      }
+      if (page.route?.draft) {
+        found.push(finding("BLUME_AUDIT_DRAFT_PAGE_PUBLISHED", pageSite(context, page, ["draft"]), `${page.url} is marked draft in its front matter but is in the build.`));
+      }
+      if (page.bytes > context.thresholds.maxHtmlBytes) {
+        const mb = (page.bytes / 1024 / 1024).toFixed(1);
+        found.push(finding("BLUME_AUDIT_HTML_TOO_LARGE", pageSite(context, page), `Page HTML is ${mb} MB — past Googlebot's 2 MB limit, the rest is not crawled.`));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/graph.ts
+var add = (map, key, value) => {
+  const existing = map.get(key);
+  if (existing) {
+    existing.add(value);
+  } else {
+    map.set(key, new Set([value]));
+  }
+};
+var buildGraph = (pages, origin, deployBase = "") => {
+  const graph = {
+    chromeIn: new Map,
+    chromeOut: new Map,
+    contentIn: new Map,
+    contentOut: new Map
+  };
+  for (const page of pages) {
+    for (const link of page.links) {
+      const resolved = resolveHref(page.url, link.href, origin, deployBase);
+      if (resolved.kind !== "internal" && resolved.kind !== "self-origin") {
+        continue;
+      }
+      const out = link.content ? graph.contentOut : graph.chromeOut;
+      const incoming = link.content ? graph.contentIn : graph.chromeIn;
+      add(out, page.url, resolved.path);
+      add(incoming, resolved.path, page.url);
+    }
+  }
+  return graph;
+};
+var orphanPages = (pages, graph, homeUrl = "/") => pages.filter((page) => page.indexable && page.url !== "/" && page.url !== homeUrl && (graph.contentIn.get(page.url)?.size ?? 0) === 0);
+
+// src/audit/checks/links.ts
+var MAGIC_FRAGMENTS = new Set(["", "top"]);
+var anchorResolves = (target, fragment) => {
+  if (MAGIC_FRAGMENTS.has(fragment)) {
+    return true;
+  }
+  try {
+    return target.ids.has(fragment) || target.ids.has(decodeURIComponent(fragment));
+  } catch {
+    return target.ids.has(fragment);
+  }
+};
+var redirectFrom = (context, path) => context.redirects.find((entry) => normalizePath(entry.from) === path);
+var linkChecks = {
+  category: "links",
+  run(context) {
+    const found = [];
+    const origin = siteOrigin(context.project.config.deployment.site);
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const brokenChrome = new Map;
+    const redirectedChrome = new Map;
+    const brokenChromeAnchors = new Map;
+    const checkAnchor = (page, link, target, fragment) => {
+      if (anchorResolves(target, fragment)) {
+        return;
+      }
+      const where = target === page ? "this page" : `${target.url}, which has no such id`;
+      if (link.content) {
+        found.push(finding("BLUME_AUDIT_ANCHOR_BROKEN", pageSite(context, page), `Link to ${link.href} points at #${fragment} on ${where}.`));
+      } else {
+        const key = `${target.url}#${fragment}`;
+        if (!brokenChromeAnchors.has(key)) {
+          brokenChromeAnchors.set(key, page);
+        }
+      }
+    };
+    const classify = (page, link) => {
+      if (link.href.startsWith("#")) {
+        checkAnchor(page, link, page, link.href.slice(1));
+        return;
+      }
+      const resolved = resolveHref(page.url, link.href, origin, deployBase);
+      if (resolved.kind === "external" || resolved.kind === "ignored") {
+        return;
+      }
+      const anchorTarget = resolved.hash ? context.byUrl.get(resolved.path) : undefined;
+      if (anchorTarget) {
+        checkAnchor(page, link, anchorTarget, resolved.hash);
+      }
+      if (resolved.kind === "self-origin") {
+        found.push(finding("BLUME_AUDIT_INTERNAL_LINK_ABSOLUTE", pageSite(context, page), `Link to ${link.href} hardcodes the site's origin; use ${resolved.path} instead.`));
+      }
+      if (link.rel?.includes("nofollow")) {
+        found.push(finding("BLUME_AUDIT_INTERNAL_LINK_NOFOLLOW", pageSite(context, page), `Internal link to ${resolved.path} is rel="nofollow".`));
+      }
+      const { path } = resolved;
+      const redirect = redirectFrom(context, path);
+      if (redirect) {
+        if (link.content) {
+          found.push(finding("BLUME_AUDIT_LINK_TO_REDIRECT", pageSite(context, page), `Link to ${path} goes through a redirect to ${redirect.to}.`));
+        } else if (!redirectedChrome.has(path)) {
+          redirectedChrome.set(path, page);
+        }
+        return;
+      }
+      if (isServed(context, path)) {
+        return;
+      }
+      if (link.content) {
+        found.push(finding("BLUME_AUDIT_LINK_TO_BROKEN", pageSite(context, page), `Link to ${link.href} resolves to ${path}, which the build does not serve.`));
+      } else if (!brokenChrome.has(path)) {
+        brokenChrome.set(path, page);
+      }
+    };
+    for (const page of context.pages) {
+      for (const link of page.links) {
+        classify(page, link);
+      }
+    }
+    for (const [path, page] of brokenChrome) {
+      found.push(finding("BLUME_AUDIT_LINK_TO_BROKEN", { url: page.url }, `Navigation links to ${path}, which the build does not serve.`, "Fix the entry in your navigation config or meta file."));
+    }
+    for (const [path, page] of redirectedChrome) {
+      const redirect = redirectFrom(context, path);
+      found.push(finding("BLUME_AUDIT_LINK_TO_REDIRECT", { url: page.url }, `Navigation links to ${path}, which redirects to ${redirect?.to}.`, "Point the navigation entry straight at the destination."));
+    }
+    for (const [key, page] of brokenChromeAnchors) {
+      found.push(finding("BLUME_AUDIT_ANCHOR_BROKEN", { url: page.url }, `Navigation links to ${key}, but the target page has no such id.`));
+    }
+    const homeUrl = normalizeBasePath(context.project.config.basePath) || "/";
+    for (const page of orphanPages(context.pages, context.graph, homeUrl)) {
+      found.push(finding("BLUME_AUDIT_ORPHAN_PAGE", pageSite(context, page), "No other page's body links here — it is reachable only from the sidebar."));
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/llms.ts
+var isLlmsToggleObject = (value) => typeof value === "object" && value !== null;
+var llmsConfig = (context) => {
+  const value = context.project.config.ai?.llmsTxt;
+  if (isLlmsToggleObject(value)) {
+    return { enabled: value.enabled, openapi: value.openapi };
+  }
+  return { enabled: value !== false, openapi: true };
+};
+var entryPath = (url, origin, deployBase) => {
+  if (/^https?:\/\//iu.test(url)) {
+    try {
+      const parsed = new URL(url);
+      if (origin && parsed.origin !== origin) {
+        return null;
+      }
+      return normalizePath(stripBasePath(deployBase, decodeURI(parsed.pathname)));
+    } catch {
+      return null;
+    }
+  }
+  if (!url.startsWith("/")) {
+    return null;
+  }
+  try {
+    return normalizePath(stripBasePath(deployBase, decodeURI(url)));
+  } catch {
+    return normalizePath(stripBasePath(deployBase, url));
+  }
+};
+var llmsChecks = {
+  category: "ai",
+  run(context) {
+    const { enabled, openapi } = llmsConfig(context);
+    if (!enabled) {
+      return [];
+    }
+    const { llms } = context;
+    if (!llms) {
+      return [
+        finding("BLUME_AUDIT_LLMS_TXT_MISSING", { url: "/llms.txt" }, "The build has no llms.txt.")
+      ];
+    }
+    const found = [];
+    const origin = siteOrigin(context.project.config.deployment.site);
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const listed = new Set;
+    for (const entry of llms.entries) {
+      const path = entryPath(entry.url, origin, deployBase);
+      if (path === null) {
+        continue;
+      }
+      listed.add(path);
+      if (!isServed(context, path)) {
+        found.push(finding("BLUME_AUDIT_LLMS_TXT_STALE_ENTRY", { file: llms.file, line: entry.line, url: entry.url }, `llms.txt lists ${path}, which the build does not serve.`));
+      }
+    }
+    for (const page of context.pages) {
+      const { route } = page;
+      if (!route || route.hidden || route.draft || !page.indexable || ERROR_ROUTES.has(page.url) || !openapi && route.source.name === "openapi" || listed.has(normalizePath(page.url))) {
+        continue;
+      }
+      found.push(finding("BLUME_AUDIT_LLMS_TXT_PAGE_MISSING", pageSite(context, page), `${page.url} is built and indexable but is not listed in llms.txt.`));
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/network.ts
+var CLIENT_ERROR = 400;
+var SERVER_ERROR = 500;
+var SLOW_MS = 1500;
+var liveUrl = (origin, page, deployBase) => new URL(`${deployBase}${page.url}`, origin).toString();
+var badResponse = (context, page, result) => {
+  const site = pageSite(context, page);
+  if (result.timedOut) {
+    return finding("BLUME_AUDIT_HTTP_TIMEOUT", site, `${page.url} did not respond within the timeout.`);
+  }
+  const { status } = result;
+  if (status !== undefined && status >= SERVER_ERROR) {
+    return finding("BLUME_AUDIT_HTTP_5XX", site, `${page.url} returned HTTP ${status}.`);
+  }
+  if (status !== undefined && status >= CLIENT_ERROR) {
+    return finding("BLUME_AUDIT_HTTP_4XX", site, `${page.url} is in the build but returned HTTP ${status}.`);
+  }
+  if (!result.ok) {
+    return finding("BLUME_AUDIT_HTTP_5XX", site, `${page.url} is unreachable: ${result.error ?? "no response"}.`);
+  }
+  return null;
+};
+var servedPageChecks = (context, page, result, origin) => {
+  const site = pageSite(context, page);
+  const found = [];
+  if (result.redirected && result.finalUrl?.startsWith("http://") && origin.startsWith("https://")) {
+    found.push(finding("BLUME_AUDIT_REDIRECT_TO_HTTP", site, `${page.url} redirects to ${result.finalUrl}, downgrading to HTTP.`));
+  }
+  if (!result.encoding) {
+    found.push(finding("BLUME_AUDIT_NOT_COMPRESSED", site, `${page.url} is served without gzip or brotli compression.`));
+  }
+  if (result.ms !== undefined && result.ms > SLOW_MS) {
+    found.push(finding("BLUME_AUDIT_SLOW_RESPONSE", site, `${page.url} took ${result.ms}ms to respond.`));
+  }
+  const tag = result.robotsTag;
+  if (tag?.includes("noindex") && page.indexable) {
+    found.push(finding("BLUME_AUDIT_ROBOTS_HEADER_CONFLICT", site, `${page.url} sends "X-Robots-Tag: ${tag}" but its HTML has no noindex — the header wins.`));
+  }
+  return found;
+};
+var networkChecks = {
+  category: "network",
+  async run(context) {
+    const { origin } = context;
+    if (!origin) {
+      return [];
+    }
+    const found = [];
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const targets = context.pages.map((page) => liveUrl(origin, page, deployBase));
+    const robotsUrl = new URL(`${deployBase}/robots.txt`, origin).toString();
+    const sitemapUrl = new URL(`${deployBase}/sitemap.xml`, origin).toString();
+    const results = await probeAll([...targets, robotsUrl, sitemapUrl]);
+    for (const page of context.pages) {
+      const result = results.get(liveUrl(origin, page, deployBase));
+      if (!result) {
+        continue;
+      }
+      const failure = badResponse(context, page, result);
+      if (failure) {
+        found.push(failure);
+        continue;
+      }
+      found.push(...servedPageChecks(context, page, result, origin));
+    }
+    const robots = results.get(robotsUrl);
+    if (robots && !robots.ok) {
+      found.push(finding("BLUME_AUDIT_ROBOTS_NOT_ACCESSIBLE", { url: "/robots.txt" }, `robots.txt is not reachable at ${robotsUrl}.`));
+    }
+    const sitemap = results.get(sitemapUrl);
+    if (context.sitemap && sitemap && !sitemap.ok) {
+      found.push(finding("BLUME_AUDIT_SITEMAP_NOT_ACCESSIBLE", { url: "/sitemap.xml" }, `sitemap.xml is in the build but is not reachable at ${sitemapUrl}.`));
+    }
+    return found;
+  },
+  tier: "network"
+};
+var externalChecks = {
+  category: "network",
+  async run(context) {
+    const origin = siteOrigin(context.project.config.deployment.site);
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const linkers = new Map;
+    for (const page of context.pages) {
+      for (const link of page.links) {
+        const resolved = resolveHref(page.url, link.href, origin, deployBase);
+        if (resolved.kind !== "external") {
+          continue;
+        }
+        const pages = linkers.get(resolved.url);
+        if (pages) {
+          if (!pages.includes(page)) {
+            pages.push(page);
+          }
+        } else {
+          linkers.set(resolved.url, [page]);
+        }
+      }
+    }
+    if (linkers.size === 0) {
+      return [];
+    }
+    const results = await probeAll([...linkers.keys()]);
+    const found = [];
+    for (const [url, pages] of linkers) {
+      const result = results.get(url);
+      if (!result) {
+        continue;
+      }
+      const site = pageSite(context, pages[0]);
+      const grade = gradeExternal(result);
+      if (grade) {
+        found.push({
+          ...finding("BLUME_AUDIT_EXTERNAL_LINK_BROKEN", site, `${url} is unreachable (${grade.detail}), linked from ${pages.length} page(s).`),
+          severity: grade.severity
+        });
+        continue;
+      }
+      if (result.redirected && result.finalUrl && result.finalUrl !== url) {
+        found.push(finding("BLUME_AUDIT_EXTERNAL_LINK_REDIRECT", site, `${url} redirects to ${result.finalUrl}.`));
+      }
+    }
+    return found;
+  },
+  tier: "external"
+};
+
+// src/audit/checks/og-image.ts
+import { readFile } from "node:fs/promises";
+import { join } from "pathe";
+
+// src/audit/image-size.ts
+import sharp from "sharp";
+var imageSize = async (bytes) => {
+  try {
+    const { width, height } = await sharp(bytes).metadata();
+    return width > 0 && height > 0 ? { height, width } : null;
+  } catch {
+    return null;
+  }
+};
+
+// src/audit/checks/og-image.ts
+var MIN_WIDTH = 600;
+var MIN_HEIGHT = 315;
+var ogImageChecks = {
+  category: "social",
+  async run(context) {
+    const found = [];
+    const sizes = new Map;
+    const read = async (path) => {
+      try {
+        return imageSize(await readFile(join(context.staticDir, path)));
+      } catch {
+        return null;
+      }
+    };
+    const measure = (path) => {
+      const cached = sizes.get(path);
+      if (cached) {
+        return cached;
+      }
+      const pending = read(path);
+      sizes.set(path, pending);
+      return pending;
+    };
+    const origin = siteOrigin(context.project.config.deployment.site);
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const candidates = [];
+    for (const page of context.pages) {
+      const src = page.og["og:image"];
+      if (!src) {
+        continue;
+      }
+      const resolved = resolveHref(page.url, src, origin, deployBase);
+      if (resolved.kind === "external" || resolved.kind === "ignored") {
+        continue;
+      }
+      const { path } = resolved;
+      if (!(context.files.has(path) || context.files.has(`${path}/index.html`))) {
+        found.push(finding("BLUME_AUDIT_OG_IMAGE_BROKEN", pageSite(context, page, ["seo", "image"]), `og:image points at ${path}, which is not in the build.`));
+        continue;
+      }
+      candidates.push({ page, path });
+    }
+    const measured = await Promise.all(candidates.map(async (candidate) => ({
+      ...candidate,
+      size: await measure(candidate.path)
+    })));
+    for (const { page, path, size } of measured) {
+      if (size && (size.width < MIN_WIDTH || size.height < MIN_HEIGHT)) {
+        found.push(finding("BLUME_AUDIT_OG_IMAGE_SMALL", pageSite(context, page, ["seo", "image"]), `og:image ${path} is ${size.width}×${size.height} — below the ${MIN_WIDTH}×${MIN_HEIGHT} floor for large social cards.`));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/redirects.ts
+var redirectChecks = {
+  category: "redirects",
+  run(context) {
+    const found = [];
+    const configFile = context.project.context.configFile ?? undefined;
+    const site = { file: configFile, url: "/" };
+    for (const redirect of context.redirects) {
+      const from = normalizePath(redirect.from);
+      if (context.byUrl.has(from)) {
+        found.push(finding("BLUME_AUDIT_REDIRECT_SOURCE_IS_PAGE", { ...site, url: from }, `A redirect is configured from ${from}, but ${from} is also a real page — the redirect never fires.`));
+        continue;
+      }
+      if (redirect.outcome === "loop") {
+        found.push(finding("BLUME_AUDIT_REDIRECT_LOOP", { ...site, url: from }, `Redirect loop: ${redirect.chain.join(" → ")}`));
+      } else if (redirect.outcome === "broken") {
+        found.push(finding("BLUME_AUDIT_REDIRECT_BROKEN", { ...site, url: from }, `Redirect from ${from} lands on ${redirect.chain.at(-1)}, which the build does not serve.`));
+      } else if (redirect.outcome === "chain") {
+        const hops = redirect.chain.length - 1;
+        const severity = hops > context.thresholds.maxRedirectHops ? " (too long)" : "";
+        found.push(finding("BLUME_AUDIT_REDIRECT_CHAIN", { ...site, url: from }, `Redirect from ${from} passes through ${hops} hops${severity}: ${redirect.chain.join(" → ")}`));
+      }
+    }
+    for (const page of context.pages) {
+      if (page.metaRefresh) {
+        found.push(finding("BLUME_AUDIT_META_REFRESH", pageSite(context, page), `Page uses a meta refresh redirect ("${page.metaRefresh}").`));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/robots.ts
+import robotsParser from "robots-parser";
+var MATCH_ORIGIN = "https://robots-audit.invalid";
+var robotsChecks = {
+  category: "robots",
+  run(context) {
+    const { robots } = context;
+    const { site } = context.project.config.deployment;
+    if (!context.project.config.seo.robots) {
+      return [];
+    }
+    if (!robots) {
+      return [
+        finding("BLUME_AUDIT_ROBOTS_MISSING", { url: "/robots.txt" }, "The build has no robots.txt.")
+      ];
+    }
+    const found = robots.invalid.map((line) => finding("BLUME_AUDIT_ROBOTS_INVALID", { file: robots.file, line: line.line, url: "/robots.txt" }, `robots.txt line ${line.line} is not a directive: "${line.text}"`));
+    if (site && robots.sitemaps.length === 0) {
+      found.push(finding("BLUME_AUDIT_ROBOTS_SITEMAP_MISSING", { file: robots.file, url: "/robots.txt" }, "robots.txt does not declare a Sitemap."));
+    }
+    const parser = robotsParser(`${MATCH_ORIGIN}/robots.txt`, robots.raw);
+    const lines = robots.raw.split(/\r?\n/u);
+    for (const loc of context.sitemap?.urls ?? []) {
+      let pathname;
+      try {
+        ({ pathname } = new URL(loc));
+      } catch {
+        continue;
+      }
+      const path = normalizePath(pathname);
+      const url = `${MATCH_ORIGIN}${pathname}`;
+      if (parser.isDisallowed(url, "*")) {
+        const line = parser.getMatchingLineNumber(url, "*");
+        const rule = line > 0 ? lines[line - 1]?.trim() : undefined;
+        found.push(finding("BLUME_AUDIT_ROBOTS_DISALLOWS_INDEXABLE", { file: robots.file, url: path }, `robots.txt "${rule ?? "Disallow"}" blocks ${path}, which sitemap.xml advertises.`));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/sitemap.ts
+var MAX_SITEMAP_BYTES = 50 * 1024 * 1024;
+var MAX_SITEMAP_URLS = 50000;
+var LASTMOD_SLACK_MS = 24 * 60 * 60 * 1000;
+var ERROR_ROUTES2 = new Set(["/404", "/500"]);
+var sitemapPaths = (context, deployBase) => {
+  const paths = new Map;
+  for (const loc of context.sitemap?.urls ?? []) {
+    try {
+      paths.set(normalizePath(stripBasePath(deployBase, decodePath(new URL(loc).pathname))), loc);
+    } catch {}
+  }
+  return paths;
+};
+var canonicalPath = (canonical, deployBase) => {
+  try {
+    return normalizePath(stripBasePath(deployBase, decodePath(new URL(canonical).pathname)));
+  } catch {
+    return null;
+  }
+};
+var checkListedUrl = (context, loc, origin, file, deployBase) => {
+  let parsed;
+  try {
+    parsed = new URL(loc);
+  } catch {
+    return [
+      finding("BLUME_AUDIT_SITEMAP_INVALID", { file, url: "/sitemap.xml" }, `sitemap.xml lists "${loc}", which is not a valid absolute URL.`)
+    ];
+  }
+  if (origin && parsed.origin !== origin) {
+    return [
+      finding("BLUME_AUDIT_SITEMAP_OUT_OF_SCOPE", { file, url: loc }, `sitemap.xml lists ${loc}, which is on another origin.`)
+    ];
+  }
+  const path = normalizePath(stripBasePath(deployBase, decodePath(parsed.pathname)));
+  const page = context.byUrl.get(path);
+  if (!page) {
+    const redirect = context.redirects.find((entry) => normalizePath(entry.from) === path);
+    return [
+      finding("BLUME_AUDIT_SITEMAP_BAD_URL", { file, url: loc }, redirect ? `sitemap.xml lists ${path}, which redirects to ${redirect.to}.` : `sitemap.xml lists ${path}, which the build does not serve.`)
+    ];
+  }
+  const found = [];
+  if (!page.indexable) {
+    found.push(finding("BLUME_AUDIT_NOINDEX_IN_SITEMAP", pageSite(context, page, ["noindex"]), `${path} is in the sitemap but declares robots "${page.robots}".`));
+  }
+  const canonical = page.canonical && canonicalPath(page.canonical, deployBase);
+  if (canonical && canonical !== path) {
+    found.push(finding("BLUME_AUDIT_NON_CANONICAL_IN_SITEMAP", pageSite(context, page, ["seo", "canonical"]), `${path} is in the sitemap but canonicalizes to ${canonical}.`));
+  }
+  return found;
+};
+var sitemapChecks = {
+  category: "sitemap",
+  run(context) {
+    const { sitemap } = context;
+    const { site } = context.project.config.deployment;
+    if (!(site && context.project.config.seo.sitemap)) {
+      return [];
+    }
+    if (!sitemap) {
+      return [
+        finding("BLUME_AUDIT_SITEMAP_INVALID", { url: "/sitemap.xml" }, "The build has no sitemap.xml.", "Set `seo.sitemap: true` and `deployment.site` in blume.config.ts.")
+      ];
+    }
+    const found = [];
+    if (sitemap.error) {
+      found.push(finding("BLUME_AUDIT_SITEMAP_INVALID", { file: sitemap.file, url: "/sitemap.xml" }, `sitemap.xml is not a valid urlset: ${sitemap.error}`));
+      return found;
+    }
+    if (sitemap.bytes > MAX_SITEMAP_BYTES || sitemap.urls.length > MAX_SITEMAP_URLS) {
+      found.push(finding("BLUME_AUDIT_SITEMAP_TOO_LARGE", { file: sitemap.file, url: "/sitemap.xml" }, `sitemap.xml holds ${sitemap.urls.length} URLs in ${Math.round(sitemap.bytes / 1024 / 1024)} MB.`));
+    }
+    for (const [loc, lastmod] of sitemap.lastmod ?? []) {
+      const time = Date.parse(lastmod);
+      if (Number.isNaN(time)) {
+        found.push(finding("BLUME_AUDIT_SITEMAP_LASTMOD_INVALID", { file: sitemap.file, url: loc }, `sitemap.xml gives ${loc} a lastmod of "${lastmod}", which is not a valid W3C date.`));
+      } else if (time > Date.now() + LASTMOD_SLACK_MS) {
+        found.push(finding("BLUME_AUDIT_SITEMAP_LASTMOD_INVALID", { file: sitemap.file, url: loc }, `sitemap.xml gives ${loc} a lastmod of ${lastmod}, which is in the future.`));
+      }
+    }
+    const origin = siteOrigin(site);
+    const deployBase = normalizeBasePath(context.project.config.deployment.base);
+    const listed = sitemapPaths(context, deployBase);
+    for (const loc of sitemap.urls) {
+      found.push(...checkListedUrl(context, loc, origin, sitemap.file, deployBase));
+    }
+    for (const page of context.pages) {
+      if (!page.indexable || ERROR_ROUTES2.has(page.url) || listed.has(normalizePath(page.url))) {
+        continue;
+      }
+      found.push(finding("BLUME_AUDIT_INDEXABLE_PAGE_NOT_IN_SITEMAP", pageSite(context, page), `${page.url} is built and indexable but is not listed in sitemap.xml.`));
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/checks/social.ts
+var OG_REQUIRED = ["og:title", "og:type", "og:description"];
+var ogRequired = (hasSite) => hasSite ? [...OG_REQUIRED, "og:url"] : OG_REQUIRED;
+var socialChecks = {
+  category: "social",
+  run(context) {
+    const found = [];
+    const hasSite = Boolean(context.project.config.deployment.site);
+    const required = ogRequired(hasSite);
+    for (const page of context.pages) {
+      if (!page.indexable) {
+        continue;
+      }
+      const missing = required.filter((property) => !page.og[property]);
+      if (missing.length > 0) {
+        found.push(finding("BLUME_AUDIT_OG_INCOMPLETE", pageSite(context, page, ["description"]), missing.length === required.length ? "Page has no Open Graph tags." : `Open Graph is missing ${missing.join(", ")}.`));
+      }
+      if (hasSite && !page.og["og:image"]) {
+        found.push(finding("BLUME_AUDIT_OG_IMAGE_MISSING", pageSite(context, page, ["seo", "image"]), "Page has no og:image — shares will render without a preview card."));
+      }
+      const ogUrl = page.og["og:url"];
+      if (ogUrl && page.canonical && ogUrl !== page.canonical) {
+        found.push(finding("BLUME_AUDIT_OG_URL_MISMATCH", pageSite(context, page), `og:url is ${ogUrl} but the canonical is ${page.canonical}.`));
+      }
+      if (!page.twitter["twitter:card"]) {
+        found.push(finding("BLUME_AUDIT_TWITTER_CARD_INCOMPLETE", pageSite(context, page), "Page has no twitter:card — X will render a plain link, not a card."));
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+var isJsonLdNode = (value) => typeof value === "object" && value !== null;
+var jsonLdProblems = (node) => {
+  if (!isJsonLdNode(node)) {
+    return ["it is not an object"];
+  }
+  const problems = [];
+  if (!node["@context"]) {
+    problems.push("@context");
+  }
+  const graph = node["@graph"];
+  if (Array.isArray(graph)) {
+    const untyped = graph.filter((entry) => !isJsonLdNode(entry) || !entry["@type"]).length;
+    if (untyped > 0) {
+      problems.push(`@type on ${untyped} of its ${graph.length} @graph nodes`);
+    }
+  } else if (!node["@type"]) {
+    problems.push("@type");
+  }
+  return problems;
+};
+var structuredDataChecks = {
+  category: "structured-data",
+  run(context) {
+    const found = [];
+    for (const page of context.pages) {
+      for (const error of page.jsonldErrors) {
+        found.push(finding("BLUME_AUDIT_JSONLD_INVALID", pageSite(context, page), `A JSON-LD block failed to parse: ${error}`));
+      }
+      for (const node of page.jsonld) {
+        const problems = jsonLdProblems(node);
+        if (problems.length > 0) {
+          found.push(finding("BLUME_AUDIT_JSONLD_INCOMPLETE", pageSite(context, page), `A JSON-LD block is missing ${problems.join(" and ")}.`));
+        }
+      }
+    }
+    return found;
+  },
+  tier: "static"
+};
+var URL_STYLE = [
+  { name: "uppercase letters", test: /[A-Z]/u },
+  { name: "underscores", test: /_/u },
+  { name: "spaces", test: /%20| /u }
+];
+var DOTTED_HOST = /^\/\/[^/]*\./u;
+var doubledSlash = (href) => {
+  if (href.startsWith("//")) {
+    return !DOTTED_HOST.test(href);
+  }
+  if (!href.startsWith("/")) {
+    return false;
+  }
+  const [path] = href.split(/[?#]/u);
+  return (path ?? "").includes("//");
+};
+var urlChecks = {
+  category: "links",
+  run(context) {
+    const found = [];
+    const doubled = new Map;
+    for (const page of context.pages) {
+      if (page.url.includes("//")) {
+        found.push(finding("BLUME_AUDIT_DOUBLE_SLASH_URL", pageSite(context, page), `URL ${normalizePath(page.url)} contains a double slash.`));
+      }
+      for (const link of page.links) {
+        const href = link.href.trim();
+        if (doubledSlash(href) && !doubled.has(href)) {
+          doubled.set(href, page);
+        }
+      }
+      const untidy = URL_STYLE.filter((style) => style.test.test(page.url));
+      if (untidy.length > 0) {
+        found.push(finding("BLUME_AUDIT_URL_STYLE", pageSite(context, page), `URL ${page.url} contains ${untidy.map((style) => style.name).join(" and ")}.`));
+      }
+    }
+    for (const [href, page] of doubled) {
+      found.push(finding("BLUME_AUDIT_DOUBLE_SLASH_URL", pageSite(context, page), `Link to ${href} contains a double slash.`));
+    }
+    return found;
+  },
+  tier: "static"
+};
+
+// src/audit/crawl.ts
+import { readFile as readFile2, stat } from "node:fs/promises";
+import { XMLParser } from "fast-xml-parser";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import pMap from "p-map";
+import { join as join2, relative } from "pathe";
+import { glob } from "tinyglobby";
+
+// src/audit/snapshot.ts
+import { createHash } from "node:crypto";
+
+// src/audit/html.ts
+import { parse } from "node-html-parser";
+var parseHtml = (html) => parse(html, {
+  blockTextElements: { noscript: true, pre: true, script: true, style: true },
+  comment: false
+});
+var attr = (element, name) => {
+  const value = element.getAttribute(name)?.trim();
+  return value || null;
+};
+var metaContents = (document, selector) => document.querySelectorAll(selector).map((element) => element.getAttribute("content")?.trim() ?? "").filter((value) => value.length > 0);
+var visibleText = (element) => {
+  const clone = parse(element.outerHTML, {
+    blockTextElements: { noscript: true, pre: true, script: true, style: true },
+    comment: false
+  });
+  for (const node of clone.querySelectorAll("script, style, pre, code")) {
+    node.remove();
+  }
+  return clone.structuredText.replaceAll(/\s+/gu, " ").trim();
+};
+
+// src/audit/snapshot.ts
+var CHROME = "nav, aside, header, footer";
+var countWords = (prose, lang) => {
+  let segmenter;
+  try {
+    segmenter = new Intl.Segmenter(lang ?? undefined, { granularity: "word" });
+  } catch {
+    segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+  }
+  let count = 0;
+  for (const segment of segmenter.segment(prose)) {
+    if (segment.isWordLike) {
+      count += 1;
+    }
+  }
+  return count;
+};
+var CONTENT_ROOTS = ["main", "article", "body"];
+var contentRoot = (document) => {
+  for (const selector of CONTENT_ROOTS) {
+    const found = document.querySelector(selector);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+};
+var contentLinks = (document) => {
+  const root = contentRoot(document);
+  if (!root) {
+    return new Set;
+  }
+  return new Set(root.querySelectorAll("a[href]").filter((anchor) => !anchor.closest(CHROME)));
+};
+var collectAssets = (document, selector, srcAttr) => document.querySelectorAll(selector).map((element) => ({
+  alt: element.getAttribute("alt") ?? null,
+  height: attr(element, "height"),
+  src: element.getAttribute(srcAttr)?.trim() ?? "",
+  width: attr(element, "width")
+})).filter((asset) => asset.src.length > 0);
+var collectJsonLd = (document) => {
+  const jsonld = [];
+  const jsonldErrors = [];
+  for (const script of document.querySelectorAll('script[type="application/ld+json"]')) {
+    try {
+      jsonld.push(JSON.parse(script.rawText));
+    } catch (error) {
+      jsonldErrors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  return { jsonld, jsonldErrors };
+};
+var prefixedMeta = (document, keyAttr, prefix) => {
+  const found = {};
+  for (const element of document.querySelectorAll(`meta[${keyAttr}^="${prefix}"]`)) {
+    const key = element.getAttribute(keyAttr)?.trim();
+    const content = element.getAttribute("content")?.trim();
+    if (key && content) {
+      found[key] = content;
+    }
+  }
+  return found;
+};
+var buildSnapshot = (options) => {
+  const { file, url, html, route } = options;
+  const document = parseHtml(html);
+  const inContent = contentLinks(document);
+  const links = document.querySelectorAll("a[href]").map((anchor) => ({
+    content: inContent.has(anchor),
+    href: anchor.getAttribute("href")?.trim() ?? "",
+    rel: attr(anchor, "rel"),
+    text: anchor.text.trim()
+  })).filter((link) => link.href.length > 0);
+  const root = contentRoot(document);
+  const prose = root ? visibleText(root) : "";
+  const robots = document.querySelector('meta[name="robots"]');
+  const lang = attr(document.querySelector("html") ?? document, "lang");
+  const { jsonld, jsonldErrors } = collectJsonLd(document);
+  return {
+    bytes: Buffer.byteLength(html, "utf-8"),
+    canonical: document.querySelector('link[rel="canonical"]')?.getAttribute("href")?.trim() ?? null,
+    contentHash: createHash("sha256").update(prose).digest("hex").slice(0, 16),
+    descriptions: metaContents(document, 'meta[name="description"]'),
+    file,
+    headings: document.querySelectorAll("h1, h2, h3, h4, h5, h6").map((heading) => ({
+      depth: Number(heading.tagName.slice(1)),
+      text: heading.text.trim()
+    })),
+    hreflang: document.querySelectorAll("link[rel=alternate][hreflang]").map((link) => ({
+      href: link.getAttribute("href")?.trim() ?? "",
+      lang: link.getAttribute("hreflang")?.trim() ?? ""
+    })).filter((alternate) => alternate.href && alternate.lang),
+    ids: new Set(document.querySelectorAll("[id]").map((element) => element.getAttribute("id") ?? "").filter((id) => id.length > 0)),
+    images: collectAssets(document, "img[src]", "src"),
+    indexable: !robots?.getAttribute("content")?.includes("noindex"),
+    jsonld,
+    jsonldErrors,
+    lang,
+    links,
+    metaRefresh: document.querySelector('meta[http-equiv="refresh" i]')?.getAttribute("content")?.trim() ?? null,
+    og: prefixedMeta(document, "property", "og:"),
+    robots: robots?.getAttribute("content")?.trim() ?? null,
+    route,
+    scripts: collectAssets(document, "script[src]", "src"),
+    source: route?.sourcePath,
+    styles: collectAssets(document, 'link[rel="stylesheet"][href]', "href"),
+    titles: document.querySelectorAll("title").map((title) => title.text.trim()).filter((text) => text.length > 0),
+    twitter: prefixedMeta(document, "name", "twitter:"),
+    url,
+    viewport: document.querySelector('meta[name="viewport"]')?.getAttribute("content")?.trim() ?? null,
+    wordCount: countWords(prose, lang)
+  };
+};
+
+// src/audit/crawl.ts
+var EXAMPLES_PREFIX = `${examplesRouteBase("")}/`;
+var CRAWL_CONCURRENCY = 16;
+var fileToUrl = (staticDir, file) => {
+  const rel = relative(staticDir, file).replaceAll("\\", "/");
+  const path = rel.replace(/(?:^|\/)index\.html$/u, "").replace(/\.html$/u, "");
+  return path === "" ? "/" : `/${path}`;
+};
+var indexFiles = async (staticDir) => {
+  const found = await glob("**/*", { cwd: staticDir, dot: true });
+  const sized = await pMap(found, async (file) => {
+    const path = `/${file.replaceAll("\\", "/")}`;
+    const info = await stat(join2(staticDir, file));
+    return [path, info.size];
+  }, { concurrency: CRAWL_CONCURRENCY });
+  return new Map(sized);
+};
+var routeIndex = (manifest, basePath) => {
+  const index = new Map;
+  for (const route of manifest.routes) {
+    index.set(route.path, route);
+    const stripped = stripBasePath(basePath, route.path);
+    if (!index.has(stripped)) {
+      index.set(stripped, route);
+    }
+  }
+  return index;
+};
+var sitemapParser = new XMLParser({
+  htmlEntities: true,
+  ignoreAttributes: true,
+  parseTagValue: false,
+  removeNSPrefix: true
+});
+var isUrlsetElement = (value) => typeof value === "object" && value !== null;
+var isUrlEntry = (value) => typeof value === "object" && value !== null;
+var isText = (value) => typeof value === "string";
+var parseSitemap = (file, xml, bytes) => {
+  const doc = { bytes, file, lastmod: new Map, urls: [] };
+  let parsed;
+  try {
+    parsed = sitemapParser.parse(xml);
+  } catch {
+    doc.error = "no <urlset> element";
+    return doc;
+  }
+  if (!Object.hasOwn(parsed, "urlset")) {
+    doc.error = Object.hasOwn(parsed, "sitemapindex") ? "sitemap is an index, not a urlset" : "no <urlset> element";
+    return doc;
+  }
+  const { urlset } = parsed;
+  const entries = isUrlsetElement(urlset) ? [urlset.url].flat() : [];
+  for (const entry of entries) {
+    if (!isUrlEntry(entry)) {
+      continue;
+    }
+    const { loc, lastmod } = entry;
+    const locText = isText(loc) ? loc.trim() : "";
+    if (!locText) {
+      continue;
+    }
+    doc.urls.push(locText);
+    if (isText(lastmod) && lastmod.trim() !== "") {
+      doc.lastmod?.set(locText, lastmod.trim());
+    }
+  }
+  return doc;
+};
+var parseLlms = (file, text) => {
+  const entries = [];
+  const collect = (node) => {
+    if ((node.type === "link" || node.type === "image" || node.type === "definition") && node.url) {
+      entries.push({ line: node.position?.start.line ?? 1, url: node.url });
+    }
+    if ("children" in node) {
+      for (const child of node.children) {
+        collect(child);
+      }
+    }
+  };
+  collect(fromMarkdown(text));
+  return { entries, file };
+};
+var ROBOTS_DIRECTIVE = /^(?<field>[a-z-]+)\s*:\s*(?<value>.*)$/iu;
+var parseRobots = (file, text) => {
+  const doc = { file, invalid: [], raw: text, sitemaps: [] };
+  for (const [index, raw] of text.split(/\r?\n/u).entries()) {
+    const line = raw.trim();
+    if (line === "" || line.startsWith("#")) {
+      continue;
+    }
+    const match = ROBOTS_DIRECTIVE.exec(line);
+    if (!match) {
+      doc.invalid.push({ line: index + 1, text: line });
+      continue;
+    }
+    const field = (match.groups?.field ?? "").toLowerCase();
+    const value = (match.groups?.value ?? "").trim();
+    if (field === "sitemap" && value) {
+      doc.sitemaps.push(value);
+    }
+  }
+  return doc;
+};
+var isDocument = (html) => /<head[\s>]/iu.test(html);
+var readIfPresent = async (file) => {
+  try {
+    return await readFile2(file, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var crawlStaticDir = async (options) => {
+  const { staticDir, manifest, basePath } = options;
+  const routes = routeIndex(manifest, basePath);
+  const htmlFiles = await glob("**/*.html", { absolute: true, cwd: staticDir });
+  const snapshots = await pMap(htmlFiles.toSorted(), async (file) => {
+    const url = fileToUrl(staticDir, file);
+    if (stripBasePath(basePath, url).startsWith(EXAMPLES_PREFIX)) {
+      return null;
+    }
+    const html = await readFile2(file, "utf-8");
+    if (!isDocument(html)) {
+      return null;
+    }
+    return buildSnapshot({
+      file,
+      html,
+      route: routes.get(url) ?? routes.get(stripBasePath(basePath, url)),
+      url
+    });
+  }, { concurrency: CRAWL_CONCURRENCY });
+  const pages = snapshots.filter((page) => page !== null);
+  const sitemapFile = join2(staticDir, "sitemap.xml");
+  const sitemapXml = await readIfPresent(sitemapFile);
+  const robotsFile = join2(staticDir, "robots.txt");
+  const robotsTxt = await readIfPresent(robotsFile);
+  const llmsFile = join2(staticDir, "llms.txt");
+  const llmsText = await readIfPresent(llmsFile);
+  const files = await indexFiles(staticDir);
+  return {
+    files,
+    llms: llmsText === null ? null : parseLlms(llmsFile, llmsText),
+    pages,
+    robots: robotsTxt === null ? null : parseRobots(robotsFile, robotsTxt),
+    sitemap: sitemapXml === null ? null : parseSitemap(sitemapFile, sitemapXml, files.get("/sitemap.xml") ?? Buffer.byteLength(sitemapXml, "utf-8"))
+  };
+};
+
+// src/audit/redirects.ts
+var pathOnly = (value) => {
+  const cut = value.search(/[?#]/u);
+  return cut === -1 ? value : value.slice(0, cut);
+};
+var resolveRedirects = (redirects, served) => {
+  const byFrom = new Map;
+  for (const redirect of redirects) {
+    byFrom.set(normalizePath(redirect.from), redirect);
+  }
+  return redirects.map((redirect) => {
+    const from = normalizePath(redirect.from);
+    const chain = [from];
+    const seen = new Set([from]);
+    let current = redirect.to;
+    for (;; ) {
+      if (/^https?:\/\//iu.test(current)) {
+        chain.push(current);
+        break;
+      }
+      const next = normalizePath(pathOnly(current));
+      if (seen.has(next)) {
+        chain.push(next);
+        return {
+          ...redirect,
+          chain,
+          outcome: "loop"
+        };
+      }
+      chain.push(next);
+      seen.add(next);
+      const hop = byFrom.get(next);
+      if (!hop) {
+        break;
+      }
+      current = hop.to;
+    }
+    const destination = chain.at(-1) ?? from;
+    const external = /^https?:\/\//iu.test(destination);
+    if (!(external || served(destination))) {
+      return { ...redirect, chain, outcome: "broken" };
+    }
+    return {
+      ...redirect,
+      chain,
+      outcome: chain.length > 2 ? "chain" : "ok"
+    };
+  });
+};
+
+// src/audit/run.ts
+var MODULES = [
+  contentChecks,
+  duplicateChecks,
+  indexabilityChecks,
+  linkChecks,
+  redirectChecks,
+  socialChecks,
+  ogImageChecks,
+  i18nChecks,
+  assetChecks,
+  sitemapChecks,
+  robotsChecks,
+  llmsChecks,
+  structuredDataChecks,
+  urlChecks,
+  networkChecks,
+  dnsAidChecks,
+  externalChecks
+];
+
+class NoBuildError extends Error {
+  staticDir;
+  constructor(staticDir) {
+    super(`No build found at ${staticDir}.`);
+    this.name = "NoBuildError";
+    this.staticDir = staticDir;
+  }
+}
+var READ_CONCURRENCY = 16;
+var readSources = async (pages) => {
+  const paths = [
+    ...new Set(pages.flatMap((page) => page.source ? [page.source] : []))
+  ];
+  const entries = await pMap2(paths, async (path) => {
+    try {
+      return [path, await readFile3(path, "utf-8")];
+    } catch {
+      return null;
+    }
+  }, { concurrency: READ_CONCURRENCY });
+  return new Map(entries.filter((entry) => entry !== null));
+};
+var matches = (id, terms) => {
+  const meta = CHECKS.find((check) => check.id === id);
+  const short = id.replace("BLUME_AUDIT_", "").toLowerCase();
+  return terms.some((raw) => {
+    const term = raw.trim().toLowerCase();
+    return term === short || term === id.toLowerCase() || term === meta?.category;
+  });
+};
+var runAudit = async (options) => {
+  const { project } = options;
+  const staticDir = deployStaticDir(project.config, project.context);
+  const basePath = normalizeBasePath(project.config.basePath);
+  const crawl = await crawlStaticDir({
+    basePath,
+    manifest: project.manifest,
+    staticDir
+  });
+  if (crawl.pages.length === 0) {
+    throw new NoBuildError(staticDir);
+  }
+  const origin = options.origin ?? null;
+  const byUrl = new Map(crawl.pages.map((page) => [page.url, page]));
+  const context = {
+    byUrl,
+    files: crawl.files,
+    graph: buildGraph(crawl.pages, siteOrigin(project.config.deployment.site), normalizeBasePath(project.config.deployment.base)),
+    llms: crawl.llms,
+    origin,
+    pages: crawl.pages,
+    project,
+    redirects: resolveRedirects(project.config.redirects.map((redirect) => ({
+      ...redirect,
+      from: withBasePath(basePath, redirect.from),
+      to: withBasePath(basePath, redirect.to)
+    })), (path) => isServed({ byUrl, files: crawl.files, project }, path)),
+    robots: crawl.robots,
+    sitemap: crawl.sitemap,
+    sources: await readSources(crawl.pages),
+    staticDir,
+    thresholds: DEFAULT_THRESHOLDS
+  };
+  const tiers = {
+    external: Boolean(options.external),
+    network: origin !== null,
+    static: true
+  };
+  const results = await Promise.all(MODULES.filter((module) => tiers[module.tier]).map((module) => module.run(context)));
+  let diagnostics = results.flat();
+  if (options.only?.length) {
+    diagnostics = diagnostics.filter((d) => matches(d.code, options.only ?? []));
+  }
+  if (options.skip?.length) {
+    diagnostics = diagnostics.filter((d) => !matches(d.code, options.skip ?? []));
+  }
+  return {
+    diagnostics,
+    origin,
+    pages: crawl.pages.length,
+    staticDir,
+    tiers
+  };
+};
+
+// src/cli/commands/audit.ts
+var SEVERITIES = ["error", "warning", "info"];
+var failingSeverities = (gate) => new Set(SEVERITIES.slice(0, SEVERITIES.indexOf(gate) + 1));
+var splitTerms = (value) => value ? value.split(",").map((term) => term.trim()).filter(Boolean) : [];
+var shouldFail = (result, gate) => {
+  const failing = failingSeverities(gate);
+  return result.diagnostics.some((d) => failing.has(d.severity));
+};
+var launchAgentCode = async (agent, prompt) => {
+  const cli = AGENTS[agent];
+  try {
+    return await launchAgent(cli.bin, prompt);
+  } catch (error) {
+    if (error?.code !== "ENOENT") {
+      throw error;
+    }
+    logger.error(`${cli.name} (\`${cli.bin}\`) was not found on PATH. Install it with \`${cli.install}\`.`);
+    return process.exit(1);
+  }
+};
+var auditCommand = defineCommand({
+  args: {
+    claude: {
+      description: "Hand the findings to Claude Code to fix interactively.",
+      type: "boolean"
+    },
+    codex: {
+      description: "Hand the findings to Codex to fix interactively.",
+      type: "boolean"
+    },
+    external: {
+      description: "Probe outbound links over the network.",
+      type: "boolean"
+    },
+    "fail-on": {
+      description: "Exit non-zero at this severity or above: error | warning | info. Defaults to error.",
+      type: "string"
+    },
+    json: {
+      description: "Emit the report as JSON on stdout (for CI/editors).",
+      type: "boolean"
+    },
+    "list-checks": {
+      description: "Print every check the audit can report, then exit.",
+      type: "boolean"
+    },
+    only: {
+      description: "Only report these checks or categories (comma-separated).",
+      type: "string"
+    },
+    skip: {
+      description: "Suppress these checks or categories (comma-separated).",
+      type: "string"
+    },
+    strict: {
+      description: "Alias for --fail-on warning.",
+      type: "boolean"
+    },
+    url: {
+      description: "Also probe a live deployment (e.g. https://docs.example.com) for status codes, headers, and redirects.",
+      type: "string"
+    },
+    verbose: {
+      description: "List every affected page instead of the first few.",
+      type: "boolean"
+    }
+  },
+  meta: commandMeta.audit,
+  async run({ args }) {
+    if (args["list-checks"]) {
+      process.stdout.write(formatCatalog());
+      return;
+    }
+    const root = process.cwd();
+    const gateInput = args["fail-on"] ?? (args.strict ? "warning" : "error");
+    const gate = SEVERITIES.find((severity) => severity === gateInput);
+    if (gate === undefined) {
+      logger.error(`Invalid --fail-on "${gateInput}" (use ${SEVERITIES.join(" | ")}).`);
+      process.exit(1);
+    }
+    const agents = Object.keys(AGENTS).filter((kind) => args[kind]);
+    if (agents.length > 1) {
+      logger.error("Pass at most one of --claude or --codex.");
+      process.exit(1);
+    }
+    const [agent] = agents;
+    if (agent && args.json) {
+      logger.error(`--json and --${agent} are mutually exclusive.`);
+      process.exit(1);
+    }
+    let result;
+    try {
+      const project = await scanProject(root, { mode: "build" });
+      result = await runAudit({
+        external: args.external,
+        only: splitTerms(args.only),
+        origin: args.url,
+        project,
+        skip: splitTerms(args.skip)
+      });
+    } catch (error) {
+      if (error instanceof NoBuildError) {
+        logger.error(`${error.message} Run \`blume build\` first.`);
+        process.exit(1);
+      }
+      if (error instanceof BlumeError) {
+        logger.error(error.diagnostic.message);
+        process.exit(1);
+      }
+      reportInternalError(error);
+      process.exit(1);
+    }
+    if (agent) {
+      process.stderr.write(formatReport(result, root, { verbose: args.verbose }));
+      if (result.diagnostics.length === 0) {
+        return;
+      }
+      const cli = AGENTS[agent];
+      const report = await writeAgentReport(result, root);
+      const count = result.diagnostics.length;
+      process.stderr.write(`  Handing ${count} finding${count === 1 ? "" : "s"} to ${cli.name}…
+
+`);
+      const code = await launchAgentCode(agent, fixPrompt(report));
+      if (code !== 0) {
+        process.exit(code);
+      }
+      return;
+    }
+    if (args.json) {
+      process.stdout.write(reportJson(result, root));
+      if (shouldFail(result, gate)) {
+        await flushStdout();
+        process.exit(1);
+      }
+      return;
+    }
+    process.stderr.write(formatReport(result, root, { verbose: args.verbose }));
+    if (shouldFail(result, gate)) {
+      process.exit(1);
+    }
+  }
+});
+export {
+  auditCommand,
+  shouldFail
+};
+
+//# debugId=B282B1370257AC4E64756E2164756E21
+//# sourceMappingURL=chunk-x1vrdjyk.js.map