npm - blume - Versions diffs - 1.0.4 → 1.1.0 - Mend

blume 1.0.4 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

package/CHANGELOG.md +65 -0
package/dist/cli/index.js +13255 -10232
package/dist/cli/index.js.map +91 -60
package/dist/types/core/config-input.d.ts +61 -1
package/dist/types/core/data.d.ts +9 -0
package/dist/types/core/deployment-env.d.ts +6 -0
package/dist/types/core/diagnostics.d.ts +23 -0
package/dist/types/core/i18n-ui.d.ts +8 -8
package/dist/types/core/schema.d.ts +131 -22
package/dist/types/core/sources/types.d.ts +3 -1
package/dist/types/core/standard-schema.d.ts +41 -0
package/dist/types/core/types.d.ts +13 -0
package/dist/types/og/card.d.ts +63 -0
package/dist/types/og/dimensions.d.ts +12 -0
package/docs/01-quickstart.mdx +1 -1
package/docs/02-deployment.mdx +9 -1
package/docs/advanced/api-reference.mdx +11 -0
package/docs/advanced/changelog.mdx +1 -1
package/docs/advanced/skills.mdx +1 -1
package/docs/configuration/ai.mdx +1 -1
package/docs/configuration/customization.mdx +1 -1
package/docs/configuration/export.mdx +1 -1
package/docs/configuration/index.mdx +21 -1
package/docs/configuration/search.mdx +28 -1
package/docs/configuration/seo.mdx +21 -2
package/docs/configuration/theming.mdx +1 -1
package/docs/content/components.mdx +14 -0
package/docs/content/index.mdx +1 -1
package/docs/content/meta.mdx +1 -1
package/docs/content/navigation.mdx +1 -1
package/docs/content/sources.mdx +1 -1
package/docs/reference/cli.mdx +79 -1
package/docs/reference/frontmatter.mdx +29 -1
package/package.json +3 -3
package/skills/blume-migrate/SKILL.md +1 -1
package/skills/blume-migrate/references/mintlify.md +3 -2
package/skills/blume-migrate/scripts/mintlify-codemod.mjs +16 -4
package/src/ai/llms.ts +15 -0
package/src/astro/adapter-root.ts +70 -0
package/src/astro/generate.ts +50 -19
package/src/astro/index.ts +1 -0
package/src/astro/pages.ts +18 -3
package/src/astro/templates.ts +65 -22
package/src/audit/agent.ts +114 -0
package/src/audit/catalog.ts +826 -0
package/src/audit/checks/assets.ts +177 -0
package/src/audit/checks/content.ts +231 -0
package/src/audit/checks/duplicates.ts +131 -0
package/src/audit/checks/i18n.ts +246 -0
package/src/audit/checks/indexability.ts +213 -0
package/src/audit/checks/links.ts +223 -0
package/src/audit/checks/llms.ts +135 -0
package/src/audit/checks/network.ts +272 -0
package/src/audit/checks/og-image.ts +113 -0
package/src/audit/checks/redirects.ts +87 -0
package/src/audit/checks/robots.ts +114 -0
package/src/audit/checks/sitemap.ts +229 -0
package/src/audit/checks/social.ts +238 -0
package/src/audit/crawl.ts +259 -0
package/src/audit/graph.ts +74 -0
package/src/audit/html.ts +54 -0
package/src/audit/image-size.ts +63 -0
package/src/audit/locate.ts +33 -0
package/src/audit/redirects.ts +74 -0
package/src/audit/report.ts +278 -0
package/src/audit/run.ts +198 -0
package/src/audit/snapshot.ts +189 -0
package/src/audit/types.ts +214 -0
package/src/audit/url.ts +103 -0
package/src/cli/commands/audit.ts +205 -0
package/src/cli/commands/build.ts +51 -12
package/src/cli/index.ts +2 -0
package/src/components/content/Tabs.astro +98 -15
package/src/components/layout/Breadcrumbs.astro +1 -1
package/src/components/layout/Header.astro +1 -0
package/src/components/layout/PageFeedback.astro +1 -1
package/src/components/layout/PageLayout.astro +5 -1
package/src/components/layout/Pagination.astro +1 -1
package/src/components/layout/RootLayout.astro +5 -3
package/src/components/layout/Search.astro +35 -6
package/src/components/layout/TableOfContents.astro +1 -1
package/src/components/openapi/Authorization.astro +80 -0
package/src/components/openapi/Operation.astro +19 -1
package/src/components/openapi/ParametersTable.astro +1 -1
package/src/components/openapi/security.ts +201 -0
package/src/components/openapi/snippets.ts +42 -13
package/src/core/config-input.ts +66 -1
package/src/core/data.ts +9 -1
package/src/core/deployment-env.ts +9 -0
package/src/core/diagnostics.ts +59 -12
package/src/core/links.ts +2 -91
package/src/core/nav-diagnostics.ts +48 -4
package/src/core/probe.ts +136 -0
package/src/core/project-graph.ts +8 -0
package/src/core/schema.ts +86 -3
package/src/core/sources/normalize.ts +198 -25
package/src/core/sources/types.ts +3 -1
package/src/core/standard-schema.ts +54 -0
package/src/core/types.ts +13 -0
package/src/deploy/adapter-output.ts +27 -15
package/src/deploy/headers.ts +66 -0
package/src/deploy/redirects.ts +49 -9
package/src/og/card.ts +98 -33
package/src/og/index.ts +1 -1
package/src/search/popular.ts +33 -0
package/src/theme/entry.ts +6 -1

