@goflag/cli 0.1.0

package/dist/chunk-75OFMTOC.js

@@ -0,0 +1,3719 @@
+#!/usr/bin/env node
+
+// src/report/fingerprint.ts
+import { createHash } from "crypto";
+function routeKey(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    const path = u.pathname.replace(/\/+$/, "") || "/";
+    return `${path}${u.search}`;
+  } catch {
+    return rawUrl;
+  }
+}
+function targetKey(rawUrl) {
+  try {
+    const u = new URL(rawUrl);
+    const path = u.pathname.replace(/\/+$/, "") || "/";
+    return `${u.origin}${path}${u.search}`;
+  } catch {
+    return rawUrl;
+  }
+}
+function fingerprint(category, ...parts) {
+  const digest = createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 10);
+  return `${category}-${digest}`;
+}
+
+// src/lib/core/extract/static.ts
+import * as cheerio from "cheerio";
+
+// src/lib/core/types.ts
+var PAGE_SCHEMA_VERSION = 2;
+
+// src/lib/core/extract/json-ld.ts
+function parseJsonLdScripts(scripts) {
+  const blocks = [];
+  let visibleIndex = 0;
+  for (const s of scripts) {
+    if (s.type?.toLowerCase() !== "application/ld+json") continue;
+    const raw = s.content?.trim() ?? "";
+    if (raw.length === 0) {
+      blocks.push({
+        index: visibleIndex++,
+        raw,
+        data: null,
+        parseError: "empty",
+        types: []
+      });
+      continue;
+    }
+    const decoded = decodeHtmlEntities(raw);
+    let parsed;
+    let parseError;
+    try {
+      parsed = JSON.parse(decoded);
+    } catch (err) {
+      parsed = null;
+      parseError = err instanceof Error ? err.message : String(err);
+    }
+    blocks.push({
+      index: visibleIndex++,
+      raw,
+      data: parsed,
+      parseError,
+      types: parsed === null ? [] : extractTypes(parsed)
+    });
+  }
+  return blocks;
+}
+function extractTypes(node) {
+  const out = /* @__PURE__ */ new Set();
+  visit(node, out);
+  return [...out];
+}
+function visit(node, out) {
+  if (node === null || node === void 0) return;
+  if (Array.isArray(node)) {
+    for (const item of node) visit(item, out);
+    return;
+  }
+  if (typeof node !== "object") return;
+  const obj = node;
+  const t = obj["@type"];
+  if (typeof t === "string") {
+    out.add(t);
+  } else if (Array.isArray(t)) {
+    for (const v of t) {
+      if (typeof v === "string") out.add(v);
+    }
+  }
+  const graph = obj["@graph"];
+  if (Array.isArray(graph)) {
+    for (const item of graph) visit(item, out);
+  }
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "@type" || k === "@graph") continue;
+    if (v && typeof v === "object") visit(v, out);
+  }
+}
+function decodeHtmlEntities(s) {
+  return s.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&#39;", "'").replaceAll("&#x27;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&nbsp;", " ").replaceAll("&amp;", "&");
+}
+
+// src/lib/core/extract/static.ts
+function extractStatic(html, options) {
+  const $ = cheerio.load(html);
+  const base = resolveBase($, options.baseUrl);
+  const raw = extractRaw($);
+  const meta = parseGenericMeta(raw, base);
+  const openGraph = parseOpenGraph(raw);
+  const twitter = parseTwitter(raw);
+  const links = parseLinks(raw, base);
+  const jsonLd = parseJsonLdScripts(raw.scripts);
+  return {
+    schemaVersion: PAGE_SCHEMA_VERSION,
+    raw,
+    meta,
+    openGraph,
+    twitter,
+    links,
+    jsonLd
+  };
+}
+function extractRaw($) {
+  const html = $("html").first();
+  const baseEl = $("head base").first();
+  const head = {
+    title: pickTitle($),
+    htmlLang: attr(html, "lang"),
+    htmlDir: attr(html, "dir"),
+    baseHref: attr(baseEl, "href"),
+    metas: [],
+    links: [],
+    scripts: []
+  };
+  $("meta").each((_, el) => {
+    head.metas.push(toRawMeta($, el));
+  });
+  $("link").each((_, el) => {
+    head.links.push(toRawLink($, el));
+  });
+  $('script[type="application/ld+json"]').each((_, el) => {
+    head.scripts.push(toRawScript($, el));
+  });
+  return head;
+}
+function pickTitle($) {
+  const headTitle = trim($("head title").first().text());
+  if (headTitle) return headTitle;
+  let found;
+  $("title").each((_, el) => {
+    if (found) return;
+    if ($(el).parents("svg").length > 0) return;
+    const text = trim($(el).text());
+    if (text) found = text;
+  });
+  return found || void 0;
+}
+function toRawMeta($, el) {
+  const attributes = collectAttributes($, el);
+  return {
+    name: attributes.name,
+    property: attributes.property,
+    httpEquiv: attributes["http-equiv"],
+    content: attributes.content,
+    charset: attributes.charset,
+    attributes
+  };
+}
+function toRawLink($, el) {
+  const attributes = collectAttributes($, el);
+  return {
+    rel: attributes.rel ?? "",
+    href: attributes.href,
+    hreflang: attributes.hreflang,
+    type: attributes.type,
+    sizes: attributes.sizes,
+    media: attributes.media,
+    crossorigin: attributes.crossorigin,
+    attributes
+  };
+}
+function toRawScript($, el) {
+  const attributes = collectAttributes($, el);
+  return {
+    type: attributes.type,
+    src: attributes.src,
+    content: trim($(el).text()) || void 0,
+    attributes
+  };
+}
+function parseGenericMeta(raw, base) {
+  const meta = {};
+  if (raw.title) {
+    meta.title = sourced(raw.title, { kind: "title" }, raw.title);
+  }
+  for (const m of raw.metas) {
+    const name = m.name?.toLowerCase();
+    if (name === "description" && m.content !== void 0) {
+      meta.description = sourcedMeta(m.content, m);
+    } else if (name === "keywords" && m.content !== void 0) {
+      const list = m.content.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+      meta.keywords = sourcedMeta(list, m);
+    } else if (name === "author" && m.content !== void 0) {
+      meta.author = sourcedMeta(m.content, m);
+    } else if (name === "theme-color" && m.content !== void 0) {
+      meta.themeColor = sourcedMeta(m.content, m);
+    } else if (name === "color-scheme" && m.content !== void 0) {
+      meta.colorScheme = sourcedMeta(m.content, m);
+    } else if (name === "viewport" && m.content !== void 0) {
+      meta.viewport = sourcedMeta(m.content, m);
+    } else if (name === "robots" && m.content !== void 0) {
+      meta.robots = sourcedMeta(m.content, m);
+    } else if (name === "googlebot" && m.content !== void 0) {
+      meta.googlebot = sourcedMeta(m.content, m);
+    } else if (name === "generator" && m.content !== void 0) {
+      meta.generator = sourcedMeta(m.content, m);
+    } else if (name === "referrer" && m.content !== void 0) {
+      meta.referrer = sourcedMeta(m.content, m);
+    } else if (name === "application-name" && m.content !== void 0) {
+      meta.applicationName = sourcedMeta(m.content, m);
+    } else if (m.charset !== void 0) {
+      meta.charset = sourced(m.charset, { kind: "meta", name: "charset" }, m.charset);
+    } else if (m.httpEquiv?.toLowerCase() === "content-type" && m.content !== void 0) {
+      const charset = /charset=([^;]+)/i.exec(m.content)?.[1]?.trim();
+      if (charset && !meta.charset) {
+        meta.charset = sourced(charset, { kind: "meta", httpEquiv: "content-type" }, m.content);
+      }
+    }
+  }
+  for (const l of raw.links) {
+    const rel = l.rel?.toLowerCase();
+    if (rel === "canonical" && l.href) {
+      const resolved = safeResolve(l.href, base);
+      meta.canonical = sourced(resolved, { kind: "link", rel: "canonical" }, l.href);
+    }
+  }
+  return meta;
+}
+function parseOpenGraph(raw) {
+  const og = {
+    localeAlternates: [],
+    images: [],
+    unknown: []
+  };
+  let current;
+  for (const m of raw.metas) {
+    const property = m.property?.toLowerCase();
+    if (!property?.startsWith("og:") || m.content === void 0) continue;
+    const value = m.content;
+    switch (property) {
+      case "og:title":
+        og.title = sourcedMeta(value, m);
+        break;
+      case "og:type":
+        og.type = sourcedMeta(value, m);
+        break;
+      case "og:url":
+        og.url = sourcedMeta(value, m);
+        break;
+      case "og:description":
+        og.description = sourcedMeta(value, m);
+        break;
+      case "og:site_name":
+        og.siteName = sourcedMeta(value, m);
+        break;
+      case "og:locale":
+        og.locale = sourcedMeta(value, m);
+        break;
+      case "og:locale:alternate":
+        og.localeAlternates.push(sourcedMeta(value, m));
+        break;
+      case "og:image":
+      case "og:image:url":
+        current = { url: sourcedMeta(value, m) };
+        og.images.push(current);
+        break;
+      case "og:image:secure_url":
+        if (current) current.secureUrl = sourcedMeta(value, m);
+        break;
+      case "og:image:type":
+        if (current) current.type = sourcedMeta(value, m);
+        break;
+      case "og:image:width": {
+        const n = Number.parseInt(value, 10);
+        if (current && Number.isFinite(n)) current.width = sourcedMeta(n, m);
+        break;
+      }
+      case "og:image:height": {
+        const n = Number.parseInt(value, 10);
+        if (current && Number.isFinite(n)) current.height = sourcedMeta(n, m);
+        break;
+      }
+      case "og:image:alt":
+        if (current) current.alt = sourcedMeta(value, m);
+        break;
+      default:
+        og.unknown.push({ property, value: sourcedMeta(value, m) });
+    }
+  }
+  return og;
+}
+function parseTwitter(raw) {
+  const tw = {};
+  for (const m of raw.metas) {
+    const name = m.name?.toLowerCase();
+    if (!name?.startsWith("twitter:") || m.content === void 0) continue;
+    switch (name) {
+      case "twitter:card":
+        tw.card = sourcedMeta(m.content, m);
+        break;
+      case "twitter:site":
+        tw.site = sourcedMeta(m.content, m);
+        break;
+      case "twitter:creator":
+        tw.creator = sourcedMeta(m.content, m);
+        break;
+      case "twitter:title":
+        tw.title = sourcedMeta(m.content, m);
+        break;
+      case "twitter:description":
+        tw.description = sourcedMeta(m.content, m);
+        break;
+      case "twitter:image":
+      case "twitter:image:src":
+        tw.image = sourcedMeta(m.content, m);
+        break;
+      case "twitter:image:alt":
+        tw.imageAlt = sourcedMeta(m.content, m);
+        break;
+    }
+  }
+  return tw;
+}
+function parseLinks(raw, base) {
+  const out = {
+    alternates: [],
+    icons: [],
+    feeds: [],
+    preconnects: [],
+    dnsPrefetches: []
+  };
+  for (const l of raw.links) {
+    const rel = l.rel.toLowerCase();
+    if (rel === "canonical" && l.href) {
+      out.canonical = safeResolve(l.href, base);
+    } else if (rel === "alternate" && l.hreflang && l.href) {
+      const alt = {
+        hreflang: l.hreflang,
+        href: safeResolve(l.href, base),
+        isXDefault: l.hreflang.toLowerCase() === "x-default"
+      };
+      out.alternates.push(alt);
+    } else if (rel === "alternate" && l.type && l.href && isFeedType(l.type)) {
+      out.feeds.push({
+        rel: "alternate",
+        type: l.type.toLowerCase(),
+        href: safeResolve(l.href, base),
+        title: l.attributes.title
+      });
+    } else if ((rel === "icon" || rel === "apple-touch-icon" || rel === "shortcut icon") && l.href) {
+      const icon = {
+        rel,
+        href: safeResolve(l.href, base),
+        sizes: l.sizes,
+        type: l.type,
+        parsedSizes: parseSizes(l.sizes)
+      };
+      out.icons.push(icon);
+    } else if (rel === "manifest" && l.href) {
+      out.manifest = { href: safeResolve(l.href, base), crossorigin: l.crossorigin };
+    } else if (rel === "preconnect" && l.href) {
+      out.preconnects.push(safeResolve(l.href, base));
+    } else if (rel === "dns-prefetch" && l.href) {
+      out.dnsPrefetches.push(safeResolve(l.href, base));
+    }
+  }
+  return out;
+}
+function isFeedType(type) {
+  const t = type.toLowerCase();
+  return t === "application/rss+xml" || t === "application/atom+xml" || t === "application/feed+json";
+}
+function parseSizes(sizes) {
+  if (!sizes) return [];
+  return sizes.split(/\s+/).filter(Boolean).map((token) => {
+    if (token.toLowerCase() === "any") return "any";
+    const m = /^(\d+)x(\d+)$/i.exec(token);
+    if (!m) return void 0;
+    const w = Number.parseInt(m[1], 10);
+    const h = Number.parseInt(m[2], 10);
+    if (!Number.isFinite(w) || !Number.isFinite(h)) return void 0;
+    return { width: w, height: h };
+  }).filter((v) => v !== void 0);
+}
+function collectAttributes(_$, el) {
+  const result = {};
+  const attribs = el.attribs;
+  if (attribs) {
+    for (const [k, v] of Object.entries(attribs)) {
+      result[k.toLowerCase()] = v;
+    }
+  }
+  return result;
+}
+function attr(el, name) {
+  const v = el.attr(name);
+  return v === void 0 || v === "" ? void 0 : v;
+}
+function trim(s) {
+  return (s ?? "").replace(/\s+/g, " ").trim();
+}
+function resolveBase($, requestUrl) {
+  let base;
+  try {
+    base = new URL(requestUrl);
+  } catch {
+    base = new URL("http://invalid.local/");
+  }
+  const baseHref = $("head base").first().attr("href");
+  if (baseHref) {
+    try {
+      base = new URL(baseHref, base);
+    } catch {
+    }
+  }
+  return base;
+}
+function safeResolve(href, base) {
+  try {
+    return new URL(href, base).toString();
+  } catch {
+    return href;
+  }
+}
+function sourced(value, origin, raw) {
+  return { value, origin, raw };
+}
+function sourcedMeta(value, m) {
+  const origin = m.property ? { kind: "meta", property: m.property } : m.name ? { kind: "meta", name: m.name } : m.httpEquiv ? { kind: "meta", httpEquiv: m.httpEquiv } : { kind: "meta" };
+  return { value, origin, raw: m.content };
+}
+
+// src/lib/core/fetch/static.ts
+var DEFAULT_UA = "Goflag/0.0 (+https://github.com/tancredesimonin-indie/goflag)";
+var FetchError = class extends Error {
+  url;
+  cause;
+  constructor(message, url, options) {
+    super(message);
+    this.name = "FetchError";
+    this.url = url;
+    this.cause = options?.cause;
+  }
+};
+async function fetchStatic(url, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const maxRedirects = options.maxRedirects ?? 10;
+  const userAgent = options.userAgent ?? DEFAULT_UA;
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new FetchError(`Invalid URL: ${url}`, url);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new FetchError(
+      `Unsupported protocol "${parsed.protocol}" \u2014 only http(s) is supported`,
+      url
+    );
+  }
+  const abort = new AbortController();
+  const onCallerAbort = () => abort.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", onCallerAbort, { once: true });
+  const timeout = setTimeout(
+    () => abort.abort(new FetchError("Request timed out", url)),
+    timeoutMs
+  );
+  const restoreTls = relaxTlsIfRequested(options.allowInsecureTls);
+  const start = performance.now();
+  try {
+    let currentUrl = parsed.toString();
+    let redirects = 0;
+    let response;
+    while (true) {
+      try {
+        response = await fetch(currentUrl, {
+          method: "GET",
+          redirect: "manual",
+          headers: {
+            "user-agent": userAgent,
+            accept: "text/html,application/xhtml+xml;q=0.9,*/*;q=0.5"
+          },
+          signal: abort.signal
+        });
+      } catch (err) {
+        throw new FetchError(`Network error fetching ${currentUrl}: ${describe(err)}`, url, {
+          cause: err
+        });
+      }
+      if (isRedirect(response.status)) {
+        const location = response.headers.get("location");
+        if (!location) {
+          throw new FetchError(
+            `Redirect ${response.status} from ${currentUrl} missing Location header`,
+            url
+          );
+        }
+        if (redirects >= maxRedirects) {
+          throw new FetchError(
+            `Exceeded maximum of ${maxRedirects} redirects (last hop: ${currentUrl})`,
+            url
+          );
+        }
+        await response.body?.cancel().catch(() => void 0);
+        currentUrl = new URL(location, currentUrl).toString();
+        redirects += 1;
+        continue;
+      }
+      const body = await response.text();
+      const headers = headersToObject(response.headers);
+      const contentType = stripContentTypeParams(headers["content-type"]);
+      const meta = {
+        requestedUrl: parsed.toString(),
+        finalUrl: currentUrl,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        redirectCount: redirects,
+        durationMs: Math.round(performance.now() - start),
+        bodyBytes: Buffer.byteLength(body, "utf8"),
+        contentType
+      };
+      return { meta, body };
+    }
+  } finally {
+    clearTimeout(timeout);
+    options.signal?.removeEventListener("abort", onCallerAbort);
+    restoreTls();
+  }
+}
+function isRedirect(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function headersToObject(headers) {
+  const out = {};
+  headers.forEach((v, k) => {
+    out[k.toLowerCase()] = v;
+  });
+  return out;
+}
+function stripContentTypeParams(value) {
+  if (!value) return void 0;
+  const semi = value.indexOf(";");
+  return (semi === -1 ? value : value.slice(0, semi)).trim().toLowerCase();
+}
+function relaxTlsIfRequested(enabled) {
+  if (!enabled) return () => void 0;
+  const previous = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  return () => {
+    if (previous === void 0) {
+      delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+    } else {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = previous;
+    }
+  };
+}
+function describe(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+
+// src/lib/core/extract/headless.ts
+var DEFAULT_UA2 = "Goflag/0.0 (+https://github.com/tancredesimonin-indie/goflag; headless)";
+var HeadlessUnavailableError = class extends Error {
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "HeadlessUnavailableError";
+    this.cause = options?.cause;
+  }
+};
+async function extractHeadless(url, options = {}) {
+  const launcher = options.launcher ?? defaultLauncher();
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  const userAgent = options.userAgent ?? DEFAULT_UA2;
+  const waitUntil = options.waitUntil ?? "networkidle";
+  if (options.signal?.aborted) {
+    throw new HeadlessUnavailableError("Headless render cancelled before launch");
+  }
+  const start = performance.now();
+  const browser = await launcher.launch({ allowInsecureTls: options.allowInsecureTls });
+  let page;
+  try {
+    page = await browser.newPage({ userAgent });
+    const nav = await page.goto(url, { waitUntil, timeoutMs });
+    const body = await page.content();
+    const meta = {
+      requestedUrl: url,
+      finalUrl: nav.finalUrl,
+      status: nav.status,
+      statusText: nav.statusText,
+      headers: nav.headers,
+      redirectCount: 0,
+      durationMs: Math.round(performance.now() - start),
+      bodyBytes: Buffer.byteLength(body, "utf8"),
+      contentType: nav.headers["content-type"]?.split(";")[0]?.trim().toLowerCase()
+    };
+    return { renderedHtml: body, fetch: meta };
+  } finally {
+    await page?.close().catch(() => void 0);
+    await browser.close().catch(() => void 0);
+  }
+}
+function defaultLauncher(loader = () => import("playwright")) {
+  return {
+    async launch({ allowInsecureTls }) {
+      let mod;
+      try {
+        mod = await loader();
+      } catch (err) {
+        throw new HeadlessUnavailableError(
+          "Headless mode requires the 'playwright' package. Install it with `pnpm add -D playwright` and `pnpm exec playwright install chromium`.",
+          { cause: err }
+        );
+      }
+      let pw;
+      try {
+        pw = await mod.chromium.launch({
+          headless: true,
+          args: allowInsecureTls ? ["--ignore-certificate-errors"] : []
+        });
+      } catch (err) {
+        throw new HeadlessUnavailableError(
+          "Could not launch Chromium. Install the browser binary with `pnpm exec playwright install chromium`.",
+          { cause: err }
+        );
+      }
+      return {
+        async newPage({ userAgent }) {
+          const ctx = await pw.newContext({
+            userAgent,
+            ignoreHTTPSErrors: !!allowInsecureTls
+          });
+          const p = await ctx.newPage();
+          return {
+            async goto(url, opts) {
+              const response = await p.goto(url, {
+                waitUntil: opts.waitUntil,
+                timeout: opts.timeoutMs
+              });
+              const status = response?.status() ?? 0;
+              const statusText = response?.statusText() ?? "";
+              const headers = response ? await response.allHeaders() : {};
+              return {
+                status,
+                statusText,
+                finalUrl: p.url(),
+                headers
+              };
+            },
+            async content() {
+              return p.content();
+            },
+            async close() {
+              await ctx.close();
+            }
+          };
+        },
+        async close() {
+          await pw.close();
+        }
+      };
+    }
+  };
+}
+
+// src/lib/core/extract/heuristics.ts
+var PLACEHOLDER_TITLES = /* @__PURE__ */ new Set([
+  "react app",
+  "vue app",
+  "vite app",
+  "create react app",
+  "next.js",
+  "nuxt",
+  "angular",
+  "ember",
+  "webpack app",
+  "document",
+  "untitled",
+  ""
+]);
+function looksClientRendered(partial) {
+  const reasons = [];
+  const titleRaw = partial.raw.title?.trim().toLowerCase() ?? "";
+  const titleMissing2 = titleRaw === "";
+  const titlePlaceholder = !titleMissing2 && PLACEHOLDER_TITLES.has(titleRaw);
+  if (titleMissing2) reasons.push("title missing");
+  else if (titlePlaceholder) reasons.push(`placeholder title "${partial.raw.title}"`);
+  const descMissing = partial.meta.description === void 0;
+  if (descMissing) reasons.push("no description");
+  const canonicalMissing2 = partial.meta.canonical === void 0;
+  if (canonicalMissing2) reasons.push("no canonical");
+  const ogMissing = partial.openGraph.title === void 0 && partial.openGraph.description === void 0 && partial.openGraph.images.length === 0 && partial.openGraph.type === void 0 && partial.openGraph.url === void 0 && partial.openGraph.siteName === void 0 && partial.openGraph.unknown.length === 0;
+  if (ogMissing) reasons.push("no og:*");
+  const twitterMissing = partial.twitter.card === void 0 && partial.twitter.title === void 0 && partial.twitter.image === void 0;
+  if (twitterMissing) reasons.push("no twitter:*");
+  const jsonLdMissing = partial.jsonLd.length === 0;
+  if (jsonLdMissing) reasons.push("no JSON-LD");
+  const hreflangMissing2 = partial.links.alternates.length === 0;
+  if (hreflangMissing2) reasons.push("no hreflang");
+  const likely = (titleMissing2 || titlePlaceholder) && descMissing && canonicalMissing2 && ogMissing && twitterMissing && jsonLdMissing && hreflangMissing2;
+  return {
+    likely,
+    reason: reasons.join(", ") || "all metadata present"
+  };
+}
+
+// src/lib/core/extract/hydration.ts
+function computeHydrationDelta(staticPass, renderedPass) {
+  const staticMetaKeys = new Set(staticPass.raw.metas.map(metaKey));
+  const renderedMetaKeys = new Set(renderedPass.raw.metas.map(metaKey));
+  const clientInjectedMetas = renderedPass.raw.metas.filter((m) => !staticMetaKeys.has(metaKey(m))).map(toMetaSummary);
+  const clientRemovedMetas = staticPass.raw.metas.filter((m) => !renderedMetaKeys.has(metaKey(m))).map(toMetaSummary);
+  const staticLinkKeys = new Set(staticPass.raw.links.map(linkKey));
+  const renderedLinkKeys = new Set(renderedPass.raw.links.map(linkKey));
+  const clientInjectedLinks = renderedPass.raw.links.filter((l) => !staticLinkKeys.has(linkKey(l))).map(toLinkSummary);
+  const clientRemovedLinks = staticPass.raw.links.filter((l) => !renderedLinkKeys.has(linkKey(l))).map(toLinkSummary);
+  return {
+    fromMode: "static",
+    toMode: "headless",
+    titleChanged: (staticPass.raw.title ?? "") !== (renderedPass.raw.title ?? ""),
+    htmlLangChanged: (staticPass.raw.htmlLang ?? "") !== (renderedPass.raw.htmlLang ?? ""),
+    clientInjectedMetas,
+    clientRemovedMetas,
+    clientInjectedLinks,
+    clientRemovedLinks,
+    jsonLdBlocksAdded: Math.max(0, renderedPass.jsonLd.length - staticPass.jsonLd.length)
+  };
+}
+function metaKey(m) {
+  return [
+    "n=" + (m.name ?? ""),
+    "p=" + (m.property ?? ""),
+    "he=" + (m.httpEquiv ?? ""),
+    "ch=" + (m.charset ?? ""),
+    "c=" + (m.content ?? "")
+  ].join("|");
+}
+function linkKey(l) {
+  return [
+    "r=" + (l.rel ?? ""),
+    "h=" + (l.href ?? ""),
+    "hl=" + (l.hreflang ?? ""),
+    "t=" + (l.type ?? ""),
+    "s=" + (l.sizes ?? "")
+  ].join("|");
+}
+function toMetaSummary(m) {
+  const out = {};
+  if (m.name) out.name = m.name;
+  if (m.property) out.property = m.property;
+  if (m.httpEquiv) out.httpEquiv = m.httpEquiv;
+  if (m.content !== void 0) out.content = m.content;
+  return out;
+}
+function toLinkSummary(l) {
+  const out = { rel: l.rel };
+  if (l.href !== void 0) out.href = l.href;
+  if (l.hreflang !== void 0) out.hreflang = l.hreflang;
+  return out;
+}
+
+// src/lib/core/probes/abort.ts
+function combineSignals(caller, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  if (!caller) {
+    return { signal: controller.signal, cleanup: () => clearTimeout(timer) };
+  }
+  if (caller.aborted) {
+    controller.abort();
+    return { signal: controller.signal, cleanup: () => clearTimeout(timer) };
+  }
+  const onAbort = () => controller.abort();
+  caller.addEventListener("abort", onAbort, { once: true });
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timer);
+      caller.removeEventListener("abort", onAbort);
+    }
+  };
+}
+
+// src/lib/core/probes/manifest.ts
+async function probeManifest(href, options = {}) {
+  const { signal, cleanup } = combineSignals(options.signal, options.timeoutMs ?? 5e3);
+  try {
+    const res = await fetch(href, { signal, redirect: "follow" });
+    if (!res.ok) return { url: href, status: res.status, found: false };
+    const raw = await res.text();
+    let data;
+    let parseError;
+    try {
+      data = JSON.parse(raw);
+    } catch (err) {
+      parseError = err instanceof Error ? err.message : String(err);
+    }
+    return { url: href, status: res.status, found: true, raw, data, parseError };
+  } catch {
+    return { url: href, status: 0, found: false };
+  } finally {
+    cleanup();
+  }
+}
+
+// src/lib/core/probes/robots.ts
+async function probeRobots(origin, options = {}) {
+  const url = new URL("/robots.txt", origin).toString();
+  const { signal, cleanup } = combineSignals(options.signal, options.timeoutMs ?? 5e3);
+  try {
+    const res = await fetch(url, { signal, redirect: "follow" });
+    if (!res.ok) {
+      return { url, status: res.status, found: false, sitemaps: [], blocksAll: false };
+    }
+    const body = await res.text();
+    return {
+      url,
+      status: res.status,
+      found: true,
+      raw: body,
+      sitemaps: extractSitemaps(body),
+      blocksAll: blocksAllUserAgents(body)
+    };
+  } catch {
+    return { url, status: 0, found: false, sitemaps: [], blocksAll: false };
+  } finally {
+    cleanup();
+  }
+}
+function extractSitemaps(body) {
+  const out = [];
+  for (const line of body.split(/\r?\n/)) {
+    const m = /^\s*Sitemap:\s*(\S+)\s*$/i.exec(line);
+    if (m?.[1]) out.push(m[1]);
+  }
+  return out;
+}
+function blocksAllUserAgents(body) {
+  let inWildcard = false;
+  for (const rawLine of body.split(/\r?\n/)) {
+    const line = rawLine.replace(/#.*$/, "").trim();
+    if (line.length === 0) continue;
+    const ua = /^User-agent:\s*(.+)$/i.exec(line);
+    if (ua) {
+      inWildcard = ua[1].trim() === "*";
+      continue;
+    }
+    if (!inWildcard) continue;
+    const dis = /^Disallow:\s*(.*)$/i.exec(line);
+    if (dis && dis[1].trim() === "/") return true;
+  }
+  return false;
+}
+
+// src/lib/core/probes/sitemap.ts
+async function probeSitemap(origin, options = {}) {
+  const url = new URL("/sitemap.xml", origin).toString();
+  const { signal, cleanup } = combineSignals(options.signal, options.timeoutMs ?? 5e3);
+  try {
+    const res = await fetch(url, { signal, redirect: "follow" });
+    if (!res.ok) return { url, status: res.status, found: false, isIndex: false, entryCount: 0 };
+    const body = await res.text();
+    return {
+      url,
+      status: res.status,
+      found: true,
+      isIndex: /<sitemapindex\b/i.test(body),
+      entryCount: countEntries(body)
+    };
+  } catch {
+    return { url, status: 0, found: false, isIndex: false, entryCount: 0 };
+  } finally {
+    cleanup();
+  }
+}
+function countEntries(body) {
+  const url = body.match(/<url\b/gi)?.length ?? 0;
+  const sm = body.match(/<sitemap\b/gi)?.length ?? 0;
+  return url + sm;
+}
+
+// src/lib/core/inspect.ts
+async function inspect(url, options = {}) {
+  const {
+    probes: enableProbes = true,
+    mode = "auto",
+    headless: headlessOpts,
+    ...fetchOptions
+  } = options;
+  const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (mode === "headless") {
+    return inspectHeadlessOnly({
+      url,
+      fetchedAt,
+      enableProbes,
+      fetchOptions,
+      headlessOpts
+    });
+  }
+  const { meta: staticMeta, body: staticBody } = await fetchStatic(url, fetchOptions);
+  const staticParsed = extractStatic(staticBody, { baseUrl: staticMeta.finalUrl });
+  if (mode === "static") {
+    const probes2 = await runProbes({
+      enabled: enableProbes,
+      origin: new URL(staticMeta.finalUrl).origin,
+      manifestHref: staticParsed.links.manifest?.href,
+      signal: fetchOptions.signal
+    });
+    return {
+      ...staticParsed,
+      fetchedAt,
+      fetch: staticMeta,
+      extractor: { mode: "static", escalated: false },
+      html: { static: staticBody },
+      probes: probes2
+    };
+  }
+  const heuristic = looksClientRendered(staticParsed);
+  if (!heuristic.likely) {
+    const probes2 = await runProbes({
+      enabled: enableProbes,
+      origin: new URL(staticMeta.finalUrl).origin,
+      manifestHref: staticParsed.links.manifest?.href,
+      signal: fetchOptions.signal
+    });
+    return {
+      ...staticParsed,
+      fetchedAt,
+      fetch: staticMeta,
+      extractor: { mode: "static", escalated: false },
+      html: { static: staticBody },
+      probes: probes2
+    };
+  }
+  let renderedBody;
+  let renderedFetch;
+  try {
+    const result = await extractHeadless(url, {
+      ...headlessOpts,
+      allowInsecureTls: fetchOptions.allowInsecureTls,
+      signal: fetchOptions.signal
+    });
+    renderedBody = result.renderedHtml;
+    renderedFetch = result.fetch;
+  } catch (err) {
+    if (!(err instanceof HeadlessUnavailableError)) throw err;
+    const probes2 = await runProbes({
+      enabled: enableProbes,
+      origin: new URL(staticMeta.finalUrl).origin,
+      manifestHref: staticParsed.links.manifest?.href,
+      signal: fetchOptions.signal
+    });
+    return {
+      ...staticParsed,
+      fetchedAt,
+      fetch: staticMeta,
+      extractor: {
+        mode: "static",
+        escalated: false,
+        escalationReason: `would-have-escalated (${heuristic.reason}) but ${err.message}`
+      },
+      html: { static: staticBody },
+      probes: probes2
+    };
+  }
+  const renderedParsed = extractStatic(renderedBody, { baseUrl: renderedFetch.finalUrl });
+  const hydration = computeHydrationDelta(staticParsed, renderedParsed);
+  const probes = await runProbes({
+    enabled: enableProbes,
+    origin: new URL(renderedFetch.finalUrl).origin,
+    manifestHref: renderedParsed.links.manifest?.href,
+    signal: fetchOptions.signal
+  });
+  return {
+    ...renderedParsed,
+    fetchedAt,
+    fetch: renderedFetch,
+    extractor: {
+      mode: "headless",
+      escalated: true,
+      escalationReason: heuristic.reason
+    },
+    html: { static: staticBody, rendered: renderedBody },
+    hydration,
+    probes
+  };
+}
+async function inspectHeadlessOnly(args) {
+  const { url, fetchedAt, enableProbes, fetchOptions, headlessOpts } = args;
+  const result = await extractHeadless(url, {
+    ...headlessOpts,
+    allowInsecureTls: fetchOptions.allowInsecureTls,
+    signal: fetchOptions.signal
+  });
+  const parsed = extractStatic(result.renderedHtml, { baseUrl: result.fetch.finalUrl });
+  const probes = await runProbes({
+    enabled: enableProbes,
+    origin: new URL(result.fetch.finalUrl).origin,
+    manifestHref: parsed.links.manifest?.href,
+    signal: fetchOptions.signal
+  });
+  return {
+    ...parsed,
+    fetchedAt,
+    fetch: result.fetch,
+    extractor: { mode: "headless", escalated: false },
+    html: { static: "", rendered: result.renderedHtml },
+    probes
+  };
+}
+async function runProbes(args) {
+  if (!args.enabled) return {};
+  const [robots, sitemap, manifest] = await Promise.all([
+    probeRobots(args.origin, { signal: args.signal }),
+    probeSitemap(args.origin, { signal: args.signal }),
+    args.manifestHref ? probeManifest(args.manifestHref, { signal: args.signal }) : Promise.resolve(void 0)
+  ]);
+  const probes = { robots, sitemap };
+  if (manifest) probes.manifest = manifest;
+  return probes;
+}
+
+// src/lib/core/glob.ts
+var cache = /* @__PURE__ */ new Map();
+function compileGlob(pattern) {
+  const cached = cache.get(pattern);
+  if (cached) return cached;
+  let re = "^";
+  let i = 0;
+  while (i < pattern.length) {
+    const c = pattern[i];
+    if (c === "*") {
+      if (pattern[i + 1] === "*") {
+        re += ".*";
+        i += 2;
+        continue;
+      }
+      re += "[^/]*";
+      i += 1;
+      continue;
+    }
+    if (c === "?") {
+      re += "[^/]";
+      i += 1;
+      continue;
+    }
+    if (/[.+^${}()|\\[\]/]/.test(c)) {
+      re += `\\${c}`;
+    } else {
+      re += c;
+    }
+    i += 1;
+  }
+  re += "$";
+  const compiled = new RegExp(re);
+  cache.set(pattern, compiled);
+  return compiled;
+}
+function matchesAny(value, patterns) {
+  for (const p of patterns) {
+    if (compileGlob(p).test(value)) return true;
+  }
+  return false;
+}
+
+// src/lib/core/discover.ts
+var ANCHOR_HREF_RE = /<a\b[^>]*?\bhref\s*=\s*("([^"]*)"|'([^']*)')/gi;
+function extractCandidateLinks(page) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const base = page.fetch.finalUrl;
+  for (const alt of page.links.alternates) {
+    push(out, seen, alt.href, "hreflang");
+  }
+  for (const link of page.raw.links) {
+    const rel = link.rel.toLowerCase();
+    if ((rel === "next" || rel === "prev") && link.href) {
+      push(out, seen, link.href, "head-link");
+    }
+  }
+  if (page.html.static) {
+    for (const match of page.html.static.matchAll(ANCHOR_HREF_RE)) {
+      const raw = match[2] ?? match[3];
+      if (!raw) continue;
+      const trimmed = raw.trim();
+      if (!trimmed) continue;
+      let absolute;
+      try {
+        absolute = new URL(trimmed, base).toString();
+      } catch {
+        continue;
+      }
+      push(out, seen, absolute, "body-anchor");
+    }
+  }
+  return out;
+}
+function push(out, seen, href, source) {
+  if (seen.has(href)) return;
+  seen.add(href);
+  out.push({ href, source });
+}
+
+// src/lib/core/crawl.ts
+async function crawl(options) {
+  const depthLimit = options.depth ?? 1;
+  const concurrency = Math.max(1, options.concurrency ?? 4);
+  const maxPages = Math.max(1, options.maxPages ?? 200);
+  const followHreflang = options.followHreflang !== false;
+  const include = options.include ?? [];
+  const exclude = options.exclude ?? [];
+  const entry = canonicaliseUrl(options.entryUrl);
+  if (!entry) {
+    return {
+      pages: [],
+      visited: [],
+      errors: [{ url: options.entryUrl, message: "entry URL is not a valid http(s) URL" }],
+      truncated: false
+    };
+  }
+  const origin = new URL(entry).origin;
+  const visitedSet = /* @__PURE__ */ new Set([entry]);
+  const queue = [{ url: entry, depth: 0 }];
+  for (const seed of options.seedUrls ?? []) {
+    const normalised = canonicaliseUrl(seed);
+    if (!normalised || visitedSet.has(normalised)) continue;
+    if (new URL(normalised).origin !== origin) continue;
+    visitedSet.add(normalised);
+    queue.push({ url: normalised, depth: 0 });
+  }
+  const pages = [];
+  const errors = [];
+  let truncated = false;
+  while (queue.length > 0) {
+    if (options.inspectOptions?.signal?.aborted) break;
+    const wave = queue.splice(0, concurrency);
+    const inspections = wave.map(async (item) => {
+      try {
+        const page = await inspect(item.url, options.inspectOptions);
+        return { kind: "ok", item, page };
+      } catch (err) {
+        return {
+          kind: "err",
+          item,
+          error: err instanceof Error ? err.message : String(err)
+        };
+      }
+    });
+    const results = await Promise.all(inspections);
+    for (const result of results) {
+      if (result.kind === "err") {
+        errors.push({ url: result.item.url, message: result.error });
+        continue;
+      }
+      pages.push(result.page);
+      if (options.onPage) {
+        options.onPage(result.page, { visited: pages.length, queued: queue.length });
+      }
+      if (pages.length >= maxPages) {
+        truncated = true;
+        break;
+      }
+      if (result.item.depth >= depthLimit) continue;
+      const candidates = extractCandidateLinks(result.page);
+      for (const candidate of candidates) {
+        const normalised = canonicaliseUrl(candidate.href, result.page.fetch.finalUrl);
+        if (!normalised) continue;
+        if (visitedSet.has(normalised)) continue;
+        const parsed = new URL(normalised);
+        if (parsed.origin !== origin) continue;
+        const passesIncludeExclude = filterAllows(parsed.pathname, include, exclude);
+        const isHreflang = candidate.source === "hreflang";
+        if (!passesIncludeExclude && !(followHreflang && isHreflang)) continue;
+        visitedSet.add(normalised);
+        queue.push({ url: normalised, depth: result.item.depth + 1 });
+      }
+    }
+    if (truncated) break;
+  }
+  return {
+    pages,
+    visited: [...visitedSet],
+    errors,
+    truncated
+  };
+}
+function filterAllows(pathname, include, exclude) {
+  if (exclude.length > 0 && matchesAny(pathname, exclude)) return false;
+  if (include.length === 0) return true;
+  return matchesAny(pathname, include);
+}
+function canonicaliseUrl(href, base, options = {}) {
+  let url;
+  try {
+    url = new URL(href, base);
+  } catch {
+    return null;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+  url.hash = "";
+  if (!options.preserveTrailingSlash && url.pathname.length > 1 && url.pathname.endsWith("/")) {
+    url.pathname = url.pathname.slice(0, -1);
+  }
+  return url.toString();
+}
+
+// src/lib/rules/index.ts
+var TITLE_MIN = 10;
+var TITLE_MAX = 60;
+var DESC_MIN = 50;
+var DESC_MAX = 160;
+function tokens(value) {
+  if (!value) return [];
+  return value.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean);
+}
+var titleMissing = {
+  id: "title.missing",
+  severity: "error",
+  summary: "Every page needs a non-empty `<title>`",
+  check: ({ page, issue }) => {
+    const t = page.meta.title?.value?.trim();
+    if (t && t.length > 0) return;
+    return issue({
+      message: "Page is missing a `<title>` element (or it is empty).",
+      origin: { kind: "title" },
+      fix: {
+        title: "Add a <title> to <head>",
+        snippet: [
+          "// app/\u2026/page.tsx \u2014 App Router owns the <head>; never hand-write the tag.",
+          'export const metadata = { title: "Page name \u2014 Site name" };'
+        ].join("\n"),
+        language: "tsx"
+      }
+    });
+  }
+};
+var titleLength = {
+  id: "title.length",
+  severity: "warning",
+  summary: `Keep \`<title>\` between ${TITLE_MIN} and ${TITLE_MAX} characters`,
+  check: ({ page, issue }) => {
+    const t = page.meta.title?.value?.trim();
+    if (!t) return;
+    if (t.length >= TITLE_MIN && t.length <= TITLE_MAX) return;
+    const direction = t.length < TITLE_MIN ? "short" : "long";
+    return issue({
+      message: `Title is ${t.length} characters \u2014 ${direction} of the recommended ${TITLE_MIN}\u2013${TITLE_MAX} window.`,
+      origin: { kind: "title" }
+    });
+  }
+};
+var descriptionMissing = {
+  id: "description.missing",
+  severity: "warning",
+  summary: 'Provide a `<meta name="description">` on every indexable page',
+  check: ({ page, issue }) => {
+    const d = page.meta.description?.value?.trim();
+    if (d && d.length > 0) return;
+    return issue({
+      message: 'Page has no `<meta name="description">`.',
+      origin: { kind: "meta", name: "description" },
+      fix: {
+        title: "Add a meta description",
+        snippet: [
+          "// app/\u2026/page.tsx",
+          "export const metadata = {",
+          '  description: "One sentence that promises what this page delivers.",',
+          "};"
+        ].join("\n"),
+        language: "tsx"
+      }
+    });
+  }
+};
+var descriptionLength = {
+  id: "description.length",
+  severity: "warning",
+  summary: `Keep descriptions between ${DESC_MIN} and ${DESC_MAX} characters`,
+  check: ({ page, issue }) => {
+    const d = page.meta.description?.value?.trim();
+    if (!d) return;
+    if (d.length >= DESC_MIN && d.length <= DESC_MAX) return;
+    const direction = d.length < DESC_MIN ? "short" : "long";
+    return issue({
+      message: `Description is ${d.length} characters \u2014 ${direction} of the recommended ${DESC_MIN}\u2013${DESC_MAX} window.`,
+      origin: { kind: "meta", name: "description" }
+    });
+  }
+};
+var canonicalMissing = {
+  id: "canonical.missing",
+  severity: "warning",
+  summary: 'Declare a `<link rel="canonical">` so search engines pick the right URL',
+  check: ({ page, issue }) => {
+    if (page.links.canonical) return;
+    return issue({
+      message: 'Page is missing `<link rel="canonical">`.',
+      origin: { kind: "link", rel: "canonical" },
+      fix: {
+        title: "Declare the canonical URL",
+        snippet: [
+          "// app/\u2026/page.tsx \u2014 relative canonicals resolve against metadataBase,",
+          "// which defaults to localhost and silently breaks in production.",
+          "export const metadata = {",
+          "  metadataBase: new URL(process.env.NEXT_PUBLIC_SITE_URL!),",
+          '  alternates: { canonical: "/the-page" },',
+          "};"
+        ].join("\n"),
+        language: "tsx"
+      }
+    });
+  }
+};
+var canonicalAbsolute = {
+  id: "canonical.absolute",
+  severity: "error",
+  summary: '`rel="canonical"` must be an absolute, fully-qualified URL',
+  check: ({ page, issue }) => {
+    const link = page.raw.links.find((l) => l.rel.toLowerCase() === "canonical");
+    const raw = link?.href?.trim();
+    if (!raw) return;
+    if (/^https?:\/\//i.test(raw)) return;
+    return issue({
+      message: `Canonical is "${raw}" \u2014 must be an absolute http(s) URL (consumers see the raw value, not the resolved "${page.links.canonical ?? raw}").`,
+      origin: { kind: "link", rel: "canonical" }
+    });
+  }
+};
+var viewportMissing = {
+  id: "viewport.missing",
+  severity: "warning",
+  summary: 'Declare a `<meta name="viewport">` so mobile browsers render at the right scale',
+  check: ({ page, issue }) => {
+    const v = page.meta.viewport?.value?.trim();
+    if (v && v.length > 0) return;
+    return issue({
+      message: 'Page has no `<meta name="viewport">` \u2014 mobile browsers will render at desktop width.',
+      origin: { kind: "meta", name: "viewport" },
+      fix: {
+        title: "Add a viewport meta",
+        snippet: [
+          "// app/layout.tsx \u2014 a dedicated export, not part of `metadata`.",
+          'export const viewport = { width: "device-width", initialScale: 1 };'
+        ].join("\n"),
+        language: "tsx"
+      }
+    });
+  }
+};
+var ogTitleMissing = {
+  id: "og.title.missing",
+  severity: "warning",
+  summary: "Set an explicit `og:title` instead of relying on `<title>` fallback",
+  check: ({ page, issue }) => {
+    if (page.openGraph.title?.value?.trim()) return;
+    return issue({
+      message: "Page has no `og:title`; consumers will fall back to `<title>` (or nothing).",
+      origin: { kind: "meta", property: "og:title" }
+    });
+  }
+};
+var ogDescriptionMissing = {
+  id: "og.description.missing",
+  severity: "info",
+  summary: "Set an explicit `og:description` for richer link unfurls",
+  check: ({ page, issue }) => {
+    if (page.openGraph.description?.value?.trim()) return;
+    const hasOtherOg = Boolean(
+      page.openGraph.title?.value || page.openGraph.images.length > 0 || page.openGraph.url?.value
+    );
+    if (!hasOtherOg) return;
+    return issue({
+      message: "Page has `og:*` tags but no `og:description`; unfurls will fall back to the meta description (or nothing).",
+      origin: { kind: "meta", property: "og:description" }
+    });
+  }
+};
+var ogImageMissing = {
+  id: "og.image.missing",
+  severity: "warning",
+  summary: "Provide at least one `og:image` so links unfurl with a preview",
+  check: ({ page, issue }) => {
+    if (page.openGraph.images.length > 0) return;
+    return issue({
+      message: "Page has no `og:image`. Link unfurls will fall back to text-only or a random body image.",
+      origin: { kind: "meta", property: "og:image" },
+      fix: {
+        title: "Add an og:image",
+        snippet: [
+          "// app/\u2026/page.tsx",
+          "export const metadata = {",
+          '  openGraph: { images: [{ url: "/og.png", width: 1200, height: 630 }] },',
+          "};",
+          "// Or generate one per page: app/\u2026/opengraph-image.tsx with ImageResponse."
+        ].join("\n"),
+        language: "tsx"
+      }
+    });
+  }
+};
+var robotsConflict = {
+  id: "robots.conflict",
+  severity: "error",
+  summary: "`robots`, `googlebot`, and `X-Robots-Tag` must not contradict each other",
+  check: ({ page, issue }) => {
+    const issues = [];
+    const metaRobots = new Set(tokens(page.meta.robots?.value));
+    const metaGoogle = new Set(tokens(page.meta.googlebot?.value));
+    const header = new Set(tokens(page.fetch.headers["x-robots-tag"]));
+    const allSources = [
+      { name: "meta robots", tokens: metaRobots, origin: { kind: "meta", name: "robots" } },
+      { name: "meta googlebot", tokens: metaGoogle, origin: { kind: "meta", name: "googlebot" } },
+      {
+        name: "X-Robots-Tag header",
+        tokens: header,
+        origin: { kind: "header", name: "x-robots-tag" }
+      }
+    ];
+    const sources = allSources.filter((s) => s.tokens.size > 0);
+    if (sources.length < 2) return [];
+    const indexers = sources.filter((s) => s.tokens.has("index") && !s.tokens.has("noindex"));
+    const noindexers = sources.filter((s) => s.tokens.has("noindex"));
+    if (indexers.length > 0 && noindexers.length > 0) {
+      issues.push(
+        issue({
+          message: `Conflicting indexing directives: ${noindexers.map((s) => s.name).join(", ")} say \`noindex\`, ${indexers.map((s) => s.name).join(", ")} say \`index\`.`,
+          origin: noindexers[0].origin
+        })
+      );
+    }
+    const followers = sources.filter((s) => s.tokens.has("follow") && !s.tokens.has("nofollow"));
+    const nofollowers = sources.filter((s) => s.tokens.has("nofollow"));
+    if (followers.length > 0 && nofollowers.length > 0) {
+      issues.push(
+        issue({
+          message: `Conflicting follow directives: ${nofollowers.map((s) => s.name).join(", ")} say \`nofollow\`, ${followers.map((s) => s.name).join(", ")} say \`follow\`.`,
+          origin: nofollowers[0].origin
+        })
+      );
+    }
+    return issues;
+  }
+};
+var RULES = [
+  canonicalAbsolute,
+  canonicalMissing,
+  descriptionLength,
+  descriptionMissing,
+  ogDescriptionMissing,
+  ogImageMissing,
+  ogTitleMissing,
+  robotsConflict,
+  titleLength,
+  titleMissing,
+  viewportMissing
+];
+var RULE_BY_ID = new Map(RULES.map((r) => [r.id, r]));
+function getRule(id) {
+  return RULE_BY_ID.get(id);
+}
+
+// src/lib/core/lint.ts
+var SEVERITY_RANK = {
+  error: 0,
+  warning: 1,
+  info: 2
+};
+function lint(page, rules = RULES) {
+  const issues = [];
+  for (const rule of rules) {
+    if (rule.appliesTo && !rule.appliesTo(page)) continue;
+    let result;
+    try {
+      result = rule.check({
+        page,
+        issue: (input) => ({
+          ruleId: rule.id,
+          severity: input.severity ?? rule.severity,
+          message: input.message,
+          origin: input.origin,
+          fix: input.fix,
+          suggestion: input.suggestion
+        })
+      });
+    } catch (err) {
+      issues.push({
+        ruleId: "engine.rule-crashed",
+        severity: "info",
+        message: `Rule \`${rule.id}\` threw: ${err instanceof Error ? err.message : String(err)}`
+      });
+      continue;
+    }
+    if (!result) continue;
+    if (Array.isArray(result)) issues.push(...result);
+    else issues.push(result);
+  }
+  return sortIssues(issues);
+}
+function sortIssues(issues) {
+  return [...issues].sort((a, b) => {
+    const sev = SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity];
+    if (sev !== 0) return sev;
+    return a.ruleId.localeCompare(b.ruleId);
+  });
+}
+
+// src/lib/core/i18n.ts
+var BCP47_LOOSE = /^[a-z]{2,3}(-[a-z]{2}|-\d{3})?$/i;
+function looksLikeLocaleSegment(segment) {
+  return BCP47_LOOSE.test(segment);
+}
+function isValidLocale(tag) {
+  if (tag === "x-default") return true;
+  return BCP47_LOOSE.test(tag);
+}
+function buildI18nMatrix(pages, options = {}) {
+  const inspectedByUrl = /* @__PURE__ */ new Map();
+  for (const page of pages) inspectedByUrl.set(page.fetch.finalUrl, page);
+  const grid = /* @__PURE__ */ new Map();
+  const locales = /* @__PURE__ */ new Set();
+  const routes = /* @__PURE__ */ new Set();
+  for (const locale of options.locales ?? []) {
+    const tag = locale.trim().toLowerCase();
+    if (tag) locales.add(tag);
+  }
+  function record(route, locale, url) {
+    routes.add(route);
+    locales.add(locale);
+    let row = grid.get(route);
+    if (!row) {
+      row = /* @__PURE__ */ new Map();
+      grid.set(route, row);
+    }
+    if (!row.has(locale)) {
+      row.set(locale, { url, inspected: inspectedByUrl.has(url) });
+    }
+  }
+  for (const page of pages) {
+    const url = new URL(page.fetch.finalUrl);
+    const { route: selfRoute, locale: selfLocale } = splitRoute(url.pathname);
+    record(selfRoute, selfLocale, page.fetch.finalUrl);
+    for (const alt of page.links.alternates) {
+      let altUrl;
+      try {
+        altUrl = new URL(alt.href);
+      } catch {
+        continue;
+      }
+      const { route } = splitRoute(altUrl.pathname);
+      const locale = alt.isXDefault ? "x-default" : alt.hreflang;
+      record(route || selfRoute, locale, altUrl.toString());
+    }
+  }
+  for (const declared of options.declaredUrls ?? []) {
+    let url;
+    try {
+      url = new URL(declared);
+    } catch {
+      continue;
+    }
+    const { route, locale } = splitRoute(url.pathname);
+    record(route, locale, url.toString());
+  }
+  const sortedLocales = sortLocales([...locales]);
+  const sortedRoutes = [...routes].sort((a, b) => a.localeCompare(b));
+  const cells = {};
+  for (const route of sortedRoutes) {
+    cells[route] = {};
+    for (const locale of sortedLocales) {
+      const slot = grid.get(route)?.get(locale);
+      cells[route][locale] = slot ? { url: slot.url, inspected: slot.inspected } : { url: null, inspected: false };
+    }
+  }
+  return { locales: sortedLocales, routes: sortedRoutes, cells };
+}
+function reciprocityIssues(pages) {
+  const issues = [];
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const page of pages) byUrl.set(page.fetch.finalUrl, page);
+  for (const page of pages) {
+    const url = page.fetch.finalUrl;
+    const seenLocalesOnPage = /* @__PURE__ */ new Set();
+    for (const alt of page.links.alternates) {
+      const locale = alt.isXDefault ? "x-default" : alt.hreflang;
+      seenLocalesOnPage.add(locale);
+      if (!isValidLocale(locale)) {
+        issues.push({
+          code: "locale.invalid",
+          url,
+          locale,
+          message: `\`hreflang="${locale}"\` is not a valid BCP 47 tag.`
+        });
+        continue;
+      }
+      let altUrl;
+      try {
+        altUrl = new URL(alt.href).toString();
+      } catch {
+        continue;
+      }
+      const peer = byUrl.get(altUrl);
+      if (!peer) continue;
+      const back = peer.links.alternates.find((p) => {
+        let peerHref;
+        try {
+          peerHref = new URL(p.href).toString();
+        } catch {
+          return false;
+        }
+        return peerHref === url;
+      });
+      if (!back) {
+        issues.push({
+          code: "missing-back-link",
+          url,
+          peerUrl: altUrl,
+          locale,
+          message: `\`${url}\` declares an alternate to \`${altUrl}\` but the peer does not link back.`
+        });
+      }
+    }
+    const nonDefaultLocales = [...seenLocalesOnPage].filter((l) => l !== "x-default");
+    if (nonDefaultLocales.length >= 2 && !seenLocalesOnPage.has("x-default")) {
+      issues.push({
+        code: "x-default-missing",
+        url,
+        message: `Page advertises ${nonDefaultLocales.length} locales but no \`hreflang="x-default"\`.`
+      });
+    }
+  }
+  return dedupeBy(
+    issues,
+    (i) => `${i.code}\0${i.url}\0${i.peerUrl ?? ""}\0${i.locale ?? ""}`
+  );
+}
+function dedupeBy(items, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    const k = key(item);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(item);
+  }
+  return out;
+}
+function splitRoute(pathname) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length > 0 && looksLikeLocaleSegment(segments[0])) {
+    const locale = segments[0];
+    const rest = segments.slice(1).join("/");
+    return { route: rest ? `/${rest}` : "/", locale };
+  }
+  return { route: pathname || "/", locale: "x-default" };
+}
+function sortLocales(locales) {
+  const xDefault = locales.includes("x-default") ? ["x-default"] : [];
+  const rest = locales.filter((l) => l !== "x-default").sort((a, b) => a.localeCompare(b));
+  return [...xDefault, ...rest];
+}
+
+// src/lib/rules/site-rules.ts
+function isMultilingual(site) {
+  return site.localeAxis.multilingual;
+}
+function declaredLocales(page) {
+  const out = /* @__PURE__ */ new Set();
+  for (const alt of page.links.alternates) {
+    if (alt.isXDefault) continue;
+    const tag = alt.hreflang?.trim().toLowerCase();
+    if (tag) out.add(tag);
+  }
+  return out;
+}
+function sitemapLocalesByRoute(site) {
+  const byRoute = /* @__PURE__ */ new Map();
+  for (const entry of site.discovery?.urls ?? []) {
+    let pathname;
+    try {
+      pathname = new URL(entry.loc).pathname;
+    } catch {
+      continue;
+    }
+    const { route, locale } = splitRoute(pathname);
+    if (locale === "x-default") continue;
+    const set = byRoute.get(route) ?? /* @__PURE__ */ new Set();
+    set.add(locale.toLowerCase());
+    byRoute.set(route, set);
+  }
+  return byRoute;
+}
+function sorted(set) {
+  return [...set].sort((a, b) => a.localeCompare(b));
+}
+var hreflangMissing = {
+  id: "hreflang.missing",
+  severity: "error",
+  summary: "Pages on a multilingual site must advertise their locale alternates",
+  appliesTo: isMultilingual,
+  check: ({ site, issue }) => {
+    const locales = site.localeAxis.locales.join(", ");
+    return site.pages.filter((page) => page.links.alternates.length === 0).map(
+      (page) => issue({
+        pageUrl: page.fetch.finalUrl,
+        message: `Page declares no \`hreflang\` alternates, but the site serves ${site.localeAxis.locales.length} locales (${locales}, per the ${site.localeAxis.source}). Locale variants of this route cannot be associated with each other.`,
+        origin: { kind: "link", rel: "alternate" },
+        fix: {
+          title: "Emit alternates from generateMetadata()",
+          snippet: [
+            "// app/[locale]/\u2026/page.tsx",
+            "export async function generateMetadata({ params }) {",
+            "  const { locale } = await params;",
+            "  return {",
+            "    alternates: {",
+            "      canonical: `${baseUrl}/${locale}${path}`,",
+            "      languages: {",
+            ...site.localeAxis.locales.map(
+              (l) => `        "${l}": \`\${baseUrl}/${l}\${path}\`,`
+            ),
+            '        "x-default": `${baseUrl}/${defaultLocale}${path}`,',
+            "      },",
+            "    },",
+            "  };",
+            "}"
+          ].join("\n"),
+          language: "tsx"
+        }
+      })
+    );
+  }
+};
+var hreflangSitemapMismatch = {
+  id: "hreflang.sitemap-mismatch",
+  severity: "warning",
+  summary: "`<head>` alternates and sitemap locale coverage must agree",
+  appliesTo: (site) => isMultilingual(site) && (site.discovery?.urls.length ?? 0) > 0,
+  check: ({ site, issue }) => {
+    const bySitemap = sitemapLocalesByRoute(site);
+    const findings = [];
+    for (const page of site.pages) {
+      const head = declaredLocales(page);
+      if (head.size === 0) continue;
+      let pathname;
+      try {
+        pathname = new URL(page.fetch.finalUrl).pathname;
+      } catch {
+        continue;
+      }
+      const { route } = splitRoute(pathname);
+      const inSitemap = bySitemap.get(route);
+      if (!inSitemap || inSitemap.size === 0) continue;
+      const onlyInSitemap = sorted(new Set([...inSitemap].filter((l) => !head.has(l))));
+      const onlyInHead = sorted(new Set([...head].filter((l) => !inSitemap.has(l))));
+      if (onlyInSitemap.length === 0 && onlyInHead.length === 0) continue;
+      const parts = [];
+      if (onlyInSitemap.length > 0) {
+        parts.push(
+          `the sitemap lists ${onlyInSitemap.join(", ")} but the \`<head>\` does not advertise ${onlyInSitemap.length > 1 ? "them" : "it"}`
+        );
+      }
+      if (onlyInHead.length > 0) {
+        parts.push(
+          `the \`<head>\` advertises ${onlyInHead.join(", ")} but the sitemap has no entry for ${onlyInHead.length > 1 ? "them" : "it"}`
+        );
+      }
+      findings.push(
+        issue({
+          pageUrl: page.fetch.finalUrl,
+          message: `Route \`${route}\`: ${parts.join("; ")}. Both are derived from the same intent and must not disagree.`,
+          origin: { kind: "link", rel: "alternate" },
+          fix: {
+            title: "Derive both from one locale-availability source",
+            snippet: [
+              "// Compute availability once, feed both the <head> and the sitemap.",
+              "const localesFor = (slug: string) =>",
+              "  allDocs.filter((d) => d.slug === slug && !d.draft).map((d) => d.locale);",
+              "",
+              "// generateMetadata(): alternates.languages \u2190 localesFor(slug)",
+              "// sitemap.ts:        alternates.languages \u2190 localesFor(slug)"
+            ].join("\n"),
+            language: "ts"
+          }
+        })
+      );
+    }
+    return findings;
+  }
+};
+function metaRobotsTokens(page) {
+  const raw = page.meta.robots?.value ?? "";
+  return new Set(
+    raw.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean)
+  );
+}
+var robotsBlocksSite = {
+  id: "robots.blocks-site",
+  severity: "error",
+  summary: "`robots.txt` must not forbid crawling a site that asks to be indexed",
+  appliesTo: (site) => site.robots?.found === true && site.robots.blocksAll,
+  check: ({ site, issue }) => {
+    const robotsUrl = site.robots?.url ?? `${site.origin}/robots.txt`;
+    const asking = site.pages.filter((page) => metaRobotsTokens(page).has("index"));
+    const detail = asking.length ? `but ${asking.length} crawled page${asking.length === 1 ? "" : "s"} declare \`<meta name="robots" content="index">\`. Both cannot be true: robots.txt wins, so the pages are never fetched and the meta tag is never read.` : "so no search engine will crawl any page on this origin. If this is a staging or preview environment, that is correct \u2014 otherwise the site is invisible.";
+    return issue({
+      pageUrl: robotsUrl,
+      severity: asking.length > 0 ? "error" : "warning",
+      message: `\`robots.txt\` disallows the whole site for \`User-agent: *\`, ${detail}`,
+      origin: { kind: "computed" },
+      fix: {
+        title: "Gate the disallow on the deployed environment",
+        snippet: [
+          "// app/robots.ts \u2014 the flag must be readable at build AND at runtime,",
+          "// or a production container silently serves the staging rules.",
+          'const isProduction = process.env.APP_ENV === "production";',
+          "",
+          "export default function robots(): MetadataRoute.Robots {",
+          '  if (!isProduction) return { rules: { userAgent: "*", disallow: "/" } };',
+          "  return {",
+          '    rules: { userAgent: "*", allow: "/", disallow: ["/api/", "/_next/"] },',
+          "    sitemap: `${baseUrl}/sitemap.xml`,",
+          "  };",
+          "}"
+        ].join("\n"),
+        language: "ts"
+      }
+    });
+  }
+};
+var SITE_RULES = [
+  hreflangMissing,
+  hreflangSitemapMismatch,
+  robotsBlocksSite
+];
+function getSiteRule(id) {
+  return SITE_RULES.find((rule) => rule.id === id);
+}
+
+// src/lib/core/lint-site.ts
+function lintSite(site, rules = SITE_RULES) {
+  const drafts = [];
+  for (const rule of rules) {
+    if (rule.appliesTo && !rule.appliesTo(site)) continue;
+    let result;
+    try {
+      result = rule.check({
+        site,
+        issue: (input) => ({
+          ruleId: rule.id,
+          severity: input.severity ?? rule.severity,
+          message: input.message,
+          origin: input.origin,
+          fix: input.fix,
+          suggestion: input.suggestion,
+          pageUrl: input.pageUrl
+        })
+      });
+    } catch (err) {
+      drafts.push({
+        ruleId: "engine.site-rule-crashed",
+        severity: "info",
+        message: `Site rule \`${rule.id}\` threw: ${err instanceof Error ? err.message : String(err)}`,
+        pageUrl: site.origin
+      });
+      continue;
+    }
+    if (!result) continue;
+    if (Array.isArray(result)) drafts.push(...result);
+    else drafts.push(result);
+  }
+  return sortSiteIssues(drafts);
+}
+function sortSiteIssues(drafts) {
+  const byPage = [...drafts].sort((a, b) => a.pageUrl.localeCompare(b.pageUrl));
+  return sortIssues(byPage);
+}
+
+// src/lib/core/locales.ts
+var ISO_639_1 = new Set(
+  "aa ab ae af ak am an ar as av ay az ba be bg bh bi bm bn bo br bs ca ce ch co cr cs cu cv cy da de dv dz ee el en eo es et eu fa ff fi fj fo fr fy ga gd gl gn gu gv ha he hi ho hr ht hu hy hz ia id ie ig ii ik io is it iu ja jv ka kg ki kj kk kl km kn ko kr ks ku kv kw ky la lb lg li ln lo lt lu lv mg mh mi mk ml mn mr ms mt my na nb nd ne ng nl nn no nr nv ny oc oj om or os pa pi pl ps pt qu rm rn ro ru rw sa sc sd se sg si sk sl sm sn so sq sr ss st su sv sw ta te tg th ti tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa wo xh yi yo za zh zu".split(" ")
+);
+function isKnownLanguageTag(tag) {
+  const primary = tag.toLowerCase().split("-")[0] ?? "";
+  return ISO_639_1.has(primary);
+}
+function localePrefixOf(url) {
+  let pathname;
+  try {
+    pathname = new URL(url).pathname;
+  } catch {
+    return null;
+  }
+  const first = pathname.split("/").filter(Boolean)[0];
+  if (first && looksLikeLocaleSegment(first)) return first.toLowerCase();
+  return null;
+}
+function prefixesIn(urls) {
+  const out = /* @__PURE__ */ new Set();
+  for (const url of urls ?? []) {
+    const locale = localePrefixOf(url);
+    if (locale) out.add(locale);
+  }
+  out.delete("x-default");
+  return out;
+}
+function describeCandidates(pages) {
+  const byTag = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const tag = localePrefixOf(page.fetch.finalUrl);
+    if (!tag || tag === "x-default") continue;
+    const entry = byTag.get(tag) ?? { pages: 0, langs: /* @__PURE__ */ new Set() };
+    entry.pages += 1;
+    const lang = page.raw.htmlLang?.trim().toLowerCase();
+    if (lang) entry.langs.add(lang);
+    byTag.set(tag, entry);
+  }
+  const candidates = [];
+  for (const [tag, { pages: n, langs }] of byTag) {
+    const observedLangs = [...langs].sort();
+    const htmlLangAgrees = observedLangs.length === 0 ? void 0 : observedLangs.some((l) => l.split("-")[0] === tag.split("-")[0]);
+    candidates.push({
+      tag,
+      pages: n,
+      isKnownLanguage: isKnownLanguageTag(tag),
+      htmlLangAgrees,
+      observedLangs
+    });
+  }
+  return candidates.sort(
+    (a, b) => Number(b.htmlLangAgrees ?? false) - Number(a.htmlLangAgrees ?? false) || Number(b.isKnownLanguage) - Number(a.isKnownLanguage) || b.pages - a.pages || a.tag.localeCompare(b.tag)
+  );
+}
+function deriveLocaleAxis(input) {
+  const explicit = new Set(
+    (input.explicit ?? []).map((l) => l.trim().toLowerCase()).filter(Boolean)
+  );
+  explicit.delete("x-default");
+  const fromSitemap = prefixesIn(input.sitemapUrls);
+  if (explicit.size > 0 || fromSitemap.size > 0) {
+    const all = /* @__PURE__ */ new Set([...explicit, ...fromSitemap]);
+    return {
+      locales: [...all].sort((a, b) => a.localeCompare(b)),
+      source: explicit.size > 0 ? "explicit" : "sitemap",
+      multilingual: all.size >= 2,
+      candidates: []
+    };
+  }
+  return {
+    locales: [],
+    source: "none",
+    multilingual: false,
+    candidates: describeCandidates(input.pages ?? [])
+  };
+}
+function suggestedLocales(axis) {
+  const plausible = axis.candidates.filter((c) => c.isKnownLanguage && c.htmlLangAgrees !== false);
+  if (plausible.length < 2) return null;
+  return plausible.map((c) => c.tag).sort((a, b) => a.localeCompare(b)).join(",");
+}
+
+// src/lib/core/sitemap/discover.ts
+import { gunzipSync } from "zlib";
+
+// src/lib/core/sitemap/parse.ts
+import * as cheerio2 from "cheerio";
+function parseSitemap(body) {
+  const trimmed = body.trim();
+  if (trimmed.length === 0) {
+    return { kind: "unknown", wellFormed: false, urls: [], sitemaps: [] };
+  }
+  let $;
+  try {
+    $ = cheerio2.load(trimmed, { xmlMode: true });
+  } catch {
+    return { kind: "unknown", wellFormed: false, urls: [], sitemaps: [] };
+  }
+  if ($("sitemapindex").length > 0) {
+    const sitemaps = [];
+    const seen = /* @__PURE__ */ new Set();
+    $("sitemap > loc").each((_, el) => {
+      const loc = $(el).text().trim();
+      if (loc && !seen.has(loc)) {
+        seen.add(loc);
+        sitemaps.push(loc);
+      }
+    });
+    return { kind: "index", wellFormed: true, sitemaps };
+  }
+  if ($("urlset").length > 0 || $("url").length > 0) {
+    const urls = [];
+    const seen = /* @__PURE__ */ new Set();
+    $("url").each((_, el) => {
+      const node = $(el);
+      const loc = node.find("loc").first().text().trim();
+      if (!loc || seen.has(loc)) return;
+      seen.add(loc);
+      const entry = { loc };
+      const lastmod = node.find("lastmod").first().text().trim();
+      if (lastmod) entry.lastmod = lastmod;
+      const changefreq = node.find("changefreq").first().text().trim();
+      if (changefreq) entry.changefreq = changefreq;
+      const priority = node.find("priority").first().text().trim();
+      if (priority) entry.priority = priority;
+      urls.push(entry);
+    });
+    return { kind: "urlset", wellFormed: true, urls };
+  }
+  return { kind: "unknown", wellFormed: false, urls: [], sitemaps: [] };
+}
+
+// src/lib/core/sitemap/discover.ts
+var DEFAULTS = {
+  timeoutMs: 8e3,
+  maxUrls: 5e3,
+  maxSitemaps: 50,
+  crawlDepth: 1,
+  crawlMaxPages: 100
+};
+async function discoverSitemap(baseUrl, options = {}) {
+  const origin = new URL(baseUrl).origin;
+  const maxUrls = options.maxUrls ?? DEFAULTS.maxUrls;
+  const maxSitemaps = options.maxSitemaps ?? DEFAULTS.maxSitemaps;
+  const diagnostics = {
+    found: false,
+    status: 0,
+    declaredInRobots: false,
+    robotsFound: false,
+    atWellKnownPath: false,
+    wellFormed: false,
+    isIndex: false,
+    childSitemapCount: 0,
+    childSitemapErrors: 0,
+    urlCount: 0,
+    warnings: []
+  };
+  const robots = await probeRobots(origin, { signal: options.signal });
+  diagnostics.robotsFound = robots.found;
+  const candidates = [];
+  for (const declared of robots.sitemaps) {
+    candidates.push({ url: declared, source: "robots", declaredInRobots: true });
+  }
+  candidates.push({
+    url: new URL("/sitemap.xml", origin).toString(),
+    source: "well-known",
+    declaredInRobots: robots.sitemaps.includes(new URL("/sitemap.xml", origin).toString())
+  });
+  candidates.push({
+    url: new URL("/sitemap_index.xml", origin).toString(),
+    source: "well-known",
+    declaredInRobots: false
+  });
+  for (const candidate of candidates) {
+    const doc = await fetchDoc(candidate.url, options);
+    if (!doc.body) {
+      if (diagnostics.status === 0) diagnostics.status = doc.status;
+      continue;
+    }
+    const parsed = parseSitemap(doc.body);
+    if (parsed.kind === "unknown") {
+      if (diagnostics.status === 0) diagnostics.status = doc.status;
+      diagnostics.warnings.push(`Malformed or unrecognised sitemap at ${candidate.url}`);
+      continue;
+    }
+    diagnostics.found = true;
+    diagnostics.status = doc.status;
+    diagnostics.wellFormed = true;
+    diagnostics.sitemapUrl = candidate.url;
+    diagnostics.declaredInRobots = candidate.declaredInRobots;
+    diagnostics.atWellKnownPath = isWellKnownPath(candidate.url);
+    const collected = [];
+    const seen = /* @__PURE__ */ new Set();
+    let truncated = false;
+    if (parsed.kind === "urlset") {
+      truncated = pushEntries(collected, seen, parsed.urls, maxUrls);
+    } else {
+      diagnostics.isIndex = true;
+      const children = parsed.sitemaps.slice(0, maxSitemaps);
+      diagnostics.childSitemapCount = parsed.sitemaps.length;
+      if (parsed.sitemaps.length > maxSitemaps) {
+        truncated = true;
+        diagnostics.warnings.push(
+          `Sitemap index has ${parsed.sitemaps.length} children; only the first ${maxSitemaps} were followed.`
+        );
+      }
+      for (const childUrl of children) {
+        if (collected.length >= maxUrls) {
+          truncated = true;
+          break;
+        }
+        const childDoc = await fetchDoc(childUrl, options);
+        if (!childDoc.body) {
+          diagnostics.childSitemapErrors += 1;
+          diagnostics.warnings.push(`Child sitemap unreachable: ${childUrl}`);
+          continue;
+        }
+        const childParsed = parseSitemap(childDoc.body);
+        if (childParsed.kind !== "urlset") {
+          diagnostics.childSitemapErrors += 1;
+          diagnostics.warnings.push(`Child sitemap not a urlset: ${childUrl}`);
+          continue;
+        }
+        if (pushEntries(collected, seen, childParsed.urls, maxUrls)) truncated = true;
+      }
+    }
+    diagnostics.urlCount = collected.length;
+    if (collected.length === 0 && options.crawlFallback !== false) {
+      return crawlSite(baseUrl, origin, options, diagnostics);
+    }
+    return {
+      origin,
+      baseUrl,
+      source: candidate.source,
+      urls: collected,
+      diagnostics,
+      truncated
+    };
+  }
+  if (options.crawlFallback !== false) {
+    return crawlSite(baseUrl, origin, options, diagnostics);
+  }
+  diagnostics.warnings.push("No sitemap found.");
+  return { origin, baseUrl, source: "well-known", urls: [], diagnostics, truncated: false };
+}
+async function crawlSite(baseUrl, origin, options, diagnostics) {
+  const result = await crawl({
+    entryUrl: baseUrl,
+    depth: options.crawlDepth ?? DEFAULTS.crawlDepth,
+    maxPages: options.crawlMaxPages ?? DEFAULTS.crawlMaxPages,
+    inspectOptions: {
+      mode: "static",
+      probes: false,
+      allowInsecureTls: options.allowInsecureTls,
+      signal: options.signal
+    }
+  });
+  const urls = dedupe(result.visited).map((loc) => ({ loc }));
+  diagnostics.urlCount = urls.length;
+  diagnostics.warnings.push(
+    diagnostics.found ? "Sitemap found but lists no URLs \u2014 crawled the site instead." : "No sitemap found \u2014 URLs were discovered by crawling links."
+  );
+  return {
+    origin,
+    baseUrl,
+    source: "crawl",
+    urls,
+    diagnostics,
+    truncated: result.truncated
+  };
+}
+function pushEntries(out, seen, entries, cap) {
+  for (const entry of entries) {
+    if (out.length >= cap) return true;
+    if (seen.has(entry.loc)) continue;
+    seen.add(entry.loc);
+    out.push(entry);
+  }
+  return out.length >= cap;
+}
+function dedupe(urls) {
+  return Array.from(new Set(urls));
+}
+function isWellKnownPath(url) {
+  try {
+    const path = new URL(url).pathname.toLowerCase();
+    return path === "/sitemap.xml" || path === "/sitemap_index.xml";
+  } catch {
+    return false;
+  }
+}
+async function fetchDoc(url, options) {
+  const { signal, cleanup } = combineSignals(
+    options.signal,
+    options.timeoutMs ?? DEFAULTS.timeoutMs
+  );
+  const restoreTls = relaxTlsIfRequested2(options.allowInsecureTls);
+  try {
+    const res = await fetch(url, {
+      signal,
+      redirect: "follow",
+      headers: {
+        accept: "application/xml,text/xml,application/gzip;q=0.9,*/*;q=0.5"
+      }
+    });
+    if (!res.ok) return { status: res.status };
+    const encoding = res.headers.get("content-encoding")?.toLowerCase() ?? "";
+    const looksGzip = url.toLowerCase().endsWith(".gz") || encoding.includes("gzip");
+    if (looksGzip) {
+      const buf = Buffer.from(await res.arrayBuffer());
+      try {
+        return { status: res.status, body: gunzipSync(buf).toString("utf8") };
+      } catch {
+        return { status: res.status, body: buf.toString("utf8") };
+      }
+    }
+    return { status: res.status, body: await res.text() };
+  } catch {
+    return { status: 0 };
+  } finally {
+    cleanup();
+    restoreTls();
+  }
+}
+function relaxTlsIfRequested2(enabled) {
+  if (!enabled) return () => void 0;
+  const previous = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  return () => {
+    if (previous === void 0) delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+    else process.env.NODE_TLS_REJECT_UNAUTHORIZED = previous;
+  };
+}
+
+// src/lib/core/net/fetch-url.ts
+var DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+var DEFAULT_TIMEOUT_MS = 8e3;
+var DEFAULT_MAX_BYTES = 3 * 1024 * 1024;
+var DEFAULT_ACCEPT = "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8";
+var TEXTY = /(text\/|application\/(xhtml\+xml|xml|json|.*\+xml|.*\+json|javascript))/;
+async function fetchUrl(url, options = {}) {
+  const method = options.method ?? "GET";
+  const redirect = options.redirect ?? "follow";
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const startedAt = Date.now();
+  const { signal, cleanup } = combineSignals(
+    options.signal,
+    options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+  );
+  const restoreTls = relaxTlsIfRequested3(options.allowInsecureTls);
+  try {
+    const res = await fetch(url, {
+      method,
+      signal,
+      redirect,
+      headers: {
+        "user-agent": options.userAgent ?? DEFAULT_USER_AGENT,
+        accept: options.accept ?? DEFAULT_ACCEPT
+      }
+    });
+    const contentType = normaliseContentType(res.headers.get("content-type"));
+    const result = {
+      requestedUrl: url,
+      finalUrl: res.url || url,
+      status: res.status,
+      redirected: res.redirected,
+      redirectChain: [],
+      contentType,
+      durationMs: Date.now() - startedAt
+    };
+    const retryAfter = res.headers.get("retry-after");
+    if (retryAfter) result.retryAfter = retryAfter;
+    if (redirect === "manual" && isRedirectStatus(res.status)) {
+      const location = res.headers.get("location");
+      if (location) {
+        try {
+          const next = new URL(location, url).toString();
+          result.finalUrl = next;
+          result.redirectChain = [next];
+          result.redirected = true;
+        } catch {
+        }
+      }
+      await res.body?.cancel().catch(() => void 0);
+      return result;
+    }
+    if (method === "HEAD") {
+      await res.body?.cancel().catch(() => void 0);
+      return result;
+    }
+    if (contentType && !TEXTY.test(contentType)) {
+      await res.body?.cancel().catch(() => void 0);
+      return result;
+    }
+    const { text, truncated } = await readCappedText(res, maxBytes);
+    result.body = text;
+    if (truncated) result.truncated = true;
+    return result;
+  } catch (err) {
+    return {
+      requestedUrl: url,
+      finalUrl: url,
+      status: 0,
+      redirected: false,
+      redirectChain: [],
+      reason: classifyError(err, options.signal),
+      durationMs: Date.now() - startedAt
+    };
+  } finally {
+    cleanup();
+    restoreTls();
+  }
+}
+function isRedirectStatus(status) {
+  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+function normaliseContentType(raw) {
+  if (!raw) return void 0;
+  const semi = raw.indexOf(";");
+  return (semi === -1 ? raw : raw.slice(0, semi)).trim().toLowerCase() || void 0;
+}
+async function readCappedText(res, maxBytes) {
+  const reader = res.body?.getReader();
+  if (!reader) {
+    const text = await res.text();
+    if (text.length > maxBytes) {
+      return { text: text.slice(0, maxBytes), truncated: true };
+    }
+    return { text, truncated: false };
+  }
+  const chunks = [];
+  let received = 0;
+  let truncated = false;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    chunks.push(value);
+    received += value.byteLength;
+    if (received >= maxBytes) {
+      truncated = true;
+      await reader.cancel().catch(() => void 0);
+      break;
+    }
+  }
+  const buf = Buffer.concat(chunks.map((c) => Buffer.from(c)));
+  const sliced = buf.byteLength > maxBytes ? buf.subarray(0, maxBytes) : buf;
+  return { text: sliced.toString("utf8"), truncated };
+}
+function classifyError(err, callerSignal) {
+  if (isAbortError(err)) {
+    return callerSignal?.aborted ? "abort" : "timeout";
+  }
+  const code = errorCode(err);
+  if (code) {
+    if (code === "ENOTFOUND" || code === "EAI_AGAIN") return "dns";
+    if (code.startsWith("CERT_") || code.includes("SELF_SIGNED") || code.includes("CERT")) {
+      return "tls";
+    }
+  }
+  const message = err instanceof Error ? err.message.toLowerCase() : String(err).toLowerCase();
+  if (message.includes("certificate") || message.includes("tls") || message.includes("ssl")) {
+    return "tls";
+  }
+  return "network";
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function errorCode(err) {
+  if (err && typeof err === "object") {
+    const direct = err.code;
+    if (typeof direct === "string") return direct;
+    const cause = err.cause;
+    if (cause && typeof cause === "object") {
+      const causeCode = cause.code;
+      if (typeof causeCode === "string") return causeCode;
+    }
+  }
+  return void 0;
+}
+function relaxTlsIfRequested3(enabled) {
+  if (!enabled) return () => void 0;
+  const previous = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+  process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+  return () => {
+    if (previous === void 0) delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+    else process.env.NODE_TLS_REJECT_UNAUTHORIZED = previous;
+  };
+}
+
+// src/lib/core/links/extract.ts
+import * as cheerio3 from "cheerio";
+var ANCHOR_SPEC = { selector: "a[href]", attr: "href", source: "a" };
+var ASSET_SPECS = [
+  { selector: "img[src]", attr: "src", source: "img" },
+  { selector: "script[src]", attr: "src", source: "script" },
+  { selector: "link[href]", attr: "href", source: "link" },
+  { selector: "iframe[src]", attr: "src", source: "iframe" }
+];
+function extractLinks(html, options) {
+  const $ = cheerio3.load(html);
+  const base = resolveBase2($, options.baseUrl);
+  const origin = safeOrigin(options.baseUrl);
+  const specs = options.includeAssets ? [ANCHOR_SPEC, ...ASSET_SPECS] : [ANCHOR_SPEC];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const spec of specs) {
+    $(spec.selector).each((_, el) => {
+      const raw = $(el).attr(spec.attr);
+      if (raw === void 0) return;
+      const rawHref = raw.trim();
+      if (!rawHref) return;
+      const ref = buildRef($, el, rawHref, spec, base, origin);
+      if (!ref) return;
+      const dedupeKey = `${ref.source}|${ref.url}`;
+      if (seen.has(dedupeKey)) return;
+      seen.add(dedupeKey);
+      out.push(ref);
+    });
+  }
+  return out;
+}
+function buildRef($, el, rawHref, spec, base, origin) {
+  const fragment = extractFragment(rawHref);
+  const canonical = canonicaliseUrl(rawHref, base, { preserveTrailingSlash: true });
+  const url = canonical ?? rawHref;
+  const kind = canonical ? classify(canonical, origin) : "external";
+  const ref = {
+    rawHref,
+    url,
+    kind,
+    source: spec.source,
+    rel: spec.source === "a" || spec.source === "link" ? parseRel($(el).attr("rel")) : []
+  };
+  if (spec.source === "a") {
+    const text = $(el).text().trim();
+    if (text) ref.anchorText = text;
+  }
+  if (fragment) ref.fragment = fragment;
+  return ref;
+}
+function extractFragment(rawHref) {
+  const hash = rawHref.indexOf("#");
+  if (hash === -1) return void 0;
+  const frag = rawHref.slice(hash);
+  return frag.length > 1 ? frag : void 0;
+}
+function parseRel(rel) {
+  if (!rel) return [];
+  return rel.split(/\s+/).map((t) => t.trim().toLowerCase()).filter(Boolean);
+}
+function classify(url, origin) {
+  if (!origin) return "external";
+  return safeOrigin(url) === origin ? "internal" : "external";
+}
+function safeOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function resolveBase2($, pageUrl) {
+  const declared = $("base[href]").first().attr("href")?.trim();
+  if (declared) {
+    try {
+      return new URL(declared, pageUrl).toString();
+    } catch {
+    }
+  }
+  return pageUrl;
+}
+
+// src/lib/core/links/classify.ts
+function classifyLink(input) {
+  if (input.status === 0) return "broken";
+  if (input.loop) return "broken";
+  if (input.softNotFound) return "warning";
+  if (input.status === 403 || input.status === 429) return "blocked";
+  if (input.status >= 400) return "broken";
+  if (input.status >= 200 && input.status < 300) {
+    return input.redirected ? "redirect" : "ok";
+  }
+  return "broken";
+}
+
+// src/lib/core/links/check.ts
+var DEFAULTS2 = {
+  timeoutMs: 8e3,
+  maxRedirects: 10,
+  retries: 1,
+  backoffBaseMs: 300,
+  maxBackoffMs: 3e3,
+  softBodyBytes: 16 * 1024
+};
+var NOT_FOUND_RE = /\b(not\s+found|page\s+doesn'?t\s+exist|404|no\s+such\s+page)\b/i;
+var SOFT_404_BODY_LIMIT = 2048;
+async function checkLink(url, options = {}) {
+  const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const started = Date.now();
+  const scheme = schemeOf(url);
+  if (scheme !== "http" && scheme !== "https") {
+    return {
+      url,
+      finalUrl: url,
+      status: 0,
+      verdict: "skipped",
+      method: "GET",
+      redirectChain: [],
+      reason: scheme ? `unsupported scheme: ${scheme}` : "not a URL",
+      checkedAt,
+      durationMs: Date.now() - started
+    };
+  }
+  const outcome = await probeWithRetry(url, options);
+  const softNotFound = isSoftNotFound(outcome);
+  const verdict = classifyLink({
+    status: outcome.status,
+    redirected: outcome.redirectChain.length > 0,
+    reason: outcome.reason,
+    softNotFound,
+    loop: outcome.loop
+  });
+  return {
+    url,
+    finalUrl: outcome.finalUrl,
+    status: outcome.status,
+    verdict,
+    method: outcome.method,
+    redirectChain: outcome.redirectChain,
+    reason: describeReason(outcome, softNotFound),
+    checkedAt,
+    durationMs: Date.now() - started
+  };
+}
+async function probeWithRetry(url, options) {
+  const retries = options.retries ?? DEFAULTS2.retries;
+  const sleep = options.sleep ?? defaultSleep;
+  let outcome = await probeWithHeadFallback(url, options);
+  for (let attempt = 0; attempt < retries; attempt++) {
+    if (!isTransient(outcome)) break;
+    if (options.signal?.aborted) break;
+    const delay = backoffDelay(outcome, attempt, options);
+    if (delay > 0) await sleep(delay);
+    outcome = await probeWithHeadFallback(url, options);
+  }
+  return outcome;
+}
+async function probeWithHeadFallback(url, options) {
+  const head = await followRedirects(url, "HEAD", options);
+  if (headRejected(head) || head.status >= 200 && head.status < 300) {
+    const get = await followRedirects(url, "GET", options);
+    if (get.status === 0 && head.status !== 0 && !headRejected(head)) return head;
+    return get;
+  }
+  return head;
+}
+function headRejected(o) {
+  return o.status === 405 || o.status === 501 || o.status === 403 || o.status === 0;
+}
+async function followRedirects(url, method, options) {
+  const maxRedirects = options.maxRedirects ?? DEFAULTS2.maxRedirects;
+  const chain = [];
+  const visited = /* @__PURE__ */ new Set([url]);
+  let current = url;
+  for (let hop = 0; hop <= maxRedirects; hop++) {
+    const res = await fetchUrl(current, {
+      method,
+      redirect: "manual",
+      timeoutMs: options.timeoutMs ?? DEFAULTS2.timeoutMs,
+      allowInsecureTls: options.allowInsecureTls,
+      userAgent: options.userAgent,
+      maxBytes: method === "GET" ? options.softBodyBytes ?? DEFAULTS2.softBodyBytes : void 0
+    });
+    if (res.status === 0) {
+      return {
+        status: 0,
+        finalUrl: current,
+        redirectChain: chain,
+        reason: res.reason,
+        loop: false,
+        method
+      };
+    }
+    const next = res.redirectChain[0];
+    if (next) {
+      chain.push(next);
+      if (visited.has(next)) {
+        return { status: res.status, finalUrl: next, redirectChain: chain, loop: true, method };
+      }
+      visited.add(next);
+      current = next;
+      continue;
+    }
+    return {
+      status: res.status,
+      finalUrl: res.finalUrl,
+      redirectChain: chain,
+      loop: false,
+      body: res.body,
+      retryAfter: res.retryAfter,
+      method
+    };
+  }
+  return { status: 0, finalUrl: current, redirectChain: chain, loop: true, method };
+}
+function isSoftNotFound(o) {
+  if (o.status < 200 || o.status >= 300) return false;
+  if (o.body === void 0) return false;
+  if (o.body.length > SOFT_404_BODY_LIMIT) return false;
+  return NOT_FOUND_RE.test(o.body);
+}
+function isTransient(o) {
+  if (o.status === 0) return true;
+  if (o.status === 429) return true;
+  if (o.status >= 500) return true;
+  return false;
+}
+function backoffDelay(o, attempt, options) {
+  const max = options.maxBackoffMs ?? DEFAULTS2.maxBackoffMs;
+  const retryAfterMs = parseRetryAfter(o.retryAfter);
+  if (retryAfterMs !== void 0) return Math.min(retryAfterMs, max);
+  const base = options.backoffBaseMs ?? DEFAULTS2.backoffBaseMs;
+  const exp = base * 2 ** attempt;
+  const jitter = Math.floor(Math.random() * base);
+  return Math.min(exp + jitter, max);
+}
+function parseRetryAfter(value) {
+  if (!value) return void 0;
+  const seconds = Number(value);
+  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1e3);
+  const date = Date.parse(value);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+function describeReason(o, softNotFound) {
+  if (o.reason) return o.reason;
+  if (o.loop) return "redirect loop";
+  if (softNotFound) return "soft-404";
+  if (o.status === 429) return "429 rate-limited";
+  if (o.status === 403) return "403 forbidden";
+  if (o.status >= 400) return `${o.status}`;
+  return void 0;
+}
+function schemeOf(url) {
+  try {
+    return new URL(url).protocol.replace(/:$/, "").toLowerCase();
+  } catch {
+    return null;
+  }
+}
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/core/links/types.ts
+function emptyVerdictSummary() {
+  return { ok: 0, redirect: 0, broken: 0, blocked: 0, warning: 0, skipped: 0 };
+}
+
+// src/lib/core/links/audit.ts
+var DEFAULTS3 = {
+  scanConcurrency: 4,
+  checkConcurrency: 8,
+  maxPerHost: 3,
+  timeoutMs: 8e3,
+  maxPages: 500,
+  maxLinks: 1e4,
+  maxScanBytes: 3 * 1024 * 1024
+};
+async function runLinkAudit(discovery, options = {}) {
+  const maxPages = options.maxPages ?? DEFAULTS3.maxPages;
+  const maxLinks = options.maxLinks ?? DEFAULTS3.maxLinks;
+  const checkExternal = options.checkExternal !== false;
+  const warnings = [];
+  let truncated = false;
+  const allPages = discovery.urls.map((u) => u.loc);
+  const pageUrls = allPages.slice(0, maxPages);
+  if (allPages.length > maxPages) {
+    truncated = true;
+    warnings.push(`Site has ${allPages.length} pages; only the first ${maxPages} were scanned.`);
+  }
+  const occurrences = [];
+  let pagesScanned = 0;
+  let pagesFailed = 0;
+  let scanDone = 0;
+  await mapWithHostCaps(
+    pageUrls,
+    {
+      concurrency: options.scanConcurrency ?? DEFAULTS3.scanConcurrency,
+      perHost: Infinity,
+      signal: options.signal
+    },
+    async (pageUrl) => {
+      const res = await fetchUrl(pageUrl, {
+        method: "GET",
+        timeoutMs: options.timeoutMs ?? DEFAULTS3.timeoutMs,
+        allowInsecureTls: options.allowInsecureTls,
+        userAgent: options.userAgent,
+        maxBytes: options.maxScanBytes ?? DEFAULTS3.maxScanBytes,
+        signal: options.signal
+      });
+      if (res.status === 0 || res.status >= 400 || res.body === void 0) {
+        pagesFailed += 1;
+      } else {
+        pagesScanned += 1;
+        const refs = extractLinks(res.body, {
+          baseUrl: res.finalUrl,
+          includeAssets: options.includeAssets
+        });
+        for (const ref of refs) occurrences.push({ pageUrl, ref });
+      }
+      scanDone += 1;
+      options.onProgress?.({ phase: "scan", done: scanDone, total: pageUrls.length });
+    },
+    () => "scan"
+  );
+  const uniqueUrls = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const occ of occurrences) {
+    const url = occ.ref.url;
+    if (seen.has(url)) continue;
+    if (!checkExternal && occ.ref.kind === "external") continue;
+    if (uniqueUrls.length >= maxLinks) {
+      truncated = true;
+      warnings.push(`More than ${maxLinks} unique links found; the remainder were not checked.`);
+      break;
+    }
+    seen.add(url);
+    uniqueUrls.push(url);
+  }
+  const checks = {};
+  let checkDone = 0;
+  await mapWithHostCaps(
+    uniqueUrls,
+    {
+      concurrency: options.checkConcurrency ?? DEFAULTS3.checkConcurrency,
+      perHost: options.maxPerHost ?? DEFAULTS3.maxPerHost,
+      signal: options.signal
+    },
+    async (url) => {
+      const check = await checkLink(url, {
+        timeoutMs: options.timeoutMs ?? DEFAULTS3.timeoutMs,
+        allowInsecureTls: options.allowInsecureTls,
+        userAgent: options.userAgent,
+        signal: options.signal,
+        sleep: options.sleep
+      });
+      checks[url] = check;
+      checkDone += 1;
+      options.onProgress?.({ phase: "check", done: checkDone, total: uniqueUrls.length });
+    },
+    (url) => hostOf(url)
+  );
+  const summary = emptyVerdictSummary();
+  for (const check of Object.values(checks)) summary[check.verdict] += 1;
+  const brokenByPage = buildBrokenByPage(occurrences, checks);
+  return {
+    origin: discovery.origin,
+    baseUrl: discovery.baseUrl,
+    pagesScanned,
+    occurrences,
+    checks,
+    summary,
+    brokenByPage,
+    truncated,
+    diagnostics: { pagesFailed, warnings }
+  };
+}
+function buildBrokenByPage(occurrences, checks) {
+  const byPage = /* @__PURE__ */ new Map();
+  for (const occ of occurrences) {
+    const check = checks[occ.ref.url];
+    if (!check) continue;
+    if (check.verdict === "ok" || check.verdict === "redirect" || check.verdict === "skipped") {
+      continue;
+    }
+    let page = byPage.get(occ.pageUrl);
+    if (!page) {
+      page = /* @__PURE__ */ new Map();
+      byPage.set(occ.pageUrl, page);
+    }
+    page.set(check.url, check);
+  }
+  return Array.from(byPage.entries()).map(([pageUrl, map]) => ({ pageUrl, broken: Array.from(map.values()) })).sort((a, b) => b.broken.length - a.broken.length);
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function mapWithHostCaps(items, opts, worker, hostOf2) {
+  const concurrency = Math.max(1, opts.concurrency);
+  const perHost = opts.perHost;
+  return new Promise((resolve) => {
+    if (items.length === 0) {
+      resolve();
+      return;
+    }
+    const pending = items.map((item) => ({ item, host: hostOf2(item) }));
+    const hostActive = /* @__PURE__ */ new Map();
+    let inflight = 0;
+    let settled = false;
+    const finish = () => {
+      if (!settled) {
+        settled = true;
+        resolve();
+      }
+    };
+    const pump = () => {
+      if (settled) return;
+      if (opts.signal?.aborted) {
+        if (inflight === 0) finish();
+        return;
+      }
+      while (inflight < concurrency) {
+        let pickIndex = -1;
+        for (let k = 0; k < pending.length; k++) {
+          const entry = pending[k];
+          if ((hostActive.get(entry.host) ?? 0) < perHost) {
+            pickIndex = k;
+            break;
+          }
+        }
+        if (pickIndex === -1) break;
+        const [picked] = pending.splice(pickIndex, 1);
+        const host = picked.host;
+        hostActive.set(host, (hostActive.get(host) ?? 0) + 1);
+        inflight += 1;
+        void worker(picked.item).catch(() => void 0).finally(() => {
+          inflight -= 1;
+          hostActive.set(host, (hostActive.get(host) ?? 1) - 1);
+          if (pending.length === 0 && inflight === 0) finish();
+          else pump();
+        });
+      }
+      if (pending.length === 0 && inflight === 0) finish();
+    };
+    pump();
+  });
+}
+
+// src/lib/core/net/normalize-url.ts
+var SCHEME_PATTERN = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\//;
+function normalizeInputUrl(input) {
+  const trimmed = input.trim();
+  if (!trimmed) return { ok: false };
+  const schemeMatch = trimmed.match(SCHEME_PATTERN);
+  let candidate;
+  if (schemeMatch) {
+    const scheme = (schemeMatch[1] ?? "").toLowerCase();
+    if (scheme !== "http" && scheme !== "https") return { ok: false };
+    candidate = trimmed;
+  } else {
+    candidate = `https://${trimmed}`;
+  }
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    return { ok: false };
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return { ok: false };
+  if (!parsed.hostname) return { ok: false };
+  return { ok: true, url: candidate };
+}
+
+// src/report/build.ts
+function isOkStatus(status) {
+  return status >= 200 && status < 300;
+}
+function isHtmlPage(page) {
+  const type = page.fetch.contentType?.trim().toLowerCase();
+  if (!type) return true;
+  return type === "text/html" || type === "application/xhtml+xml";
+}
+function localeOfUrl(url) {
+  try {
+    const { pathname } = new URL(url);
+    const first = pathname.split("/").filter(Boolean)[0];
+    if (first && looksLikeLocaleSegment(first)) return first;
+  } catch {
+  }
+  return null;
+}
+function deriveTranslationHoles(matrix, ignoreRoutes = []) {
+  const realLocales = matrix.locales.filter((l) => l !== "x-default");
+  if (realLocales.length < 2) return [];
+  const holes = [];
+  for (const route of matrix.routes) {
+    if (ignoreRoutes.length > 0 && matchesAny(route, [...ignoreRoutes])) continue;
+    const present = [];
+    const missing = [];
+    for (const locale of realLocales) {
+      const cell = matrix.cells[route]?.[locale];
+      if (cell && cell.url) present.push(locale);
+      else missing.push(locale);
+    }
+    if (present.length > 0 && missing.length > 0) {
+      holes.push({
+        id: fingerprint("i18n", "hole", route),
+        route,
+        presentLocales: present,
+        missingLocales: missing
+      });
+    }
+  }
+  return holes;
+}
+function exitCode(report, failOn = "warning") {
+  if (failOn === "never") return 0;
+  if (report.summary.verdict === "green") return 0;
+  if (failOn === "error") return report.summary.verdict === "red" ? 1 : 0;
+  return 1;
+}
+function dropCanonicalDuplicates(pages) {
+  const crawled = new Set(pages.map((p) => routeKey(p.fetch.finalUrl)));
+  const kept = pages.filter((page) => {
+    const canonical = page.links.canonical;
+    if (!canonical) return true;
+    const self = routeKey(page.fetch.finalUrl);
+    let target;
+    try {
+      target = routeKey(new URL(canonical, page.fetch.finalUrl).toString());
+    } catch {
+      return true;
+    }
+    if (target === self) return true;
+    return !crawled.has(target);
+  });
+  return { kept, dropped: pages.length - kept.length };
+}
+async function runAudit(inputUrl, options = {}) {
+  const normalized = normalizeInputUrl(inputUrl);
+  if (!normalized.ok) {
+    throw new Error(`"${inputUrl}" is not a valid http(s) URL.`);
+  }
+  const entry = normalized.url;
+  const origin = new URL(entry).origin;
+  const depth = options.depth ?? 2;
+  const maxPages = options.maxPages ?? 200;
+  const checkExternal = options.checkExternal !== false;
+  const discovery = options.noSitemap ? void 0 : await discoverSitemap(entry, {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs,
+    allowInsecureTls: options.allowInsecureTls,
+    crawlFallback: false
+  }).catch(() => void 0);
+  const sitemapUrls = (discovery?.urls ?? []).map((u) => u.loc);
+  const robots = await probeRobots(origin, {
+    signal: options.signal,
+    timeoutMs: options.timeoutMs
+  }).catch(() => void 0);
+  const crawlResult = await crawl({
+    entryUrl: entry,
+    seedUrls: sitemapUrls,
+    depth,
+    maxPages,
+    include: options.include,
+    exclude: options.exclude,
+    inspectOptions: {
+      mode: options.static ? "static" : "auto",
+      probes: false,
+      allowInsecureTls: options.allowInsecureTls,
+      timeoutMs: options.timeoutMs,
+      signal: options.signal
+    },
+    onPage: (page, ctx) => options.onProgress?.({
+      phase: "crawl",
+      done: ctx.visited,
+      total: ctx.visited + ctx.queued,
+      url: page.fetch.finalUrl,
+      status: page.fetch.status
+    })
+  });
+  const pages = crawlResult.pages;
+  const warnings = crawlResult.errors.map((e) => `crawl: ${e.url} \u2014 ${e.message}`);
+  const okPages = pages.filter((p) => isOkStatus(p.fetch.status));
+  const documents = okPages.filter(isHtmlPage);
+  const { kept: htmlPages, dropped: duplicatePages } = dropCanonicalDuplicates(documents);
+  const unreachablePages = pages.filter((p) => !isOkStatus(p.fetch.status)).map((p) => ({
+    id: fingerprint("page", routeKey(p.fetch.finalUrl)),
+    url: p.fetch.finalUrl,
+    status: p.fetch.status
+  }));
+  const seoIssues = [];
+  for (const page of htmlPages) {
+    const pageUrl = page.fetch.finalUrl;
+    const occurrence = /* @__PURE__ */ new Map();
+    for (const issue of lint(page)) {
+      const n = occurrence.get(issue.ruleId) ?? 0;
+      occurrence.set(issue.ruleId, n + 1);
+      const rule = getRule(issue.ruleId);
+      seoIssues.push({
+        id: fingerprint("seo", issue.ruleId, routeKey(pageUrl), String(n)),
+        pageUrl,
+        ruleId: issue.ruleId,
+        severity: issue.severity,
+        message: issue.message,
+        why: rule?.summary,
+        fix: issue.fix?.snippet
+      });
+    }
+  }
+  const localeAxis = deriveLocaleAxis({
+    explicit: options.locales,
+    sitemapUrls,
+    pages: htmlPages
+  });
+  if (localeAxis.source === "none" && localeAxis.candidates.length > 0) {
+    const suggestion = suggestedLocales(localeAxis);
+    warnings.push(
+      suggestion ? `No sitemap and no --locales: i18n checks are off. Locale-looking prefixes found \u2014 re-run with \`--locales ${suggestion}\` to enable them.` : `No sitemap and no --locales: i18n checks are off. Prefixes seen (${localeAxis.candidates.map((c) => c.tag).join(", ")}) do not look like locales; pass --locales if any of them is one.`
+    );
+  }
+  const matrix = buildI18nMatrix(htmlPages, {
+    declaredUrls: sitemapUrls,
+    locales: localeAxis.locales
+  });
+  const holes = localeAxis.multilingual ? deriveTranslationHoles(matrix, options.ignoreHoles) : [];
+  const ignoredHoles = localeAxis.multilingual && (options.ignoreHoles?.length ?? 0) > 0 ? deriveTranslationHoles(matrix).length - holes.length : 0;
+  const reciprocity = reciprocityIssues(htmlPages).map((issue) => ({
+    id: fingerprint(
+      "i18n",
+      issue.code,
+      routeKey(issue.url),
+      issue.peerUrl ? routeKey(issue.peerUrl) : "",
+      issue.locale ?? ""
+    ),
+    ...issue
+  }));
+  const siteContext = {
+    origin,
+    pages: htmlPages,
+    matrix,
+    localeAxis,
+    discovery,
+    robots
+  };
+  const siteOccurrence = /* @__PURE__ */ new Map();
+  const siteIssues = lintSite(siteContext).map((draft) => {
+    const key = `${draft.ruleId}\0${draft.pageUrl}`;
+    const n = siteOccurrence.get(key) ?? 0;
+    siteOccurrence.set(key, n + 1);
+    const rule = getSiteRule(draft.ruleId);
+    return {
+      id: fingerprint("site", draft.ruleId, routeKey(draft.pageUrl), String(n)),
+      pageUrl: draft.pageUrl,
+      ruleId: draft.ruleId,
+      severity: draft.severity,
+      message: draft.message,
+      why: rule?.summary,
+      fix: draft.fix?.snippet
+    };
+  });
+  const linkDiscovery = syntheticDiscovery(origin, entry, okPages, crawlResult.truncated);
+  const linkReport = await runLinkAudit(linkDiscovery, {
+    allowInsecureTls: options.allowInsecureTls,
+    checkExternal,
+    timeoutMs: options.timeoutMs,
+    maxPages,
+    signal: options.signal,
+    onProgress: (p) => options.onProgress?.({
+      phase: p.phase === "scan" ? "scan" : "links",
+      done: p.done,
+      total: p.total
+    })
+  });
+  warnings.push(...linkReport.diagnostics.warnings);
+  const brokenLinks = [];
+  for (const { pageUrl, broken } of linkReport.brokenByPage) {
+    for (const check of broken) {
+      brokenLinks.push({
+        id: fingerprint("link", routeKey(pageUrl), targetKey(check.url)),
+        pageUrl,
+        href: check.url,
+        status: check.status,
+        verdict: check.verdict,
+        reason: check.reason
+      });
+    }
+  }
+  const scanTargets = okPages.length;
+  const scanFailed = linkReport.diagnostics.pagesFailed;
+  const scanBlind = scanTargets > 0 && linkReport.pagesScanned === 0;
+  if (scanBlind) {
+    warnings.push(
+      `Link scan failed on all ${scanFailed} page(s) \u2014 "0 broken links" is unverified, not clean.`
+    );
+  } else if (scanFailed > 0 && scanFailed >= scanTargets / 2) {
+    warnings.push(
+      `Link scan failed on ${scanFailed} of ${scanTargets} page(s); link results are partial.`
+    );
+  }
+  const brokenCount = linkReport.summary.broken;
+  const errorCount = seoIssues.filter((i) => i.severity === "error").length + siteIssues.filter((i) => i.severity === "error").length;
+  const missingTranslations = holes.length + reciprocity.length;
+  const anyFinding = missingTranslations > 0 || seoIssues.length > 0 || siteIssues.length > 0 || brokenLinks.length > 0;
+  const crawlBlind = pages.length === 0;
+  if (crawlBlind) {
+    warnings.push(
+      `Crawled 0 pages from ${entry} \u2014 the audit reached nothing, so "no findings" is unverified, not clean.`
+    );
+  }
+  let verdict = "green";
+  if (crawlBlind || brokenCount > 0 || errorCount > 0 || unreachablePages.length > 0 || scanBlind) {
+    verdict = "red";
+  } else if (anyFinding) {
+    verdict = "yellow";
+  }
+  return {
+    url: entry,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    summary: {
+      brokenLinks: brokenCount,
+      missingTranslations,
+      seoIssues: seoIssues.length,
+      siteIssues: siteIssues.length,
+      unreachablePages: unreachablePages.length,
+      verdict
+    },
+    localeAxis: {
+      locales: localeAxis.locales,
+      source: localeAxis.source,
+      multilingual: localeAxis.multilingual,
+      ...localeAxis.candidates.length > 0 ? { candidates: localeAxis.candidates } : {}
+    },
+    pages: pages.map((p) => ({
+      url: p.fetch.finalUrl,
+      status: p.fetch.status,
+      locale: localeOfUrl(p.fetch.finalUrl)
+    })),
+    unreachablePages,
+    brokenLinks,
+    missingTranslations: { holes, reciprocity },
+    seoIssues,
+    siteIssues,
+    diagnostics: {
+      pagesCrawled: pages.length,
+      pagesScanned: linkReport.pagesScanned,
+      pagesFailed: linkReport.diagnostics.pagesFailed,
+      truncated: crawlResult.truncated || linkReport.truncated,
+      warnings,
+      ...ignoredHoles > 0 ? { ignoredHoles } : {},
+      ...duplicatePages > 0 ? { duplicatePages } : {},
+      ...discovery ? {
+        sitemap: {
+          found: discovery.diagnostics.found,
+          sitemapUrl: discovery.diagnostics.sitemapUrl,
+          urlCount: sitemapUrls.length,
+          uncrawled: countUncrawled(sitemapUrls, pages)
+        }
+      } : {}
+    }
+  };
+}
+function countUncrawled(sitemapUrls, pages) {
+  const crawled = new Set(pages.map((p) => p.fetch.finalUrl));
+  let n = 0;
+  for (const url of sitemapUrls) if (!crawled.has(url)) n += 1;
+  return n;
+}
+function syntheticDiscovery(origin, baseUrl, pages, truncated) {
+  return {
+    origin,
+    baseUrl,
+    source: "crawl",
+    urls: pages.map((p) => ({ loc: p.fetch.finalUrl })),
+    diagnostics: {
+      found: false,
+      status: 0,
+      declaredInRobots: false,
+      robotsFound: false,
+      atWellKnownPath: false,
+      wellFormed: false,
+      isIndex: false,
+      childSitemapCount: 0,
+      childSitemapErrors: 0,
+      urlCount: pages.length,
+      warnings: []
+    },
+    truncated
+  };
+}
+
+// src/report/render-terminal.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function paint(enabled) {
+  return (code, text) => enabled ? `${code}${text}${ANSI.reset}` : text;
+}
+var VERDICT_FLAG = {
+  green: "green flag",
+  yellow: "yellow flag",
+  red: "red flag"
+};
+function verdictColor(verdict) {
+  return verdict === "green" ? ANSI.green : verdict === "yellow" ? ANSI.yellow : ANSI.red;
+}
+function renderTerminal(report, options = {}) {
+  const color = options.color ?? false;
+  const c = paint(color);
+  const lines = [];
+  lines.push("");
+  lines.push(`${c(ANSI.bold, "goflag")} ${c(ANSI.dim, report.url)}`);
+  lines.push(
+    `${c(verdictColor(report.summary.verdict), VERDICT_FLAG[report.summary.verdict].toUpperCase())}  ` + c(
+      ANSI.dim,
+      `${report.diagnostics.pagesCrawled} pages crawled, ${report.diagnostics.pagesScanned} scanned`
+    )
+  );
+  lines.push("");
+  lines.push(
+    [
+      count(c, report.summary.brokenLinks, "broken link", report.summary.brokenLinks > 0),
+      count(
+        c,
+        report.summary.missingTranslations,
+        "missing translation",
+        report.summary.missingTranslations > 0
+      ),
+      count(c, report.summary.seoIssues, "SEO issue", report.summary.seoIssues > 0),
+      count(c, report.summary.siteIssues, "site issue", report.summary.siteIssues > 0),
+      count(
+        c,
+        report.summary.unreachablePages,
+        "unreachable page",
+        report.summary.unreachablePages > 0
+      )
+    ].join("   ")
+  );
+  lines.push("");
+  if (report.unreachablePages.length > 0) {
+    lines.push(c(ANSI.bold, "Unreachable pages"));
+    for (const page of report.unreachablePages) {
+      lines.push(`  ${c(ANSI.red, `[${page.status || "network error"}]`)} ${page.url}`);
+    }
+    lines.push("");
+  }
+  if (report.brokenLinks.length > 0) {
+    lines.push(c(ANSI.bold, "Broken links"));
+    const byPage = groupBy(report.brokenLinks, (b) => b.pageUrl);
+    for (const [pageUrl, links] of byPage) {
+      lines.push(`  ${c(ANSI.cyan, pageUrl)}`);
+      for (const link of links) {
+        const tag = link.verdict === "broken" ? c(ANSI.red, `[${link.status || link.reason || "broken"}]`) : c(ANSI.yellow, `[${link.verdict}${link.reason ? ` ${link.reason}` : ""}]`);
+        lines.push(`    ${tag} ${link.href}`);
+      }
+    }
+    lines.push("");
+  }
+  const { holes, reciprocity } = report.missingTranslations;
+  if (holes.length > 0 || reciprocity.length > 0) {
+    lines.push(c(ANSI.bold, "Missing translations"));
+    for (const hole of holes) {
+      lines.push(
+        `  ${c(ANSI.cyan, hole.route)} \u2014 missing ${c(ANSI.yellow, hole.missingLocales.join(", "))}` + c(ANSI.dim, ` (have ${hole.presentLocales.join(", ")})`)
+      );
+    }
+    for (const issue of reciprocity) {
+      lines.push(`  ${c(ANSI.yellow, issue.code)} ${c(ANSI.dim, issue.url)}`);
+      lines.push(`    ${issue.message}`);
+    }
+    lines.push("");
+  }
+  if (report.seoIssues.length > 0) {
+    lines.push(c(ANSI.bold, "SEO issues"));
+    lines.push(...renderIssuesByPage(report.seoIssues, c));
+    lines.push("");
+  }
+  if (report.siteIssues.length > 0) {
+    lines.push(c(ANSI.bold, "Site-wide issues"));
+    lines.push(
+      `  ${c(ANSI.dim, `locales: ${report.localeAxis.locales.join(", ") || "none"} (via ${report.localeAxis.source})`)}`
+    );
+    lines.push(...renderIssuesByPage(report.siteIssues, c));
+    lines.push("");
+  }
+  if (report.summary.verdict === "green") {
+    lines.push(c(ANSI.green, "No problems found."));
+    lines.push("");
+  }
+  for (const warning of report.diagnostics.warnings) {
+    lines.push(c(ANSI.dim, `note: ${warning}`));
+  }
+  if (report.diagnostics.truncated) {
+    lines.push(c(ANSI.dim, "note: results truncated by a page/link cap."));
+  }
+  return lines.join("\n");
+}
+function count(c, n, noun, bad) {
+  const label = `${n} ${noun}${n === 1 ? "" : "s"}`;
+  return bad ? c(ANSI.bold, c(ANSI.yellow, label)) : c(ANSI.dim, label);
+}
+function renderIssuesByPage(issues, c) {
+  const lines = [];
+  for (const [pageUrl, group] of groupBy([...issues], (i) => i.pageUrl)) {
+    lines.push(`  ${c(ANSI.cyan, pageUrl)}`);
+    for (const issue of group) {
+      const sev = issue.severity === "error" ? c(ANSI.red, "error") : issue.severity === "warning" ? c(ANSI.yellow, "warn ") : c(ANSI.dim, "info ");
+      lines.push(`    ${sev} ${c(ANSI.dim, issue.ruleId)}  ${stripBackticks(issue.message)}`);
+    }
+  }
+  return lines;
+}
+function groupBy(items, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const k = key(item);
+    const arr = map.get(k);
+    if (arr) arr.push(item);
+    else map.set(k, [item]);
+  }
+  return map;
+}
+function stripBackticks(s) {
+  return s.replace(/`/g, "");
+}
+
+// src/report/render-summary.ts
+var ANSI2 = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+function paint2(enabled) {
+  return (code, text) => enabled ? `${code}${text}${ANSI2.reset}` : text;
+}
+var VERDICT_FLAG2 = {
+  green: "GREEN FLAG",
+  yellow: "YELLOW FLAG",
+  red: "RED FLAG"
+};
+function verdictColor2(verdict) {
+  return verdict === "green" ? ANSI2.green : verdict === "yellow" ? ANSI2.yellow : ANSI2.red;
+}
+function renderSummaryTerminal(summary, options = {}) {
+  const c = paint2(options.color ?? false);
+  const lines = [];
+  lines.push("");
+  lines.push(`${c(ANSI2.bold, "goflag")} ${c(ANSI2.dim, summary.url)} ${c(ANSI2.dim, "(summary)")}`);
+  lines.push(
+    `${c(verdictColor2(summary.verdict), VERDICT_FLAG2[summary.verdict])}  ` + c(
+      ANSI2.dim,
+      `${summary.totals.pagesCrawled} pages crawled, ${summary.totals.pagesScanned} scanned`
+    )
+  );
+  lines.push("");
+  lines.push(
+    [
+      metric(c, summary.totals.brokenLinks, "broken link"),
+      metric(c, summary.totals.missingTranslations, "missing translation"),
+      metric(c, summary.totals.seoIssues, "SEO issue"),
+      metric(c, summary.totals.siteIssues, "site issue"),
+      metric(c, summary.totals.unreachablePages, "unreachable page")
+    ].join("   ")
+  );
+  lines.push("");
+  if (summary.unreachablePages.length > 0) {
+    lines.push(c(ANSI2.bold, "Unreachable pages"));
+    for (const page of summary.unreachablePages) {
+      lines.push(`  ${c(ANSI2.red, `[${page.status || "network error"}]`)} ${page.url}`);
+    }
+    lines.push("");
+  }
+  if (summary.brokenLinks.length > 0) {
+    lines.push(c(ANSI2.bold, "Broken links"));
+    for (const link of summary.brokenLinks) {
+      const tag = link.verdict === "broken" ? c(ANSI2.red, `[${link.status || link.reason || "broken"}]`) : c(ANSI2.yellow, `[${link.verdict}${link.reason ? ` ${link.reason}` : ""}]`);
+      lines.push(`  ${tag} ${link.href} ${c(ANSI2.dim, `\xD7${link.count}`)}`);
+      lines.push(`    ${c(ANSI2.dim, `on ${samplePages(link.pages, link.morePages)}`)}`);
+    }
+    lines.push("");
+  }
+  const { holes, reciprocity } = summary.translations;
+  if (holes.length > 0 || reciprocity.length > 0) {
+    lines.push(c(ANSI2.bold, "Missing translations"));
+    for (const hole of holes) {
+      lines.push(
+        `  ${c(ANSI2.cyan, hole.route)} \u2014 missing ${c(ANSI2.yellow, hole.missingLocales.join(", "))}` + c(ANSI2.dim, ` (have ${hole.presentLocales.join(", ")})`)
+      );
+    }
+    for (const issue of reciprocity) {
+      lines.push(`  ${c(ANSI2.yellow, issue.code)} ${c(ANSI2.dim, `\xD7${issue.count}`)}`);
+      lines.push(`    ${stripBackticks2(issue.sample)}`);
+      lines.push(`    ${c(ANSI2.dim, `on ${samplePages(issue.pages, issue.morePages)}`)}`);
+    }
+    lines.push("");
+  }
+  if (summary.seoIssues.length > 0) {
+    lines.push(c(ANSI2.bold, "SEO issues"));
+    lines.push(...rollupRows(summary.seoIssues, c));
+    lines.push("");
+  }
+  if (summary.siteIssues.length > 0) {
+    lines.push(c(ANSI2.bold, "Site-wide issues"));
+    lines.push(...rollupRows(summary.siteIssues, c));
+    lines.push("");
+  }
+  if (summary.verdict === "green") {
+    lines.push(c(ANSI2.green, "No problems found."));
+    lines.push("");
+  }
+  for (const warning of summary.warnings) {
+    lines.push(c(ANSI2.dim, `note: ${warning}`));
+  }
+  if (summary.truncated) {
+    lines.push(c(ANSI2.dim, "note: results truncated by a page/link cap."));
+  }
+  return lines.join("\n");
+}
+function metric(c, n, noun) {
+  const label = `${n} ${noun}${n === 1 ? "" : "s"}`;
+  return n > 0 ? c(ANSI2.bold, c(ANSI2.yellow, label)) : c(ANSI2.dim, label);
+}
+function samplePages(pages, more) {
+  const shown = pages.join(", ");
+  return more > 0 ? `${shown} (+${more} more)` : shown;
+}
+function stripBackticks2(s) {
+  return s.replace(/`/g, "");
+}
+function rollupRows(issues, c) {
+  const lines = [];
+  for (const issue of issues) {
+    const sev = issue.severity === "error" ? c(ANSI2.red, "error") : issue.severity === "warning" ? c(ANSI2.yellow, "warn ") : c(ANSI2.dim, "info ");
+    lines.push(`  ${sev} ${c(ANSI2.cyan, issue.ruleId)} ${c(ANSI2.dim, `\xD7${issue.count}`)}`);
+    if (issue.why) lines.push(`    ${c(ANSI2.dim, stripBackticks2(issue.why))}`);
+    if (issue.fix) {
+      const [head, ...rest] = issue.fix.split("\n");
+      lines.push(`    ${c(ANSI2.dim, "fix:")} ${head}`);
+      for (const line of rest) lines.push(`         ${c(ANSI2.dim, line)}`);
+    }
+    lines.push(`    ${c(ANSI2.dim, `on ${samplePages(issue.pages, issue.morePages)}`)}`);
+  }
+  return lines;
+}
+
+// src/report/summarize.ts
+var SAMPLE_LIMIT = 5;
+function summarize(report) {
+  return {
+    url: report.url,
+    finishedAt: report.finishedAt,
+    verdict: report.summary.verdict,
+    totals: {
+      brokenLinks: report.summary.brokenLinks,
+      missingTranslations: report.summary.missingTranslations,
+      seoIssues: report.summary.seoIssues,
+      siteIssues: report.summary.siteIssues,
+      unreachablePages: report.summary.unreachablePages,
+      pagesCrawled: report.diagnostics.pagesCrawled,
+      pagesScanned: report.diagnostics.pagesScanned,
+      pagesFailed: report.diagnostics.pagesFailed
+    },
+    unreachablePages: report.unreachablePages,
+    brokenLinks: rollupLinks(report),
+    translations: {
+      holes: report.missingTranslations.holes,
+      reciprocity: rollupReciprocity(report)
+    },
+    seoIssues: rollupByRule(report.seoIssues),
+    siteIssues: rollupByRule(report.siteIssues),
+    truncated: report.diagnostics.truncated,
+    warnings: report.diagnostics.warnings
+  };
+}
+function rollupLinks(report) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const link of report.brokenLinks) {
+    const key = `${link.href}\0${link.verdict}`;
+    const existing = groups.get(key);
+    if (existing) {
+      existing.count += 1;
+      if (existing.pages.length < SAMPLE_LIMIT) existing.pages.push(link.pageUrl);
+      else existing.morePages += 1;
+    } else {
+      groups.set(key, {
+        href: link.href,
+        verdict: link.verdict,
+        status: link.status,
+        reason: link.reason,
+        count: 1,
+        pages: [link.pageUrl],
+        morePages: 0
+      });
+    }
+  }
+  return [...groups.values()].sort((a, b) => b.count - a.count || a.href.localeCompare(b.href));
+}
+function rollupByRule(issues) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = groups.get(issue.ruleId);
+    if (existing) {
+      existing.count += 1;
+      if (existing.pages.length < SAMPLE_LIMIT) existing.pages.push(issue.pageUrl);
+      else existing.morePages += 1;
+    } else {
+      groups.set(issue.ruleId, {
+        ruleId: issue.ruleId,
+        severity: issue.severity,
+        why: issue.why,
+        fix: issue.fix,
+        sample: issue.message,
+        count: 1,
+        pages: [issue.pageUrl],
+        morePages: 0
+      });
+    }
+  }
+  const sevRank = { error: 0, warning: 1, info: 2 };
+  return [...groups.values()].sort(
+    (a, b) => sevRank[a.severity] - sevRank[b.severity] || a.ruleId.localeCompare(b.ruleId)
+  );
+}
+function rollupReciprocity(report) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const issue of report.missingTranslations.reciprocity) {
+    const existing = groups.get(issue.code);
+    if (existing) {
+      existing.count += 1;
+      if (existing.pages.length < SAMPLE_LIMIT) existing.pages.push(issue.url);
+      else existing.morePages += 1;
+    } else {
+      groups.set(issue.code, {
+        code: issue.code,
+        count: 1,
+        sample: issue.message,
+        pages: [issue.url],
+        morePages: 0
+      });
+    }
+  }
+  return [...groups.values()].sort((a, b) => b.count - a.count || a.code.localeCompare(b.code));
+}
+
+// src/report/logger.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var BAR_WIDTH = 18;
+var ANSI3 = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m"
+};
+var PHASE_LABEL = {
+  crawl: "crawl",
+  scan: "scan",
+  links: "links"
+};
+var PHASE_HEADER = {
+  crawl: "Crawling pages",
+  scan: "Scanning pages for links",
+  links: "Checking links"
+};
+var PHASE_DONE_NOUN = {
+  crawl: "pages",
+  scan: "pages scanned",
+  links: "links"
+};
+var Logger = class {
+  stream;
+  color;
+  mode;
+  isTTY;
+  spinnerIntervalMs;
+  throttleMs;
+  now;
+  timer;
+  frame = 0;
+  last;
+  lineOpen = false;
+  lastPlainAt = 0;
+  headerShown = {};
+  constructor(options = {}) {
+    this.stream = options.stream ?? process.stderr;
+    this.isTTY = this.stream.isTTY === true;
+    this.color = options.color ?? this.isTTY;
+    this.mode = options.mode ?? "compact";
+    this.spinnerIntervalMs = options.spinnerIntervalMs ?? 80;
+    this.throttleMs = options.throttleMs ?? 250;
+    this.now = options.now ?? Date.now;
+  }
+  paint(code, text) {
+    return this.color ? `${code}${text}${ANSI3.reset}` : text;
+  }
+  /** Print a standalone line (banner, warning). Survives around the spinner. */
+  note(message) {
+    if (this.mode === "quiet") return;
+    this.clearLine();
+    this.stream.write(`${this.paint(ANSI3.dim, message)}
+`);
+    if (this.mode === "compact" && this.last) this.render();
+  }
+  /** Feed one progress tick. */
+  onProgress = (event) => {
+    if (this.mode === "quiet") return;
+    this.last = event;
+    if (this.mode === "verbose") {
+      this.verboseLine(event);
+      return;
+    }
+    if (this.isTTY) {
+      this.ensureTimer();
+      this.render();
+    } else {
+      this.plainThrottled(event);
+    }
+  };
+  /** Stop the spinner and clear the status line so the report starts clean. */
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+    this.clearLine();
+  }
+  // --- rendering ---------------------------------------------------------
+  ensureTimer() {
+    if (this.timer || this.spinnerIntervalMs <= 0) return;
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this.render();
+    }, this.spinnerIntervalMs);
+    this.timer.unref?.();
+  }
+  render() {
+    if (!this.last) return;
+    const line = this.composeLine(this.last);
+    if (this.isTTY) {
+      this.stream.write(`\r\x1B[2K${line}`);
+      this.lineOpen = true;
+    } else {
+      this.stream.write(`${line}
+`);
+    }
+  }
+  composeLine(e) {
+    const spinner = this.paint(ANSI3.cyan, FRAMES[this.frame]);
+    const phase = this.paint(ANSI3.bold, PHASE_LABEL[e.phase]);
+    const counts = `${e.done}/${e.total}`;
+    const bar = this.bar(e.done, e.total);
+    const subject = e.url ? this.paint(ANSI3.dim, this.truncate(e.url)) : "";
+    return [spinner, phase, bar, counts, subject].filter(Boolean).join("  ");
+  }
+  bar(done, total) {
+    if (total <= 0) return "";
+    const ratio = Math.max(0, Math.min(1, done / total));
+    const filled = Math.round(ratio * BAR_WIDTH);
+    const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
+    return this.paint(ANSI3.dim, `[${bar}]`);
+  }
+  verboseLine(e) {
+    if (!this.headerShown[e.phase]) {
+      this.headerShown[e.phase] = true;
+      this.stream.write(`${this.paint(ANSI3.bold, PHASE_HEADER[e.phase])}
+`);
+    }
+    if (e.phase === "crawl" && e.url) {
+      const counts = this.paint(ANSI3.dim, `(${e.done}/${e.total})`);
+      this.stream.write(`  ${this.statusTag(e.status)} ${e.url}  ${counts}
+`);
+    } else if (e.phase === "scan" || e.phase === "links") {
+      if (e.done === e.total && e.total > 0) {
+        this.stream.write(`  ${this.paint(ANSI3.dim, `${e.total} ${PHASE_DONE_NOUN[e.phase]}`)}
+`);
+      }
+    }
+  }
+  statusTag(status) {
+    if (status === void 0) return this.paint(ANSI3.dim, "\xB7\xB7\xB7");
+    if (status >= 200 && status < 300) return this.paint(ANSI3.green, String(status));
+    if (status >= 300 && status < 400) return this.paint(ANSI3.yellow, String(status));
+    return this.paint(ANSI3.red, String(status));
+  }
+  plainThrottled(e) {
+    const t = this.now();
+    const done = e.done === e.total;
+    if (!done && t - this.lastPlainAt < this.throttleMs) return;
+    this.lastPlainAt = t;
+    this.stream.write(`goflag: ${PHASE_LABEL[e.phase]} ${e.done}/${e.total}
+`);
+  }
+  clearLine() {
+    if (this.isTTY && this.lineOpen) {
+      this.stream.write("\r\x1B[2K");
+      this.lineOpen = false;
+    }
+  }
+  truncate(url) {
+    const width = this.stream.columns ?? 80;
+    const budget = Math.max(16, width - 44);
+    if (url.length <= budget) return url;
+    return `\u2026${url.slice(url.length - budget + 1)}`;
+  }
+};
+
+export {
+  routeKey,
+  targetKey,
+  fingerprint,
+  deriveTranslationHoles,
+  exitCode,
+  runAudit,
+  renderTerminal,
+  renderSummaryTerminal,
+  SAMPLE_LIMIT,
+  summarize,
+  Logger
+};
+//# sourceMappingURL=chunk-75OFMTOC.js.map