blume 2.1.2 → 2.2.0

package/src/astro/templates.ts

@@ -10,7 +10,7 @@ import { buildHomeLinkHeader } from "../ai/link-headers.ts";
 import type { CaptchaAdapter } from "../captcha/schema.ts";
 import { CONSENT_CLIENT_MODULES } from "../consent/clients.ts";
 import { normalizeBasePath } from "../core/base-path.ts";
-import { TOC_HIDDEN_KEY } from "../core/heading-markers.ts";
+import { TOC_HIDDEN_KEY, TOC_TEXT_KEY } from "../core/heading-markers.ts";
 import {
   compileEveryRedirect,
   isPatternPath,
@@ -22,15 +22,18 @@ import { BLUME_IGNORE_DIRS } from "../core/sources/watch.ts";
 import { trimChar } from "../core/trim.ts";
 import type { ProjectContext } from "../core/types.ts";
 import { hasVariables } from "../core/variables.ts";
+import { getBlumeVersion } from "../core/version.ts";
 import { deployPassthrough } from "../deploy/adapters/types.ts";
 import { SVG_ASSET_HEADERS } from "../deploy/headers.ts";
 import { deployPlatform } from "../deploy/platforms/index.ts";
 import { adapterRoot, distDir } from "../deploy/platforms/paths.ts";
 import {
   applyBaseToAstroRedirects,
+  isPageIndexFile,
   withMirrorRedirects,
 } from "../deploy/redirects.ts";
 import { API_RAIL_KEY } from "../markdown/api-rail.ts";
+import { TITLE_ID_KEY } from "../markdown/title-heading.ts";
 import { VIEWS_KEY } from "../markdown/views.ts";
 import type { OgCache } from "../og/cache.ts";
 import type { OgFont, OgFontFamilies, OgGoogleFont } from "../og/card.ts";
@@ -717,8 +720,16 @@ export const astroConfigTemplate = (options: {
   // Only exact redirects: Astro can't prerender a pattern's redirect pages
   // (it would need every path the pattern covers), so a pattern reaches the
   // dev server through the integration and each host through its own rules.
+  // Nor one from a page's own `index.html` in a static build, where Astro
+  // would write its redirect page inside the page's file (see
+  // `isPageIndexFile`); the host files and the dev server still carry it.
+  const staticOutput = deployment.options.output === "static";
   const exactRedirects = basedRedirects.filter(
-    (redirect) => !isPatternPath(redirect.from)
+    (redirect) =>
+      !(
+        isPatternPath(redirect.from) ||
+        (staticOutput && isPageIndexFile(redirect.from, redirectPages))
+      )
   );
   const redirectsOption =
     exactRedirects.length > 0
@@ -801,6 +812,7 @@ export const astroConfigTemplate = (options: {
   const blumeImports = [
     "blumeIntegration",
     "includeHmrPlugin",
+    "mdxSourceErrorsPlugin",
     "prerenderDepsPlugin",
     ...runtimeModuleImports,
     ...(adapterOption.includes("withAdapterRoot") ? ["withAdapterRoot"] : []),
@@ -909,10 +921,10 @@ ${userConfigSetup}export default defineConfig({
   devToolbar: { enabled: false },
   // One canonical URL per page: canonicals, the sitemap, and hreflang all use
   // the slashless form, so the slashed spelling is not a second address. Astro
-  // applies this itself — its dev server answers a slashed URL with a 404 that
-  // names the setting, an on-demand route redirects — and the Vercel adapter
-  // turns it into the platform's 308 route, so the Build Output config needs
-  // no hand-spliced redirect (see deploy/vercel-negotiation.ts). Static hosts
+  // applies this itself — an on-demand route redirects, and the integration
+  // has the dev server redirect too, ahead of Astro's own 404 — and the Vercel
+  // adapter turns it into the platform's 308 route, so the Build Output config
+  // needs no hand-spliced redirect (see deploy/vercel-negotiation.ts). Static hosts
   // serve the \`index.html\` directory layout as they always did.
   trailingSlash: "never",
   // The layouts render Astro's <ClientRouter />, and its in-place swaps read
@@ -930,7 +942,7 @@ ${userConfigSetup}export default defineConfig({
     plugins: [${runtimeModulesPluginEntry}${variablesPluginEntry}tailwindcss(), includeHmrPlugin(${configPath(
       `${context.outDir}/src/generated/includes.json`,
       ejected
-    )}), prerenderDepsPlugin()],
+    )}), mdxSourceErrorsPlugin(), prerenderDepsPlugin()],
     build: {${features.mermaid ? MERMAID_CHUNK_LIMIT : ""}
       rolldownOptions: {
         ${ROLLDOWN_ON_LOG},
@@ -1031,6 +1043,13 @@ const runtimeDirWithin = (base: string, outDir: string): string | null => {
 const astroGlobBase = (base: string): string =>
   isAbsolute(base) ? pathToFileURL(base).href : base;
 
+// The characters a glob reads as syntax; a `(group)` folder has two.
+const GLOB_SYNTAX = /[!()*+?@[\\\]{|}]/gu;
+
+/** A relative path as a glob that matches only that file. */
+const escapeGlob = (path: string): string =>
+  path.replaceAll(GLOB_SYNTAX, String.raw`\$&`);
+
 /** Generate `.blume/src/content.config.ts`. */
 export const contentConfigTemplate = (options: {
   context: ProjectContext;
@@ -1051,6 +1070,13 @@ export const contentConfigTemplate = (options: {
    * a non-filesystem source), the collection globs nothing — see below.
    */
   filesystem?: boolean;
+  /**
+   * Absolute paths of `.mdx` files the build dropped because they don't
+   * parse. Astro compiles every `.mdx` file in the collection, routed or
+   * not, so each is left out of the glob, or a `--no-strict` build would
+   * still fail on it.
+   */
+  unparsable?: readonly string[];
 }): string => {
   const { context, config } = options;
   const stagedBase = options.stagedBase ?? stagedContentDir(context.outDir);
@@ -1087,6 +1113,12 @@ export const contentConfigTemplate = (options: {
           dir === ".blume" ? [] : [`!**/${dir}/**`]
         ),
         ...outDirIgnore,
+        ...(options.unparsable ?? []).flatMap((file) => {
+          const rel = relative(collectionBase, file);
+          return rel.startsWith("..") || isAbsolute(rel)
+            ? []
+            : [`!${escapeGlob(rel)}`];
+        }),
       ]
     : [];
 
@@ -1118,6 +1150,10 @@ import { pageCollectionSchema } from "blume/core/schema.ts";
 // pageCollectionSchema is the scan's page front-matter schema, so entry.data
 // is typed and normalized the same way; it passes custom keys through and
 // falls back to defaults for a page the scan already dropped as invalid.
+//
+// Astro's content store re-parses an entry only when its file or this config
+// changes, so naming the Blume version (${getBlumeVersion()}) here re-parses
+// every entry after an upgrade: none keeps what an older schema produced.
 const docs = defineCollection({
   loader: withIncludeRefresh(glob({
     pattern: ${JSON.stringify(docsPattern)},
@@ -1831,7 +1867,10 @@ export function GET({ props }: { props: { route: string } }) {
  *   - `content/<project-relative path>` — colocated content images
  *     (`![alt](./diagram.png)`), served as originals for the agent-facing
  *     Markdown endpoints (the HTML render uses the `astro:assets`-optimized
- *     copies instead). The mapping comes from `generated/content-assets.json`.
+ *     copies instead), and the other files beside a page that its links and
+ *     element URLs name (`[spec](./spec.pdf)`, `<img src="./a.png">`), which
+ *     the HTML render points here too. The mapping comes from
+ *     `generated/content-assets.json`.
  *   - `<source>/<hash>.<ext>` — remote-source images the scan pipeline
  *     materializes under `.blume/public/blume-assets` (see
  *     `core/sources/assets.ts`). That directory is NOT Astro's `publicDir`
@@ -1874,11 +1913,25 @@ const TYPES: Record<string, string> = {
   ".webp": "image/webp",
 };
 
+// The other files a page's links name beside it, typed so the dev server
+// opens them the way a static host would. Anything else downloads.
+const FILE_TYPES: Record<string, string> = {
+  ".csv": "text/csv; charset=utf-8",
+  ".json": "application/json",
+  ".mp3": "audio/mpeg",
+  ".pdf": "application/pdf",
+  ".txt": "text/plain; charset=utf-8",
+  ".wav": "audio/wav",
+  ".zip": "application/zip",
+};
+
 const extensionOf = (path: string): string =>
   path.slice(path.lastIndexOf(".")).toLowerCase();
 
 const contentType = (path: string): string =>
-  TYPES[extensionOf(path)] ?? "application/octet-stream";
+  TYPES[extensionOf(path)] ??
+  FILE_TYPES[extensionOf(path)] ??
+  "application/octet-stream";
 
 // A source downloads only images and videos; anything else in the staged
 // directory (a page an older build saved under its URL's extension) is never
@@ -2340,6 +2393,7 @@ import Badge from "blume/components/content/Badge.astro";
 import Callout from "blume/components/content/Callout.astro";
 import Card from "blume/components/content/Card.astro";
 import CardGroup from "blume/components/content/CardGroup.astro";
+import Changelog from "blume/components/content/Changelog.astro";
 import CodeBlock from "blume/components/content/CodeBlock.astro";
 import CodeGroup from "blume/components/content/CodeGroup.astro";
 import ColorRoot from "blume/components/content/Color.astro";
@@ -2393,6 +2447,7 @@ ${mathImport}import { mdxComponents as userMdx, layoutOverrides } from "../gener
   Callout,
   Card,
   CardGroup,
+  Changelog,
   CodeBlock,
   CodeGroup,
   Color,
@@ -2513,10 +2568,25 @@ const views = Array.isArray(viewsRaw)
   : [];
 const tocHiddenRaw = remarkPluginFrontmatter?.${TOC_HIDDEN_KEY};
 const tocHidden = new Set(Array.isArray(tocHiddenRaw) ? tocHiddenRaw : []);
-const headings =
+// A heading holding a \`<Badge>\` lists without the badge's text, which the
+// heading plugin reports by slug the same way.
+const tocTextRaw = remarkPluginFrontmatter?.${TOC_TEXT_KEY};
+const tocText = tocTextRaw && typeof tocTextRaw === "object" ? tocTextRaw : {};
+const headings = (
   tocHidden.size > 0
     ? allHeadings.filter((heading) => !tocHidden.has(heading.slug))
-    : allHeadings;
+    : allHeadings
+).map((heading) =>
+  typeof tocText[heading.slug] === "string"
+    ? { ...heading, text: tocText[heading.slug] }
+    : heading
+);
+// An untitled page's opening \`# Heading\` is its title, so the title-heading
+// plugin drops it from the body and reports its id here: the title \`<h1>\`
+// below takes it, so links to the heading's anchor still land (see
+// markdown/title-heading.ts).
+const titleIdRaw = remarkPluginFrontmatter?.${TITLE_ID_KEY};
+const titleId = typeof titleIdRaw === "string" ? titleIdRaw : undefined;
 const frontmatter = entry.data;
 
 const seo = frontmatter.seo;
@@ -2809,7 +2879,7 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
   noindex={effectiveNoindex}
   structuredDataEnabled={data.config.structuredData}
 >
-  {pageChrome && <h1>{title}</h1>}
+  {pageChrome && <h1 id={titleId}>{title}</h1>}
   {pageChrome && frontmatter.description && <p class="text-lg text-muted-foreground">{frontmatter.description}</p>}
   {narration && (
     <NarrationPlayer
@@ -2843,42 +2913,22 @@ export const changelogIndexTemplate = (options: {
   exportPdf: boolean;
   /** Serialize the island-hooks snapshot; only needed when React is enabled. */
   needsReact: boolean;
-  /** Whether a `staged` collection exists (non-filesystem changelog sources). */
-  staged: boolean;
 }): string => {
   const clientData = options.needsReact
     ? '\n  clientData={{ config: data.config, navigation: data.navigation, page: { route: "/changelog", title: pageTitle } }}'
     : "";
-  // Staged sources (e.g. GitHub Releases) render through a parallel collection,
-  // so fold them in alongside filesystem entries when one exists.
-  const stagedSpread = options.staged
-    ? '\n  ...(await getCollection("staged")),'
-    : "";
 
   return `---
 // Generated by Blume. Do not edit.
-import { getCollection } from "astro:content";
 import RootLayout from "blume/components/layout/RootLayout.astro";
+import Changelog from "blume/components/content/Changelog.astro";
 import { withMountedBase } from "blume/components/islands/base-path.ts";
 import { resolveSlot } from "blume/components/layout/overrides.ts";
-import { resolveDateFormatOptions } from "blume/core/date-format.ts";
 import { layoutOverrides } from "../generated/components.ts";
 import data from "blume:data";
 
 export const prerender = true;
 
-const entryDate = (entry: {
-  data: { date?: string | null; changelog?: { date?: string | null } | null };
-}) => entry.data.date ?? entry.data.changelog?.date ?? null;
-
-const parseDate = (value: string | null | undefined) => {
-  if (!value) {
-    return null;
-  }
-  const date = new Date(value);
-  return Number.isNaN(date.getTime()) ? null : date;
-};
-
 // The changelog is an unlocalized route, so its chrome renders in the default
 // locale's dictionary and direction (\`data.ui\` is the default locale's resolved
 // dictionary), mirroring the catch-all's locale wiring.
@@ -2889,109 +2939,6 @@ const localeMeta = i18n
 const dir = localeMeta?.dir ?? "ltr";
 const htmlLang = i18n ? i18n.defaultLocale : "en";
 
-// Formatted in the same locale as the chrome, and with the configured
-// \`dateFormat\` (UTC by default), to match the per-page "last updated" stamp.
-// The year heads each group, so a row shows the rest of the date: a preset
-// style keeps its month wording, a component format simply drops the year.
-const dateFormatOptions = resolveDateFormatOptions(data.config.dateFormat);
-const { dateStyle, year: _year, ...dateComponents } = dateFormatOptions;
-const rowDateFormat: Intl.DateTimeFormatOptions = dateStyle
-  ? {
-      ...dateComponents,
-      day: "numeric",
-      month: dateStyle === "medium" ? "short" : "long",
-    }
-  : dateComponents;
-const formatRowDate = (date: Date) =>
-  new Intl.DateTimeFormat(htmlLang, rowDateFormat).format(date);
-const formatYear = (date: Date) =>
-  new Intl.DateTimeFormat(htmlLang, {
-    timeZone: dateFormatOptions.timeZone,
-    year: "numeric",
-  }).format(date);
-
-const slugify = (text: string) =>
-  text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") ||
-  "update";
-
-// Map each entry to its own generated page so the row can link to it. The
-// collection entry id matches the route manifest's \`entryId\` — and under
-// i18n every locale serves a page for it (its translations plus fallback
-// copies of an untranslated one), all sharing that id, so a map over every
-// route would keep whichever locale came last: a Portuguese permalink on an
-// unlocalized index. Only the default locale's routes are kept, and an entry
-// is listed only when it has one, so a translated changelog file (a distinct
-// entry that lives under its own locale) does not add a second row for the
-// same release.
-const defaultLocale = i18n ? i18n.defaultLocale : null;
-const routeByEntry = new Map<string, string>();
-for (const route of data.routes) {
-  if (defaultLocale === null || route.locale === defaultLocale) {
-    routeByEntry.set(route.entryId, route.path);
-  }
-}
-
-const changelogEntries = [
-  ...(await getCollection("docs")),${stagedSpread}
-]
-  .filter(
-    (entry) =>
-      entry.data.type === "changelog" &&
-      !entry.data.draft &&
-      !entry.data.sidebar?.hidden &&
-      (defaultLocale === null || routeByEntry.has(entry.id))
-  )
-  .toSorted(
-    (a, b) =>
-      (parseDate(entryDate(b))?.getTime() ?? 0) -
-      (parseDate(entryDate(a))?.getTime() ?? 0)
-  );
-
-const items = changelogEntries.map((entry) => {
-  const label =
-    entry.data.title ??
-    (entry.data.changelog?.version
-      ? "v" + entry.data.changelog.version
-      : "Update");
-  const date = parseDate(entryDate(entry));
-  const route = routeByEntry.get(entry.id);
-  return {
-    date: date ? formatRowDate(date) : null,
-    dateTime: date ? date.toISOString().slice(0, 10) : null,
-    href: route ? withMountedBase(route) : null,
-    id: slugify(label),
-    label,
-    tag: entry.data.changelog?.category ?? null,
-    year: date ? formatYear(date) : null,
-  };
-});
-
-// Repeated labels slug to the same id (e.g. two entries with neither a title
-// nor a version both falling back to "update"); suffix the later ones -2, -3,
-// ... so every row keeps its own hash anchor. The first keeps the plain slug.
-const seenIds = new Set();
-for (const item of items) {
-  let uniqueId = item.id;
-  for (let n = 2; seenIds.has(uniqueId); n += 1) {
-    uniqueId = item.id + "-" + n;
-  }
-  seenIds.add(uniqueId);
-  item.id = uniqueId;
-}
-
-// Consecutive releases from the same year share a group, so the list reads as
-// a year rail beside the rows; undated entries (sorted last) form a final
-// group with no year label.
-const groups: { items: typeof items; year: string | null }[] = [];
-for (const item of items) {
-  const last = groups[groups.length - 1];
-  if (last && last.year === item.year) {
-    last.items.push(item);
-  } else {
-    groups.push({ items: [item], year: item.year });
-  }
-}
-
 const base = data.config.site ? data.config.site.replace(/\\/$/, "") : null;
 // The canonical URL carries the deployment base (the page is served under it),
 // matching how the catch-all canonicalizes via \`withMountedBase(route)\`.
@@ -3004,15 +2951,16 @@ const canonical = base ? base + basedRoute : null;
 const ogPath = data.config.og.enabled ? withMountedBase("/og/changelog.png") : null;
 const ogImage = ogPath && base ? base + ogPath : ogPath;
 
-// The page chrome (h1, title, description, empty state) comes from the
-// translatable \`changelog\` group, which carries the \`changelog\` config's title and
+// The page chrome (h1, title, description) comes from the translatable
+// \`changelog\` group, which carries the \`changelog\` config's title and
 // description when it sets them; optional chaining tolerates a
-// not-yet-regenerated data snapshot from before these keys existed.
+// not-yet-regenerated data snapshot from before these keys existed. The list
+// itself is \`<Changelog />\`, the same component an authored page can place to
+// put prose above it.
 const changelogTitle = data.ui.changelog?.title ?? "Changelog";
 const changelogDescription =
   data.ui.changelog?.description ??
   "Product updates, new features, and fixes from every release.";
-const changelogEmpty = data.ui.changelog?.empty ?? "No changelog entries yet.";
 // The layout suffixes "- {site title}" itself, so the page title is just the
 // changelog's own name — prefixing the site title too would double it
 // ("Acme Changelog - Acme").
@@ -3063,51 +3011,7 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
 >
   <h1>{changelogTitle}</h1>
   <p class="text-lg text-muted-foreground">{changelogDescription}</p>
-  {
-    items.length === 0 ? (
-      <p>{changelogEmpty}</p>
-    ) : (
-      <div class="not-prose mt-10 divide-y divide-border border-border border-y">
-        {groups.map((group) => (
-          <section
-            aria-label={group.year ?? undefined}
-            class="grid md:grid-cols-[6rem_minmax(0,1fr)] md:gap-x-8"
-          >
-            <h2 class="mt-0! pt-3! font-medium! text-muted-foreground text-sm! leading-5! tabular-nums max-md:pb-1">
-              {group.year}
-            </h2>
-            <ul class="m-0! list-none divide-y divide-border p-0!">
-              {group.items.map((item) => (
-                <li class="m-0! p-0!" id={item.id}>
-                  <a
-                    class="group/release flex items-baseline gap-4 py-3 no-underline! hover:no-underline!"
-                    href={item.href ?? "#" + item.id}
-                  >
-                    <span class="min-w-0 flex-1 font-medium text-foreground text-sm transition-colors group-hover/release:text-accent">
-                      {item.label}
-                    </span>
-                    {item.tag && (
-                      <span class="shrink-0 rounded-full bg-muted px-2 py-0.5 font-medium text-[0.65rem] text-muted-foreground">
-                        {item.tag}
-                      </span>
-                    )}
-                    {item.date && (
-                      <time
-                        class="shrink-0 font-mono text-muted-foreground text-xs tabular-nums"
-                        datetime={item.dateTime}
-                      >
-                        {item.date}
-                      </time>
-                    )}
-                  </a>
-                </li>
-              ))}
-            </ul>
-          </section>
-        ))}
-      </div>
-    )
-  }
+  <Changelog />
 </LayoutComponent>
 `;
 };

package/src/audit/checks/redirects.ts

@@ -48,11 +48,15 @@ export const redirectChecks: CheckModule = {
           )
         );
       } else if (redirect.outcome === "broken") {
+        // A pattern's chain starts at the bare path it also matches.
+        const [start] = redirect.chain;
+        const what =
+          start === from ? from : `${from}, which also matches ${start},`;
         found.push(
           finding(
             "BLUME_AUDIT_REDIRECT_BROKEN",
             { ...site, url: from },
-            `Redirect from ${from} lands on ${redirect.chain.at(-1)}, which the build does not serve.`
+            `Redirect from ${what} lands on ${redirect.chain.at(-1)}, which the build does not serve.`
           )
         );
       } else if (redirect.outcome === "chain") {

package/src/audit/redirects.ts

@@ -1,4 +1,5 @@
 import {
+  bareRedirect,
   isPatternPath,
   patternDestination,
 } from "../core/redirect-patterns.ts";
@@ -22,11 +23,22 @@ const pathOnly = (value: string): string => {
   return cut === -1 ? value : value.slice(0, cut);
 };
 
+/**
+ * The most hops a walk follows before calling it a loop. A pattern can send a
+ * path somewhere it covers again, one segment longer each time (`/a/*` to
+ * `/a/b/:splat`), which never revisits a hop yet never resolves either.
+ */
+const MAX_HOPS = 32;
+
+/** Where a walk from one path ended, and how. */
+type Walk = Pick<RedirectResolution, "chain" | "outcome">;
+
 /**
  * Follow every configured redirect through to its destination, classifying what
  * it lands on.
  *
- * - `loop`    — the chain revisits a hop it has already been to. Never resolves.
+ * - `loop`    — the chain revisits a hop it has already been to, or runs past
+ *   {@link MAX_HOPS}. Never resolves.
  * - `broken`  — the chain ends somewhere the build does not serve.
  * - `chain`   — it resolves, but through at least one intermediate redirect.
  * - `ok`      — one hop, straight to a real page.
@@ -34,6 +46,11 @@ const pathOnly = (value: string): string => {
  *   naming one, so there is no single chain to walk; {@link redirectAt}
  *   resolves a path it covers.
  *
+ * A pattern ending in a rest also matches its bare path (`/beta`, see
+ * `bareRedirect`), which every host gets as an exact rule. That one path is
+ * walked like an exact redirect: when it loops or breaks, the pattern takes
+ * that outcome, its chain starting at the bare path.
+ *
  * An external destination (`https://…`) is always `ok`: it's outside the site,
  * so there's no local page to check it against. A hop onto a path a pattern
  * covers continues through that pattern.
@@ -50,14 +67,10 @@ export const resolveRedirects = (
   const hopFrom = (path: string): string | undefined =>
     byFrom.get(path)?.to ?? patternDestination(redirects, path);
 
-  return redirects.map((redirect) => {
-    const from = normalizePath(redirect.from);
-    if (isPatternPath(redirect.from)) {
-      return { ...redirect, chain: [from], outcome: "pattern" as const };
-    }
+  const walk = (from: string, to: string): Walk => {
     const chain: string[] = [from];
     const seen = new Set<string>([from]);
-    let current = redirect.to;
+    let current = to;
 
     for (;;) {
       // An external hop ends the walk — we can't follow it locally.
@@ -66,13 +79,9 @@ export const resolveRedirects = (
         break;
       }
       const next = normalizePath(pathOnly(current));
-      if (seen.has(next)) {
+      if (seen.has(next) || chain.length > MAX_HOPS) {
         chain.push(next);
-        return {
-          ...redirect,
-          chain,
-          outcome: "loop" as const,
-        };
+        return { chain, outcome: "loop" };
       }
       chain.push(next);
       seen.add(next);
@@ -86,15 +95,23 @@ export const resolveRedirects = (
     const destination = chain.at(-1) ?? from;
     const external = /^https?:\/\//iu.test(destination);
     if (!(external || served(destination))) {
-      return { ...redirect, chain, outcome: "broken" as const };
+      return { chain, outcome: "broken" };
     }
     // `chain` is [from, …hops, destination]; more than two entries means at
     // least one intermediate redirect.
-    return {
-      ...redirect,
-      chain,
-      outcome: chain.length > 2 ? ("chain" as const) : ("ok" as const),
-    };
+    return { chain, outcome: chain.length > 2 ? "chain" : "ok" };
+  };
+
+  return redirects.map((redirect) => {
+    const from = normalizePath(redirect.from);
+    if (!isPatternPath(redirect.from)) {
+      return { ...redirect, ...walk(from, redirect.to) };
+    }
+    const bare = bareRedirect(redirect);
+    const walked = bare && walk(normalizePath(bare.from), bare.to);
+    return walked && (walked.outcome === "loop" || walked.outcome === "broken")
+      ? { ...redirect, ...walked }
+      : { ...redirect, chain: [from], outcome: "pattern" as const };
   });
 };
 

package/src/audit/report.ts

@@ -7,6 +7,7 @@ import type { Diagnostic, DiagnosticSeverity } from "../core/types.ts";
 import { CHECKS, checkMeta } from "./catalog.ts";
 import type { CheckId } from "./catalog.ts";
 import type { AuditResult } from "./run.ts";
+import { checkSelected } from "./terms.ts";
 import type { AuditCategory, AuditTier } from "./types.ts";
 
 const SEVERITY_COLOR = {
@@ -128,15 +129,27 @@ export const rollup = (diagnostics: Diagnostic[]): CheckRollup[] => {
 };
 
 /** Categories that had no findings but were never run, and the flag that runs them. */
-const skippedTiers = (tiers: Record<AuditTier, boolean>): string[] =>
-  TIER_FLAGS.filter(({ tier }) => !tiers[tier]).map(({ flag, tier }) => {
-    const label = CHECKS.filter((check) => check.tier === tier).length;
-    return `  ${colors.dim(`⊘ ${tier.padEnd(12)} skipped — pass ${flag} (${label} checks)`)}`;
+const skippedTiers = (result: AuditResult): string[] =>
+  TIER_FLAGS.flatMap(({ flag, tier }) => {
+    // Only the checks `--only`/`--skip` left in would have run.
+    const count = CHECKS.filter(
+      (check) => check.tier === tier && checkSelected(check.id, result)
+    ).length;
+    return result.tiers[tier] || count === 0
+      ? []
+      : [
+          `  ${colors.dim(`⊘ ${tier.padEnd(12)} skipped — pass ${flag} (${count} checks)`)}`,
+        ];
   });
 
-/** How many checks actually ran, i.e. those whose tier was enabled. */
-const activeChecks = (tiers: Record<AuditTier, boolean>): number =>
-  CHECKS.filter((check) => tiers[check.tier]).length;
+/**
+ * How many checks the report covers: those whose tier was enabled, and that
+ * `--only`/`--skip` left in.
+ */
+const activeChecks = (result: AuditResult): number =>
+  CHECKS.filter(
+    (check) => result.tiers[check.tier] && checkSelected(check.id, result)
+  ).length;
 
 /**
  * Individual checks performed: every rule that ran, against every page crawled.
@@ -144,7 +157,7 @@ const activeChecks = (tiers: Record<AuditTier, boolean>): number =>
  * rather than a bare count.
  */
 export const auditCount = (result: AuditResult): number =>
-  activeChecks(result.tiers) * result.pages;
+  activeChecks(result) * result.pages;
 
 const summaryLine = (
   counts: Record<DiagnosticSeverity, number>,
@@ -244,7 +257,7 @@ export const formatReport = (
     lines.push("");
   }
 
-  const skipped = skippedTiers(result.tiers);
+  const skipped = skippedTiers(result);
   if (skipped.length > 0) {
     lines.push(...skipped, "");
   }