package/src/audit/checks/i18n.ts ADDED Viewed

@@ -0,0 +1,246 @@
+import { normalizeBasePath, stripBasePath } from "../../core/base-path.ts";
+import type { Diagnostic } from "../../core/types.ts";
+import { finding } from "../catalog.ts";
+import { pageSite } from "../locate.ts";
+import type { AuditContext, CheckModule, PageSnapshot } from "../types.ts";
+import { normalizePath } from "../url.ts";
+/** The normalized `deployment.base` — hreflang hrefs carry it, page URLs don't. */
+const deployBaseOf = (context: AuditContext): string =>
+  normalizeBasePath(context.project.config.deployment.base);
+/** The hreflang value meaning "use this when nothing else matches". Not a locale. */
+const X_DEFAULT = "x-default";
+const isValidBcp47 = (tag: string): boolean => {
+  try {
+    Intl.getCanonicalLocales(tag);
+    return true;
+  } catch {
+    return false;
+  }
+};
+/** The site path an hreflang `href` points at, or null when it isn't parseable. */
+const alternatePath = (href: string, deployBase: string): string | null => {
+  try {
+    return normalizePath(stripBasePath(deployBase, new URL(href).pathname));
+  } catch {
+    return null;
+  }
+};
+const langChecks = (
+  context: AuditContext,
+  page: PageSnapshot
+): Diagnostic[] => {
+  if (!page.lang) {
+    return [
+      finding(
+        "BLUME_AUDIT_HTML_LANG_MISSING",
+        pageSite(context, page),
+        "The <html> element has no lang attribute."
+      ),
+    ];
+  }
+  if (!isValidBcp47(page.lang)) {
+    return [
+      finding(
+        "BLUME_AUDIT_HTML_LANG_INVALID",
+        pageSite(context, page),
+        `"${page.lang}" is not a valid BCP 47 language tag.`
+      ),
+    ];
+  }
+  return [];
+};
+/**
+ * Every hreflang finding for one page: validity, self-reference, x-default, and
+ * whether each alternate points at a real, canonical page.
+ */
+const hreflangChecks = (
+  context: AuditContext,
+  page: PageSnapshot
+): Diagnostic[] => {
+  const found: Diagnostic[] = [];
+  const seen = new Map<string, string[]>();
+  const deployBase = deployBaseOf(context);
+  for (const alternate of page.hreflang) {
+    if (alternate.lang !== X_DEFAULT && !isValidBcp47(alternate.lang)) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_INVALID",
+          pageSite(context, page),
+          `hreflang="${alternate.lang}" is not a valid BCP 47 language tag.`
+        )
+      );
+      continue;
+    }
+    const hrefs = seen.get(alternate.lang) ?? [];
+    hrefs.push(alternate.href);
+    seen.set(alternate.lang, hrefs);
+    const path = alternatePath(alternate.href, deployBase);
+    if (path === null) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_BAD_TARGET",
+          pageSite(context, page),
+          `hreflang="${alternate.lang}" points at "${alternate.href}", which is not an absolute URL.`
+        )
+      );
+      continue;
+    }
+    const target = context.byUrl.get(path);
+    const redirect = context.redirects.find(
+      (entry) => normalizePath(entry.from) === path
+    );
+    if (redirect) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_BAD_TARGET",
+          pageSite(context, page),
+          `hreflang="${alternate.lang}" points at ${path}, which redirects to ${redirect.to}.`
+        )
+      );
+    } else if (!target) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_BAD_TARGET",
+          pageSite(context, page),
+          `hreflang="${alternate.lang}" points at ${path}, which the build does not serve.`
+        )
+      );
+    } else if (
+      target.canonical &&
+      alternatePath(target.canonical, deployBase) !== normalizePath(target.url)
+    ) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_BAD_TARGET",
+          pageSite(context, page),
+          `hreflang="${alternate.lang}" points at ${path}, which canonicalizes elsewhere.`
+        )
+      );
+    }
+  }
+  // One language may name exactly one page.
+  for (const [lang, hrefs] of seen) {
+    if (hrefs.length > 1) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_CONFLICT",
+          pageSite(context, page),
+          `hreflang="${lang}" is declared ${hrefs.length} times, pointing at ${hrefs.join(", ")}.`
+        )
+      );
+    }
+  }
+  const self = page.hreflang.find(
+    (alternate) =>
+      alternatePath(alternate.href, deployBase) === normalizePath(page.url)
+  );
+  if (self) {
+    if (page.lang && self.lang !== X_DEFAULT && self.lang !== page.lang) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_HREFLANG_LANG_MISMATCH",
+          pageSite(context, page),
+          `Page declares <html lang="${page.lang}"> but its own hreflang is "${self.lang}".`
+        )
+      );
+    }
+  } else {
+    found.push(
+      finding(
+        "BLUME_AUDIT_HREFLANG_SELF_MISSING",
+        pageSite(context, page),
+        "Page's hreflang set does not include a self-reference."
+      )
+    );
+  }
+  if (!page.hreflang.some((alternate) => alternate.lang === X_DEFAULT)) {
+    found.push(
+      finding(
+        "BLUME_AUDIT_HREFLANG_XDEFAULT_MISSING",
+        pageSite(context, page),
+        "Page's hreflang set has no x-default alternate."
+      )
+    );
+  }
+  return found;
+};
+/**
+ * Reciprocity: if A names B as its alternate, B must name A back. Google ignores
+ * a whole hreflang group when the return tags don't line up.
+ *
+ * This is the hardest check for a real crawler — it has to hold the entire site
+ * in memory and cross-reference it. We already do.
+ */
+const returnTagChecks = (context: AuditContext): Diagnostic[] => {
+  const found: Diagnostic[] = [];
+  const deployBase = deployBaseOf(context);
+  for (const page of context.pages) {
+    for (const alternate of page.hreflang) {
+      if (alternate.lang === X_DEFAULT) {
+        continue;
+      }
+      const path = alternatePath(alternate.href, deployBase);
+      if (path === null || path === normalizePath(page.url)) {
+        continue;
+      }
+      const target = context.byUrl.get(path);
+      if (!target || target.hreflang.length === 0) {
+        // A missing or hreflang-less target is already reported as a bad target.
+        continue;
+      }
+      const returns = target.hreflang.some(
+        (back) =>
+          alternatePath(back.href, deployBase) === normalizePath(page.url)
+      );
+      if (!returns) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_HREFLANG_NO_RETURN_TAG",
+            pageSite(context, page),
+            `Page names ${path} as its "${alternate.lang}" alternate, but ${path} does not name it back.`
+          )
+        );
+      }
+    }
+  }
+  return found;
+};
+/**
+ * Language declarations: `<html lang>` on every page, plus the full hreflang
+ * cluster on pages that have translations.
+ *
+ * The hreflang checks are gated on the page actually carrying hreflang tags
+ * rather than on `config.i18n`, so a monolingual site sees exactly zero of them
+ * — but still gets its `<html lang>` validated, which is a real bug on any site.
+ */
+export const i18nChecks: CheckModule = {
+  category: "i18n",
+  run(context) {
+    const found: Diagnostic[] = [];
+    for (const page of context.pages) {
+      found.push(...langChecks(context, page));
+      if (page.hreflang.length > 0) {
+        found.push(...hreflangChecks(context, page));
+      }
+    }
+    found.push(...returnTagChecks(context));
+    return found;
+  },
+  tier: "static",
+};

