blume 1.4.0 → 1.4.2

package/src/core/sources/github-releases.ts

@@ -1,3 +1,8 @@
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { gfmFromMarkdown } from "mdast-util-gfm";
+import { toString as mdastToString } from "mdast-util-to-string";
+import { gfm } from "micromark-extension-gfm";
+
 import matter from "../frontmatter.ts";
 import {
   hashText,
@@ -62,39 +67,37 @@ const EDGE_DASHES = /^-+|-+$/gu;
 const DESCRIPTION_MAX = 160;
 const DESCRIPTION_MIN = 110;
 
-const CODE_FENCE = /```[\s\S]*?```/gu;
-const HEADING_LINE = /^#{1,6}\s.*$/gmu;
-const LIST_MARK = /^\s*(?:[-*+]|\d+[.)])\s+/u;
 // Changesets-generated release bullets open with the changeset's short commit
-// hash (`- cf8fa22: Fix …`) — noise in a search snippet.
-const CHANGESET_HASH = /^[0-9a-f]{7,40}:\s+/u;
-const IMAGE = /!\[[^\]]*\]\([^)]*\)/gu;
-const LINK = /\[(?<text>[^\]]*)\]\([^)]*\)/gu;
-const INLINE_CODE = /`(?<code>[^`]+)`/gu;
-// Tag-shaped only: a bare `<` in prose must not swallow text up to a later `>`.
-const HTML_OR_JSX = /<\/?[a-zA-Z][^\n<>]*>|<\/?>/gu;
-const MARKDOWN_PUNCT = /[*_~>]+/gu;
+// hash (`- cf8fa22: Fix …`) — noise in a search snippet. Stripped from the
+// raw lines (where the bullet anchor still exists) before parsing.
+const CHANGESET_HASH = /^(?<mark>\s*(?:[-*+]|\d+[.)])\s+)[0-9a-f]{7,40}:\s+/gmu;
 const WHITESPACE = /\s+/gu;
 const TRAILING_FRAGMENT = /[\s,;:.—–-]+$/u;
 
+/** Block nodes with no place in a search snippet. */
+const NON_PROSE = new Set(["code", "heading", "html", "thematicBreak"]);
+
 /**
- * Derive a meta description from release notes: markdown reduced to plain
- * text — section headings ("### Patch Changes") and changesets' commit-hash
- * bullet prefixes dropped — then cut at a word boundary to fit the search
- * snippet cap. Undefined when the notes have no prose at all.
+ * Derive a meta description from release notes: GitHub-flavored markdown
+ * parsed to mdast and reduced to the plain text of its prose blocks —
+ * section headings ("### Patch Changes"), code fences, and changesets'
+ * commit-hash bullet prefixes dropped; link/emphasis text and inline code
+ * content kept — then cut at a word boundary to fit the search snippet cap.
+ * Undefined when the notes have no prose at all.
  */
 const releaseDescription = (body: string): string | undefined => {
-  const text = body
-    .replaceAll(CODE_FENCE, " ")
-    .replaceAll(HEADING_LINE, "")
-    .split("\n")
-    .map((line) => line.replace(LIST_MARK, "").replace(CHANGESET_HASH, ""))
-    .join("\n")
-    .replaceAll(IMAGE, " ")
-    .replaceAll(LINK, "$<text>")
-    .replaceAll(INLINE_CODE, "$<code>")
-    .replaceAll(HTML_OR_JSX, " ")
-    .replaceAll(MARKDOWN_PUNCT, " ")
+  const tree = fromMarkdown(body.replaceAll(CHANGESET_HASH, "$<mark>"), {
+    extensions: [gfm()],
+    mdastExtensions: [gfmFromMarkdown()],
+  });
+  const text = tree.children
+    .filter((node) => !NON_PROSE.has(node.type))
+    // Images vanish (their alt is not prose) and raw HTML/JSX tags drop,
+    // matching what a reader of the rendered notes would see as text.
+    .map((node) =>
+      mdastToString(node, { includeHtml: false, includeImageAlt: false })
+    )
+    .join(" ")
     .replaceAll(WHITESPACE, " ")
     .trim();
   if (!text) {

package/src/core/sources/mdx-remote.ts

@@ -1,3 +1,5 @@
+import picomatch from "picomatch";
+
 import { BlumeError } from "../diagnostics.ts";
 import matter from "../frontmatter.ts";
 import type { Diagnostic } from "../types.ts";
@@ -31,61 +33,10 @@ export interface MdxRemoteSourceOptions {
   fetchImpl?: typeof fetch;
 }
 
-const REGEX_SPECIAL = /[.*+?^${}()|[\]\\]/u;
-
-/** Escape a literal character for embedding in a RegExp. */
-const escapeChar = (char: string): string =>
-  REGEX_SPECIAL.test(char) ? `\\${char}` : char;
-
-/** Translate one glob token at `i` into RegExp source + the next index. */
-const globToken = (
-  pattern: string,
-  i: number
-): { source: string; next: number } => {
-  const char = pattern[i] ?? "";
-  if (char === "*") {
-    if (pattern[i + 1] === "*") {
-      // `**/` spans zero or more whole segments — `docs/**/guide.md` must
-      // match `docs/guide.md` and `docs/a/guide.md` but not `docs/subguide.md`.
-      if (pattern[i + 2] === "/") {
-        return { next: i + 3, source: "(?:.*/)?" };
-      }
-      return { next: i + 2, source: ".*" };
-    }
-    return { next: i + 1, source: "[^/]*" };
-  }
-  if (char === "?") {
-    return { next: i + 1, source: "[^/]" };
-  }
-  if (char === "{") {
-    const end = pattern.indexOf("}", i);
-    if (end !== -1) {
-      const options = pattern
-        .slice(i + 1, end)
-        .split(",")
-        .map((part) => [...part].map(escapeChar).join(""))
-        .join("|");
-      return { next: end + 1, source: `(?:${options})` };
-    }
-  }
-  return { next: i + 1, source: escapeChar(char) };
-};
-
-/** Compile a glob (`**`, `*`, `?`, `{a,b}`) into an anchored RegExp. */
-const globToRegExp = (pattern: string): RegExp => {
-  let source = "";
-  let i = 0;
-  while (i < pattern.length) {
-    const token = globToken(pattern, i);
-    source += token.source;
-    i = token.next;
-  }
-  return new RegExp(`^${source}$`, "u");
-};
-
-/** Whether a ref matches any of the include globs. */
-const matchesInclude = (ref: string, patterns: string[]): boolean =>
-  patterns.some((pattern) => globToRegExp(pattern).test(ref));
+// Include globs compile through picomatch — what the filesystem source's
+// tinyglobby uses under the hood — so the same `include` array means the same
+// thing on every source type: negation, character classes, nested braces, and
+// extglobs included. Compiled once per enumeration, not per ref.
 
 /** A file to fetch: its source-local ref plus where to read it from. */
 interface RemoteRef {
@@ -136,12 +87,13 @@ const enumerateGithub = async (
     truncated?: boolean;
   };
   const prefix = base ? `${base}/` : "";
+  const included = picomatch(include);
   const refs = (body.tree ?? []).flatMap((node) => {
     if (!(node.type === "blob" && node.path.startsWith(prefix))) {
       return [];
     }
     const rel = node.path.slice(prefix.length);
-    if (!matchesInclude(rel, include)) {
+    if (!included(rel)) {
       return [];
     }
     return [
@@ -193,8 +145,9 @@ export const mdxRemoteSource = (
       return await enumerateGithub(options.github, options.include, doFetch);
     }
     const base = (options.url ?? "").replace(/\/$/u, "");
+    const included = picomatch(options.include);
     const refs = (options.files ?? []).flatMap((ref) =>
-      matchesInclude(ref, options.include)
+      included(ref)
         ? [{ editUrl: `${base}/${ref}`, fetchUrl: `${base}/${ref}`, ref }]
         : []
     );

package/src/core/sources/notion.ts

@@ -148,31 +148,25 @@ const SECOND_MS = 1000;
  * many concurrent block-children requests, so without this a single 429 would
  * reject the batch and abort the whole import.
  */
-const withNotionRetry = async <T>(call: () => Promise<T>): Promise<T> => {
-  let lastError: unknown;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt += 1) {
-    try {
-      // oxlint-disable-next-line no-await-in-loop, react-doctor/async-await-in-loop -- sequential retry attempts, not independent
-      return await call();
-    } catch (error) {
-      lastError = error;
-      const { status } = error as { status?: number };
-      if (status !== RATE_LIMITED || attempt === MAX_RETRIES) {
-        throw error;
-      }
-      const retryAfter = Number(
-        (error as { headers?: Record<string, string> }).headers?.["retry-after"]
-      );
-      const wait =
-        retryAfter > 0 ? retryAfter * SECOND_MS : BASE_DELAY_MS * 2 ** attempt;
-      // oxlint-disable-next-line no-await-in-loop -- back off before retrying
-      await sleep(wait);
+const withNotionRetry = async <T>(
+  call: () => Promise<T>,
+  attempt = 0
+): Promise<T> => {
+  try {
+    return await call();
+  } catch (error) {
+    const { status } = error as { status?: number };
+    if (status !== RATE_LIMITED || attempt === MAX_RETRIES) {
+      throw error;
     }
+    const retryAfter = Number(
+      (error as { headers?: Record<string, string> }).headers?.["retry-after"]
+    );
+    const wait =
+      retryAfter > 0 ? retryAfter * SECOND_MS : BASE_DELAY_MS * 2 ** attempt;
+    await sleep(wait);
+    return withNotionRetry(call, attempt + 1);
   }
-  // Unreachable — the loop always returns or rethrows — but keeps types honest.
-  throw lastError instanceof Error
-    ? lastError
-    : new Error("Notion request failed after retries.");
 };
 
 /** Paginate a Notion list endpoint via recursion (no await-in-loop). */

package/src/core/tsconfig-aliases.ts

@@ -1,8 +1,7 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
+import { existsSync } from "node:fs";
 
-import { dirname, isAbsolute, join, resolve } from "pathe";
+import { parseTsconfig } from "get-tsconfig";
+import { dirname, join, resolve } from "pathe";
 
 /**
  * Read the project's TypeScript path aliases (`compilerOptions.paths`) and turn
@@ -15,177 +14,28 @@ import { dirname, isAbsolute, join, resolve } from "pathe";
  * import would have to be rewritten to a relative path. Reading the aliases here
  * lets those components port over unchanged.
  *
- * Best-effort and non-fatal: tsconfig is parsed leniently (it is JSONC —
- * comments and trailing commas), a single `extends` chain is followed to the
- * file that actually declares `paths`, and anything unparseable yields no
- * aliases (the prior behavior).
+ * Parsing is get-tsconfig's job — JSONC, the full `extends` chain (relative
+ * paths, directories, package specifiers, TS 5.0 arrays), and the rebasing of
+ * inherited relative paths all follow tsc's own semantics. Best-effort and
+ * non-fatal: anything unparseable yields no aliases.
  */
 
-interface ScanStep {
-  append: string;
-  inString: boolean;
-  next: number;
-}
+/** TS 5.5's config-relative template prefix, literal by design in tsconfig. */
+// oxlint-disable-next-line no-template-curly-in-string -- tsconfig's own syntax
+const CONFIG_DIR_TEMPLATE = "${configDir}";
 
-/** Scan one character (or comment/escape run) starting at `index`. */
-const scanJsonChar = (
-  text: string,
-  index: number,
-  inString: boolean
-): ScanStep => {
-  const char = text[index];
-  if (inString) {
-    if (char === "\\") {
-      return {
-        append: char + (text[index + 1] ?? ""),
-        inString: true,
-        next: index + 2,
-      };
-    }
-    return { append: char ?? "", inString: char !== '"', next: index + 1 };
-  }
-  if (char === '"') {
-    return { append: char, inString: true, next: index + 1 };
-  }
-  if (char === "/" && text[index + 1] === "/") {
-    const newline = text.indexOf("\n", index + 2);
-    return {
-      append: "",
-      inString: false,
-      next: newline === -1 ? text.length : newline,
-    };
-  }
-  if (char === "/" && text[index + 1] === "*") {
-    const end = text.indexOf("*/", index + 2);
-    return {
-      append: "",
-      inString: false,
-      next: end === -1 ? text.length : end + 2,
-    };
-  }
-  return { append: char ?? "", inString: false, next: index + 1 };
-};
-
-/** Strip `//` line and `/* *\/` block comments that sit outside strings. */
-const stripJsonComments = (text: string): string => {
-  let out = "";
-  let inString = false;
-  let index = 0;
-  while (index < text.length) {
-    const {
-      append,
-      inString: nextInString,
-      next,
-    } = scanJsonChar(text, index, inString);
-    out += append;
-    inString = nextInString;
-    index = next;
-  }
-  return out;
-};
-
-const TRAILING_COMMA = /,(?<rest>\s*[}\]])/gu;
-
-/** Parse JSONC (tsconfig) into a plain object, or null if it can't be read. */
-const parseJsonc = (text: string): Record<string, unknown> | null => {
-  try {
-    const cleaned = stripJsonComments(text).replaceAll(
-      TRAILING_COMMA,
-      "$<rest>"
-    );
-    const value: unknown = JSON.parse(cleaned);
-    return value && typeof value === "object" && !Array.isArray(value)
-      ? (value as Record<string, unknown>)
-      : null;
-  } catch {
-    return null;
-  }
-};
-
-const isFile = (path: string): boolean => {
-  try {
-    return statSync(path).isFile();
-  } catch {
-    return false;
-  }
-};
-
-/** Resolve a tsconfig `extends` target (relative path, directory, or package). */
-const resolveExtends = (spec: string, fromDir: string): string | null => {
-  if (spec.startsWith(".") || isAbsolute(spec)) {
-    const candidates = spec.endsWith(".json")
-      ? [resolve(fromDir, spec)]
-      : [
-          resolve(fromDir, `${spec}.json`),
-          resolve(fromDir, spec, "tsconfig.json"),
-          resolve(fromDir, spec),
-        ];
-    return candidates.find(isFile) ?? null;
-  }
-  // A bare specifier points at a package's shared config (e.g. `@tsconfig/*`).
-  try {
-    const requireFromDir = createRequire(
-      pathToFileURL(join(fromDir, "_.js")).href
-    );
-    for (const sub of [`${spec}/tsconfig.json`, spec]) {
-      try {
-        return requireFromDir.resolve(sub);
-      } catch {
-        // try the next candidate
-      }
-    }
-  } catch {
-    // createRequire failed; fall through
-  }
-  return null;
-};
-
-interface LoadedPaths {
-  /** Directory `paths` entries resolve against (`dirname(file)` + `baseUrl`). */
-  baseDir: string;
-  paths: Record<string, unknown>;
-}
-
-/** Find the nearest tsconfig in an `extends` chain that declares `paths`. */
-const loadPaths = (file: string, seen: Set<string>): LoadedPaths | null => {
-  if (seen.has(file) || !existsSync(file)) {
-    return null;
-  }
-  seen.add(file);
-  const json = parseJsonc(readFileSync(file, "utf-8"));
-  if (!json) {
-    return null;
-  }
-  const options = (json.compilerOptions ?? {}) as Record<string, unknown>;
-  if (options.paths && typeof options.paths === "object") {
-    const baseUrl = typeof options.baseUrl === "string" ? options.baseUrl : ".";
-    return {
-      baseDir: resolve(dirname(file), baseUrl),
-      paths: options.paths as Record<string, unknown>,
-    };
-  }
-  // `extends` is a string or, since TS 5.0, an array searched first-to-last.
-  const bases = Array.isArray(json.extends)
-    ? json.extends
-    : [json.extends].filter(Boolean);
-  for (const base of bases) {
-    if (typeof base !== "string") {
-      continue;
-    }
-    const resolved = resolveExtends(base, dirname(file));
-    const found = resolved ? loadPaths(resolved, seen) : null;
-    if (found) {
-      return found;
-    }
-  }
-  return null;
-};
+/** Substitute a leading `${configDir}` template with the config's directory. */
+const substituteConfigDir = (value: string, configDir: string): string =>
+  value.startsWith(CONFIG_DIR_TEMPLATE)
+    ? join(configDir, value.slice(CONFIG_DIR_TEMPLATE.length))
+    : value;
 
 /** Convert one tsconfig `paths` mapping to a Vite alias, or null to skip. */
 const toAlias = (
   key: string,
   value: unknown,
-  baseDir: string
+  baseDir: string,
+  configDir: string
 ): { find: string; replacement: string } | null => {
   // tsconfig allows a fallback array; Vite aliases are 1:1, so take the first.
   const first = Array.isArray(value) ? value[0] : value;
@@ -198,7 +48,10 @@ const toAlias = (
   if (find === "" || find === "*") {
     return null;
   }
-  return { find, replacement: resolve(baseDir, target) };
+  return {
+    find,
+    replacement: resolve(baseDir, substituteConfigDir(target, configDir)),
+  };
 };
 
 /**
@@ -215,13 +68,27 @@ export const resolveTsconfigAliases = (
   if (!entry) {
     return {};
   }
-  const loaded = loadPaths(entry, new Set());
-  if (!loaded) {
+  let options: ReturnType<typeof parseTsconfig>["compilerOptions"];
+  try {
+    options = parseTsconfig(entry).compilerOptions;
+  } catch {
+    // Unparseable config or unresolvable extends: no aliases, as before.
+    return {};
+  }
+  const paths = options?.paths;
+  if (!paths) {
     return {};
   }
+  const configDir = dirname(entry);
+  // get-tsconfig rebases inherited relative values onto the entry config, so
+  // `baseUrl` (and bare `paths` entries) anchor here after substitution.
+  const baseDir = resolve(
+    configDir,
+    substituteConfigDir(options?.baseUrl ?? ".", configDir)
+  );
   const aliases: Record<string, string> = {};
-  for (const [key, value] of Object.entries(loaded.paths)) {
-    const alias = toAlias(key, value, loaded.baseDir);
+  for (const [key, value] of Object.entries(paths)) {
+    const alias = toAlias(key, value, baseDir, configDir);
     if (alias) {
       aliases[alias.find] = alias.replacement;
     }

package/src/deploy/rss.ts

@@ -1,7 +1,10 @@
+// html-escaper's five-entity table is XML-safe: `'` becomes the numeric
+// `'` reference rather than `'`, which XML accepts equally.
+import { escape as escapeXml } from "html-escaper";
+
 import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { PageRecord } from "../core/types.ts";
-import { escapeXml } from "./xml.ts";
 
 /** A single feed entry derived from a content page. */
 export interface RssItem {

package/src/deploy/sitemap.ts

@@ -1,3 +1,6 @@
+// html-escaper's five-entity table is XML-safe (`'` → the numeric `'`).
+import { escape as escapeXml } from "html-escaper";
+
 import {
   customStaticRoutes,
   discoverPagesSync,
@@ -5,7 +8,6 @@ import {
 } from "../astro/pages.ts";
 import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
-import { escapeXml } from "./xml.ts";
 
 /**
  * Astro's reserved error routes. A user-authored override (`pages/404.astro`,

package/src/eval/report.ts

@@ -1,23 +1,14 @@
 import { mkdtemp, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 
+import { colors } from "consola/utils";
+import type { ColorFunction } from "consola/utils";
 import { join, relative } from "pathe";
 
 import { AGENTS } from "../audit/agent.ts";
 import { countBySeverity } from "../core/diagnostics.ts";
 import type { EvalResult, QuestionResult, QuestionStatus } from "./run.ts";
 
-const ESC = String.fromCodePoint(27);
-const COLORS = {
-  bold: `${ESC}[1m`,
-  cyan: `${ESC}[36m`,
-  dim: `${ESC}[2m`,
-  green: `${ESC}[32m`,
-  red: `${ESC}[31m`,
-  reset: `${ESC}[0m`,
-  yellow: `${ESC}[33m`,
-};
-
 const GLYPH: Record<QuestionStatus, string> = {
   error: "!",
   fail: "✖",
@@ -25,11 +16,11 @@ const GLYPH: Record<QuestionStatus, string> = {
   skip: "⊘",
 };
 
-const STATUS_COLOR: Record<QuestionStatus, string> = {
-  error: COLORS.yellow,
-  fail: COLORS.red,
-  pass: COLORS.green,
-  skip: COLORS.dim,
+const STATUS_COLOR: Record<QuestionStatus, ColorFunction> = {
+  error: colors.yellow,
+  fail: colors.red,
+  pass: colors.green,
+  skip: colors.dim,
 };
 
 /** Longest id gets the room; everything shorter aligns to it. */
@@ -52,17 +43,18 @@ const duration = (ms: number): string => {
 /** One question's progress/report line: glyph, id, status, score, time, cost. */
 export const questionLine = (result: QuestionResult): string => {
   const color = STATUS_COLOR[result.status];
-  const glyph = `${color}${GLYPH[result.status]}${COLORS.reset}`;
+  const glyph = color(GLYPH[result.status]);
   const id = result.id.padEnd(ID_PAD);
   if (result.status === "skip") {
-    return `  ${glyph} ${id} ${COLORS.dim}skipped${COLORS.reset}`;
+    return `  ${glyph} ${id} ${colors.dim("skipped")}`;
   }
   const score = result.score === undefined ? "" : result.score.toFixed(2);
+  const cost = money(result.costUsd);
   const cells = [
-    `${color}${result.status}${COLORS.reset}`,
+    color(result.status),
     score,
-    `${COLORS.dim}${seconds(result.durationMs)}${COLORS.reset}`,
-    `${COLORS.dim}${money(result.costUsd)}${COLORS.reset}`,
+    colors.dim(seconds(result.durationMs)),
+    cost === "" ? "" : colors.dim(cost),
   ]
     .filter((cell) => cell !== "")
     .join("  ");
@@ -77,17 +69,17 @@ export const questionDetails = (
   const lines: string[] = [];
   if (result.status === "fail") {
     for (const fact of result.missing) {
-      lines.push(`      ${COLORS.dim}missing: ${fact}${COLORS.reset}`);
+      lines.push(`      ${colors.dim(`missing: ${fact}`)}`);
     }
   }
   if (result.status === "error" && result.detail) {
-    lines.push(`      ${COLORS.dim}${result.detail}${COLORS.reset}`);
+    lines.push(`      ${colors.dim(result.detail)}`);
   }
   if (verbose && result.answer && result.status !== "pass") {
     lines.push(
       ...result.answer
         .split("\n")
-        .map((line) => `      ${COLORS.dim}> ${line}${COLORS.reset}`)
+        .map((line) => `      ${colors.dim(`> ${line}`)}`)
     );
   }
   return lines;
@@ -109,11 +101,11 @@ export const summaryLine = (result: EvalResult): string => {
 
 /** The header line the command prints before the first question runs. */
 export const headerLine = (total: number, agent: EvalResult["agent"]): string =>
-  `${COLORS.bold}blume eval${COLORS.reset}  ${total} question(s) · ${AGENTS[agent].name}`;
+  `${colors.bold("blume eval")}  ${total} question(s) · ${AGENTS[agent].name}`;
 
 /** The dim announce line while a question's agents run. */
 export const startLine = (id: string, index: number, total: number): string =>
-  `  ${COLORS.dim}▸ ${id} (${index + 1}/${total})${COLORS.reset}`;
+  `  ${colors.dim(`▸ ${id} (${index + 1}/${total})`)}`;
 
 /** `fix:` pointers for failed questions, naming the file that resolves each. */
 export const fixLines = (result: EvalResult, root: string): string[] =>
@@ -123,7 +115,7 @@ export const fixLines = (result: EvalResult, root: string): string[] =>
       const site = finding.file
         ? `${relative(root, finding.file)}${finding.line ? `:${finding.line}` : ""}`
         : "";
-      return `  ${COLORS.cyan}fix:${COLORS.reset} ${site} ${COLORS.dim}${finding.message}${COLORS.reset}`;
+      return `  ${colors.cyan("fix:")} ${site} ${colors.dim(finding.message)}`;
     });
 
 /** Dim warnings for route hints that no longer match a page. */
@@ -134,7 +126,7 @@ export const warningLines = (result: EvalResult, root: string): string[] =>
       const site = finding.file
         ? ` ${relative(root, finding.file)}${finding.line ? `:${finding.line}` : ""}`
         : "";
-      return `  ${COLORS.yellow}⚠${COLORS.reset}${site} ${COLORS.dim}${finding.message}${COLORS.reset}`;
+      return `  ${colors.yellow("⚠")}${site} ${colors.dim(finding.message)}`;
     });
 
 /** The human report, written to stderr by the command. */

package/src/markdown/directives.ts

@@ -1,3 +1,5 @@
+import { toString as mdastToString } from "mdast-util-to-string";
+
 import { jsxAttribute, jsxFlowElement } from "./mdast.ts";
 import type { MdastNode, MdastVisitorContext } from "./mdast.ts";
 
@@ -35,23 +37,6 @@ export const calloutTypeFor = (name: string): string | null => {
   return ALIASES[lower] ?? null;
 };
 
-interface TextNode extends MdastNode {
-  value?: string;
-}
-
-/**
- * Concatenate the plain text of a node, recursing through phrasing children so
- * formatted labels keep every word — `:::note[Read **this**]` yields
- * `Read this`, not `Read ` (the bolded run dropped).
- */
-const textOf = (node: MdastNode): string => {
-  const { children } = node as { children?: MdastNode[] };
-  if (children && children.length > 0) {
-    return children.map(textOf).join("");
-  }
-  return (node as TextNode).value ?? "";
-};
-
 /**
  * Satteri MDAST plugin mapping container directives (`:::note`, `:::warning`,
  * `:::tip`, …) onto Blume's `<Callout>` component. The title comes from a
@@ -77,7 +62,10 @@ export const directiveToCalloutPlugin = () => ({
     if (labelIndex !== -1) {
       const [label] = children.splice(labelIndex, 1);
       if (label) {
-        title ??= textOf(label) || undefined;
+        // Flatten the label's phrasing children so `:::note[Read **this**]`
+        // yields `Read this`; image alt is excluded (an image is not label
+        // text), matching the historical child-values-only behavior.
+        title ??= mdastToString(label, { includeImageAlt: false }) || undefined;
       }
     }