package/src/audit/checks/indexability.ts ADDED Viewed

@@ -0,0 +1,213 @@
+import { SITE_INFERRING_ADAPTERS } from "../../core/deployment-env.ts";
+import type { Diagnostic } from "../../core/types.ts";
+import { finding } from "../catalog.ts";
+import { pageSite } from "../locate.ts";
+import { ERROR_ROUTES } from "../types.ts";
+import type { AuditContext, CheckModule, PageSnapshot } from "../types.ts";
+import { normalizePath, siteOrigin } from "../url.ts";
+/** The canonical URL parsed, or null when it isn't a usable absolute URL. */
+const parseCanonical = (page: PageSnapshot): URL | null => {
+  if (!page.canonical) {
+    return null;
+  }
+  try {
+    return new URL(page.canonical);
+  } catch {
+    return null;
+  }
+};
+const canonicalChecks = (
+  context: AuditContext,
+  page: PageSnapshot
+): Diagnostic[] => {
+  const { site } = context.project.config.deployment;
+  const origin = siteOrigin(site);
+  // Error routes are noindex by design, so a canonical on them is meaningless
+  // and its absence isn't a defect — flagging /404 would be a guaranteed
+  // finding on every site that has an error page.
+  if (ERROR_ROUTES.has(page.url)) {
+    return [];
+  }
+  if (!page.canonical) {
+    // Without `deployment.site` Blume has no absolute URL to canonicalize to, so
+    // report the root cause once (in the sitemap/robots checks) rather than
+    // flagging every page for a config field they can't fix individually.
+    return site
+      ? [
+          finding(
+            "BLUME_AUDIT_CANONICAL_MISSING",
+            pageSite(context, page),
+            "Page has no canonical URL."
+          ),
+        ]
+      : [];
+  }
+  const canonical = parseCanonical(page);
+  if (!canonical) {
+    return [
+      finding(
+        "BLUME_AUDIT_CANONICAL_BAD_TARGET",
+        pageSite(context, page, ["seo", "canonical"]),
+        `Canonical "${page.canonical}" is not a valid absolute URL.`
+      ),
+    ];
+  }
+  const found: Diagnostic[] = [];
+  if (origin && canonical.origin !== origin) {
+    const sameHost = canonical.host === new URL(origin).host;
+    // A different *protocol* on the same host is a misconfiguration worth
+    // calling out; a different host entirely is a deliberate cross-site
+    // canonical, which is legitimate.
+    if (sameHost) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_CANONICAL_PROTOCOL_MISMATCH",
+          pageSite(context, page, ["seo", "canonical"]),
+          `Canonical uses ${canonical.protocol}// but the site is ${new URL(origin).protocol}//.`
+        )
+      );
+    }
+    return found;
+  }
+  const target = normalizePath(canonical.pathname);
+  if (target === normalizePath(page.url)) {
+    return found;
+  }
+  // The canonical points at another page on this site. It must exist, and it
+  // must not itself redirect — a canonical to a redirect is a dead end.
+  const redirect = context.redirects.find(
+    (entry) => normalizePath(entry.from) === target
+  );
+  if (redirect) {
+    found.push(
+      finding(
+        "BLUME_AUDIT_CANONICAL_BAD_TARGET",
+        pageSite(context, page, ["seo", "canonical"]),
+        `Canonical points at ${target}, which is a redirect to ${redirect.to}.`
+      )
+    );
+  } else if (context.byUrl.has(target)) {
+    found.push(
+      finding(
+        "BLUME_AUDIT_CANONICAL_NOT_SELF",
+        pageSite(context, page, ["seo", "canonical"]),
+        `Page declares ${target} as its canonical, so it will not be indexed itself.`
+      )
+    );
+  } else {
+    found.push(
+      finding(
+        "BLUME_AUDIT_CANONICAL_BAD_TARGET",
+        pageSite(context, page, ["seo", "canonical"]),
+        `Canonical points at ${target}, which is not a page on this site.`
+      )
+    );
+  }
+  return found;
+};
+/**
+ * Whether and how a page can be indexed: its canonical, its robots meta, and
+ * whether Googlebot will read all of it.
+ */
+export const indexabilityChecks: CheckModule = {
+  category: "indexability",
+  run(context) {
+    const found: Diagnostic[] = [];
+    // Without `deployment.site` Blume has no absolute URL to build from, so it
+    // cannot emit a canonical, an Open Graph image, or a sitemap on *any* page.
+    // That's one fact about the config, not a defect on each of 200 pages —
+    // report it once, and let the checks that depend on it stay quiet.
+    if (!context.project.config.deployment.site) {
+      const { adapter } = context.project.config.deployment;
+      const site = {
+        file: context.project.context.configFile ?? undefined,
+        url: "/",
+      };
+      // On a platform adapter the value arrives from the platform's env vars
+      // at deploy time (`applyDeploymentEnv`), so only this local artifact is
+      // missing it — the deployed site won't be. Hardcoding `deployment.site`
+      // would duplicate state the platform owns, so the finding (which agents
+      // apply verbatim via `--claude`/`--codex`) must not suggest it.
+      found.push(
+        adapter && SITE_INFERRING_ADAPTERS.has(adapter)
+          ? finding(
+              "BLUME_AUDIT_SITE_INFERRED_AT_DEPLOY",
+              site,
+              `deployment.site is not set in this build — on ${adapter} it is inferred from the platform env at deploy time, so canonical URLs, Open Graph images, and the sitemap are only missing from this local artifact.`
+            )
+          : finding(
+              "BLUME_AUDIT_SITE_NOT_SET",
+              site,
+              "deployment.site is not set, so no canonical URLs, Open Graph images, or sitemap can be generated."
+            )
+      );
+    }
+    for (const page of context.pages) {
+      found.push(...canonicalChecks(context, page));
+      // Error routes are *meant* to carry noindex, so reporting them would be a
+      // guaranteed finding on every site that has a 404 page. A robots meta
+      // that doesn't noindex (an ejected layout emitting `index, follow`)
+      // leaves the page indexable and isn't this finding.
+      if (page.robots && !page.indexable && !ERROR_ROUTES.has(page.url)) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_ROBOTS_META_UNEXPECTED",
+            pageSite(context, page, ["noindex"]),
+            `Page declares robots "${page.robots}" and will not be indexed.`
+          )
+        );
+        // Google warns against pairing the two: the canonical says "index that
+        // URL", the robots meta says "don't trust this page's signals" — and
+        // which one wins is undefined.
+        if (!page.indexable && page.canonical) {
+          found.push(
+            finding(
+              "BLUME_AUDIT_CANONICAL_ON_NOINDEX",
+              pageSite(context, page, ["noindex"]),
+              `Page is noindex but declares ${page.canonical} as its canonical.`
+            )
+          );
+        }
+      }
+      // Only the manifest knows a page was a draft — the built HTML looks like
+      // any other page, which is exactly why deploying a `--preview` build is
+      // so easy to miss.
+      if (page.route?.draft) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_DRAFT_PAGE_PUBLISHED",
+            pageSite(context, page, ["draft"]),
+            `${page.url} is marked draft in its front matter but is in the build.`
+          )
+        );
+      }
+      if (page.bytes > context.thresholds.maxHtmlBytes) {
+        const mb = (page.bytes / 1024 / 1024).toFixed(1);
+        found.push(
+          finding(
+            "BLUME_AUDIT_HTML_TOO_LARGE",
+            pageSite(context, page),
+            `Page HTML is ${mb} MB — past Googlebot's 2 MB limit, the rest is not crawled.`
+          )
+        );
+      }
+    }
+    return found;
+  },
+  tier: "static",
+};

package/src/audit/checks/links.ts ADDED Viewed

@@ -0,0 +1,223 @@
+import { normalizeBasePath } from "../../core/base-path.ts";
+import type { Diagnostic } from "../../core/types.ts";
+import { finding } from "../catalog.ts";
+import { orphanPages } from "../graph.ts";
+import { pageSite } from "../locate.ts";
+import type {
+  AuditContext,
+  CheckModule,
+  PageSnapshot,
+  SnapshotLink,
+} from "../types.ts";
+import { normalizePath, resolveHref, siteOrigin } from "../url.ts";
+/** Whether a path is served by the build — as a page, or as a static file. */
+const isServed = (context: AuditContext, path: string): boolean =>
+  context.byUrl.has(path) ||
+  context.files.has(path) ||
+  // Astro's directory format serves `/docs/api` from `/docs/api/index.html`.
+  context.files.has(`${path}/index.html`);
+/** Browser-magic fragments that scroll without needing a matching id. */
+const MAGIC_FRAGMENTS = new Set(["", "top"]);
+/** Whether a fragment lands on an id of the target page. */
+const anchorResolves = (target: PageSnapshot, fragment: string): boolean => {
+  if (MAGIC_FRAGMENTS.has(fragment)) {
+    return true;
+  }
+  // Hrefs usually carry the fragment percent-encoded while the HTML id is not;
+  // check both spellings so an encoded match isn't reported as broken.
+  try {
+    return (
+      target.ids.has(fragment) || target.ids.has(decodeURIComponent(fragment))
+    );
+  } catch {
+    return target.ids.has(fragment);
+  }
+};
+const redirectFrom = (context: AuditContext, path: string) =>
+  context.redirects.find((entry) => normalizePath(entry.from) === path);
+/**
+ * Internal links, and what they land on.
+ *
+ * Broken *chrome* links are deduplicated by target: Blume renders the sidebar on
+ * every page, so one bad nav entry would otherwise be reported once per page —
+ * hundreds of findings for a single typo. Body links are reported per
+ * occurrence, because each one lives in a different `.mdx` a reader can go fix.
+ */
+export const linkChecks: CheckModule = {
+  category: "links",
+  run(context) {
+    const found: Diagnostic[] = [];
+    const origin = siteOrigin(context.project.config.deployment.site);
+    const deployBase = normalizeBasePath(
+      context.project.config.deployment.base
+    );
+    /** Broken chrome targets, and the first page each was seen on. */
+    const brokenChrome = new Map<string, PageSnapshot>();
+    const redirectedChrome = new Map<string, PageSnapshot>();
+    /** Broken anchor targets in chrome (`url#frag`), first page each was seen on. */
+    const brokenChromeAnchors = new Map<string, PageSnapshot>();
+    /**
+     * A fragment must land on an id of the page it targets — a miss loads the
+     * page but silently dumps the reader at the top, which no crawler reports
+     * because the HTTP response is a healthy 200.
+     */
+    const checkAnchor = (
+      page: PageSnapshot,
+      link: SnapshotLink,
+      target: PageSnapshot,
+      fragment: string
+    ): void => {
+      if (anchorResolves(target, fragment)) {
+        return;
+      }
+      const where =
+        target === page ? "this page" : `${target.url}, which has no such id`;
+      if (link.content) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_ANCHOR_BROKEN",
+            pageSite(context, page),
+            `Link to ${link.href} points at #${fragment} on ${where}.`
+          )
+        );
+      } else {
+        const key = `${target.url}#${fragment}`;
+        if (!brokenChromeAnchors.has(key)) {
+          brokenChromeAnchors.set(key, page);
+        }
+      }
+    };
+    const classify = (page: PageSnapshot, link: SnapshotLink): void => {
+      // Same-page anchors (`#setup`) never leave the page, so resolveHref
+      // files them under "ignored" — but their fragment still has to exist.
+      if (link.href.startsWith("#")) {
+        checkAnchor(page, link, page, link.href.slice(1));
+        return;
+      }
+      const resolved = resolveHref(page.url, link.href, origin, deployBase);
+      if (resolved.kind === "external" || resolved.kind === "ignored") {
+        return;
+      }
+      const anchorTarget = resolved.hash
+        ? context.byUrl.get(resolved.path)
+        : undefined;
+      if (anchorTarget) {
+        checkAnchor(page, link, anchorTarget, resolved.hash);
+      }
+      if (resolved.kind === "self-origin") {
+        found.push(
+          finding(
+            "BLUME_AUDIT_INTERNAL_LINK_ABSOLUTE",
+            pageSite(context, page),
+            `Link to ${link.href} hardcodes the site's origin; use ${resolved.path} instead.`
+          )
+        );
+      }
+      if (link.rel?.includes("nofollow")) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_INTERNAL_LINK_NOFOLLOW",
+            pageSite(context, page),
+            `Internal link to ${resolved.path} is rel="nofollow".`
+          )
+        );
+      }
+      const { path } = resolved;
+      const redirect = redirectFrom(context, path);
+      if (redirect) {
+        if (link.content) {
+          found.push(
+            finding(
+              "BLUME_AUDIT_LINK_TO_REDIRECT",
+              pageSite(context, page),
+              `Link to ${path} goes through a redirect to ${redirect.to}.`
+            )
+          );
+        } else if (!redirectedChrome.has(path)) {
+          redirectedChrome.set(path, page);
+        }
+        return;
+      }
+      if (isServed(context, path)) {
+        return;
+      }
+      if (link.content) {
+        found.push(
+          finding(
+            "BLUME_AUDIT_LINK_TO_BROKEN",
+            pageSite(context, page),
+            `Link to ${link.href} resolves to ${path}, which the build does not serve.`
+          )
+        );
+      } else if (!brokenChrome.has(path)) {
+        brokenChrome.set(path, page);
+      }
+    };
+    for (const page of context.pages) {
+      for (const link of page.links) {
+        classify(page, link);
+      }
+    }
+    for (const [path, page] of brokenChrome) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_LINK_TO_BROKEN",
+          { url: page.url },
+          `Navigation links to ${path}, which the build does not serve.`,
+          "Fix the entry in your navigation config or meta file."
+        )
+      );
+    }
+    for (const [path, page] of redirectedChrome) {
+      const redirect = redirectFrom(context, path);
+      found.push(
+        finding(
+          "BLUME_AUDIT_LINK_TO_REDIRECT",
+          { url: page.url },
+          `Navigation links to ${path}, which redirects to ${redirect?.to}.`,
+          "Point the navigation entry straight at the destination."
+        )
+      );
+    }
+    for (const [key, page] of brokenChromeAnchors) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_ANCHOR_BROKEN",
+          { url: page.url },
+          `Navigation links to ${key}, but the target page has no such id.`
+        )
+      );
+    }
+    const homeUrl = normalizeBasePath(context.project.config.basePath) || "/";
+    for (const page of orphanPages(context.pages, context.graph, homeUrl)) {
+      found.push(
+        finding(
+          "BLUME_AUDIT_ORPHAN_PAGE",
+          pageSite(context, page),
+          "No other page's body links here — it is reachable only from the sidebar."
+        )
+      );
+    }
+    return found;
+  },
+  tier: "static",
+};