blume 0.5.4 → 0.6.1

package/src/ai/ask-context.ts

@@ -26,16 +26,77 @@ export interface AskData {
 /** Documents retrieved per question and injected into the system prompt. */
 const MAX_RESULTS = 6;
 /** Characters kept per injected excerpt. */
-const EXCERPT_CHARS = 1500;
+const EXCERPT_CHARS = 2000;
 /** Overall cap on injected documentation characters. */
-const CONTEXT_BUDGET = 8000;
+const CONTEXT_BUDGET = 10_000;
+/** Chars of lead-in kept before the matched region, for heading/sentence context. */
+const EXCERPT_LEAD = 160;
+
+/**
+ * Common words dropped from the retrieval query before locating the relevant
+ * excerpt region, so short filler ("how does…", "what is…") doesn't drag the
+ * window toward incidental matches instead of the meaningful terms.
+ */
+const STOPWORDS = new Set([
+  "about",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "can",
+  "do",
+  "does",
+  "for",
+  "from",
+  "how",
+  "in",
+  "into",
+  "is",
+  "it",
+  "its",
+  "my",
+  "of",
+  "on",
+  "or",
+  "our",
+  "that",
+  "the",
+  "these",
+  "this",
+  "those",
+  "to",
+  "use",
+  "used",
+  "using",
+  "was",
+  "were",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "with",
+  "you",
+  "your",
+]);
+
+/** Distinct, meaningful lowercase terms from a query (drops stopwords). */
+const queryTerms = (query: string): string[] =>
+  [...new Set(query.toLowerCase().match(/[a-z0-9]+/gu))].filter(
+    (term) => term.length >= 2 && !STOPWORDS.has(term)
+  );
 
 /**
  * The grounding preamble. The model is told to answer strictly from the injected
- * excerpts and to cite the pages it used, so answers stay tied to the docs.
+ * excerpts and to cite the pages it used as Markdown links (each excerpt is
+ * headed by `## Title (/route)`), so citations render as real links in the panel.
  */
 const BASE_INSTRUCTION =
-  "You are a helpful documentation assistant for this project. Answer the user's question using ONLY the documentation excerpts below. If the answer is not covered by them, say you don't know and suggest where in the docs to look — do not invent details. Cite the page titles you drew from.";
+  "You are a helpful documentation assistant for this project. Answer the user's question using ONLY the documentation excerpts below. Each excerpt is headed by its page as `## Page Title (/route)`. If the answer is not covered by the excerpts, say you don't know and suggest where in the docs to look — do not invent details. Always cite the pages you drew from, and write every citation as a Markdown link to that page using its route, e.g. [Page Title](/route).";
 
 /** Normalize a page path to a document `route` (`/`, `/a/b`, no trailing slash). */
 const normalizeRoute = (input: string): string => {
@@ -55,10 +116,68 @@ const lastUserMessage = (messages: AskMessage[]): string => {
   return "";
 };
 
-/** Trim a document body to `max` characters, marking truncation with an ellipsis. */
-const excerpt = (content: string, max: number): string => {
+/**
+ * Excerpt the region of `content` most relevant to `query`, not just its head.
+ *
+ * Pages are indexed whole (one document each), so a naive head slice of a long
+ * page returns its intro and misses sections below the fold — the exact failure
+ * where "How does Ask AI work?" retrieves the right page but only sees its
+ * opening paragraph. This centers the window on the densest cluster of query
+ * terms so the injected text is the part that actually answers the question.
+ */
+const relevantExcerpt = (
+  content: string,
+  query: string,
+  max: number
+): string => {
   const trimmed = content.trim();
-  return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
+  if (trimmed.length <= max) {
+    return trimmed;
+  }
+  const withEllipsis = (start: number): string => {
+    const slice = trimmed.slice(start, start + max).trim();
+    const prefix = start > 0 ? "…" : "";
+    const suffix = start + max < trimmed.length ? "…" : "";
+    return `${prefix}${slice}${suffix}`;
+  };
+
+  const lower = trimmed.toLowerCase();
+  const positions: number[] = [];
+  for (const term of queryTerms(query)) {
+    let idx = lower.indexOf(term);
+    while (idx !== -1) {
+      positions.push(idx);
+      idx = lower.indexOf(term, idx + term.length);
+    }
+  }
+  // No query terms hit this doc — nothing to center on, so keep the head.
+  if (positions.length === 0) {
+    return withEllipsis(0);
+  }
+
+  // Pick the term hit whose following `max`-char window covers the most hits.
+  // `positions` is non-empty here, so the first window (count ≥ 1) always wins
+  // over the initial 0 and assigns a real offset to `best`.
+  positions.sort((a, b) => a - b);
+  let best = 0;
+  let bestCount = 0;
+  for (const start of positions) {
+    const end = start + max;
+    let count = 0;
+    for (const pos of positions) {
+      if (pos >= end) {
+        break;
+      }
+      if (pos >= start) {
+        count += 1;
+      }
+    }
+    if (count > bestCount) {
+      bestCount = count;
+      best = start;
+    }
+  }
+  return withEllipsis(Math.max(0, best - EXCERPT_LEAD));
 };
 
 /**
@@ -111,7 +230,11 @@ export const createAskContext = (
         return;
       }
       seen.add(doc.route);
-      const body = excerpt(doc.content, Math.min(EXCERPT_CHARS, budget));
+      const body = relevantExcerpt(
+        doc.content,
+        query,
+        Math.min(EXCERPT_CHARS, budget)
+      );
       budget -= body.length;
       sections.push(`## ${doc.title} (${doc.route})${label}\n${body}`);
     };

package/src/ai/ask-data.ts

@@ -6,10 +6,13 @@ import type { AskData } from "./ask-context.ts";
  * Build the grounding snapshot the Ask AI endpoint serves. Like the MCP server,
  * Ask AI is independent of on-page search, so documents are indexed even when the
  * search provider is `none` (`includeWhenDisabled`). `locale` is kept (unlike the
- * MCP snapshot) so retrieval can be filtered to the current page's language.
+ * MCP snapshot) so retrieval can be filtered to the current page's language, and
+ * content is kept as Markdown so grounding sees fenced code examples — the model
+ * answers "what does the config look like?" from the docs instead of declining.
  */
 export const buildAskData = async (project: BlumeProject): Promise<AskData> => {
   const documents = await buildSearchDocuments(project, {
+    content: "markdown",
     includeWhenDisabled: true,
   });
   return {

package/src/astro/generate.ts

@@ -330,6 +330,26 @@ export const detectNeedsReact = async (root: string): Promise<boolean> => {
   return matches.length > 0;
 };
 
+/**
+ * Detect whether the project authors block math (`$$…$$`) in any `.mdx`. Drives
+ * whether the generated runtime imports the `<Math>` component and KaTeX's
+ * stylesheet, so a math-free site ships no KaTeX CSS. Math parsing itself is
+ * always on but block-only, so a literal `$$` in source is a necessary
+ * condition — no false negatives. A stray `$$` (e.g. inside a code fence) merely
+ * over-includes the idempotent import, which is harmless.
+ */
+export const detectUsesMath = async (root: string): Promise<boolean> => {
+  const files = await glob(["**/*.mdx"], {
+    cwd: root,
+    ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
+    onlyFiles: true,
+  });
+  const contents = await Promise.all(
+    files.map((file) => readOptional(join(root, file)))
+  );
+  return contents.some((content) => content.includes("$$"));
+};
+
 const writeIfChanged = async (
   path: string,
   content: string
@@ -620,6 +640,7 @@ export const buildRuntimeData = (project: BlumeProject): string => {
           code,
           withReferenceTabs(
             graph.navigationByLocale[code] ?? {
+              featured: [],
               selectors: [],
               sidebar: [],
               tabs: [],
@@ -633,6 +654,9 @@ export const buildRuntimeData = (project: BlumeProject): string => {
     config: {
       analytics: config.analytics ?? null,
       appleIcon: resolveAppleIcon(project),
+      ask: config.ai.ask?.enabled
+        ? { suggestions: config.ai.ask.suggestions }
+        : null,
       banner: resolveBanner(config),
       codeWrap: config.markdown.code.wrap,
       description: config.description,
@@ -929,16 +953,21 @@ export const generateRuntime = async (
   const askEnabled = config.ai.ask?.enabled ?? false;
   const exportPdf = config.export.pdf;
   const exportEpub = config.export.epub;
-  const [pages, detectedReact, userTheme, islandDiscovery, exampleDiscovery] =
-    await Promise.all([
-      context.pagesRoot
-        ? discoverPages(context.pagesRoot)
-        : Promise.resolve([]),
-      detectNeedsReact(context.root),
-      readOptional(context.themeFile),
-      discoverIslands(context.root),
-      discoverExamples(context.root, config.examples),
-    ]);
+  const [
+    pages,
+    detectedReact,
+    usesMath,
+    userTheme,
+    islandDiscovery,
+    exampleDiscovery,
+  ] = await Promise.all([
+    context.pagesRoot ? discoverPages(context.pagesRoot) : Promise.resolve([]),
+    detectNeedsReact(context.root),
+    detectUsesMath(context.root),
+    readOptional(context.themeFile),
+    discoverIslands(context.root),
+    discoverExamples(context.root, config.examples),
+  ]);
   // Statically analyze `components.ts` overrides (never executed): drives the
   // `islands` group, hydration on layout/mdx overrides, string-path resolution,
   // and the "framework component with no client mode" diagnostic.
@@ -1024,7 +1053,7 @@ export const generateRuntime = async (
         askEnabled,
         exportEpub,
         exportPdf,
-        mathEnabled: config.markdown.math,
+        mathEnabled: usesMath,
         needsReact,
       })
     ),

package/src/astro/templates.ts

@@ -5,6 +5,7 @@ import { dirname, isAbsolute, join, relative } from "pathe";
 import { askBackendRuntimeDep } from "../ai/ask.ts";
 import type { AskBackend } from "../ai/ask.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
+import { BLUME_IGNORE_DIRS } from "../core/sources/watch.ts";
 import type { ProjectContext } from "../core/types.ts";
 import { hasScalarReferences } from "../openapi/references.ts";
 import { searchProviderMeta } from "../search/providers.ts";
@@ -299,8 +300,6 @@ export const astroConfigTemplate = (options: {
   const integrations = [
     `mdx({ processor: blumeMdxProcessor(${JSON.stringify({
       headingAnchors: config.markdown.headingAnchors,
-      inline: config.markdown.code.inline,
-      math: config.markdown.math,
     })}) })`,
   ];
   if (needsReact) {
@@ -334,7 +333,6 @@ export default defineConfig({
   markdown: {
     processor: blumeMarkdownProcessor(${JSON.stringify({
       headingAnchors: config.markdown.headingAnchors,
-      inline: config.markdown.code.inline,
     })}),
     shikiConfig: {
       themes: {
@@ -354,9 +352,17 @@ export default defineConfig({
     // native bindings resolve at runtime and isolated linkers don't bundle
     // symlinked store copies (which would surface their children as unresolvable
     // imports). See RENDER_EXTERNAL_DEPS / prerenderDepsPlugin.
+    //
+    // The SSR externals go through the legacy \`ssr.external\` key rather than
+    // \`environments.ssr\`: defining a user-owned \`environments.ssr\` block
+    // collides with the internal environment Astro 7 builds the server under and
+    // detaches the adapter's server entrypoint from the rolldown input, so the
+    // SSR entry is emitted as \`index.mjs\` instead of the \`entry.mjs\` the
+    // Vercel adapter's \`astro:build:done\` hook then fails to find. \`prerender\`
+    // is Astro-only and has no legacy equivalent, so it stays under \`environments\`.
+    ssr: { external: ${JSON.stringify(RENDER_EXTERNAL_DEPS)} },
     environments: {
       prerender: { resolve: { external: ${JSON.stringify(RENDER_EXTERNAL_DEPS)} } },
-      ssr: { resolve: { external: ${JSON.stringify(RENDER_EXTERNAL_DEPS)} } },
     },
     resolve: {
       alias: {
@@ -432,7 +438,15 @@ export const contentConfigTemplate = (options: {
     ? [
         ...config.content.include,
         ...(config.content.exclude ?? []).map((pattern) => `!${pattern}`),
-        "!**/node_modules/**",
+        // Mirror the filesystem scan's baseline ignores (see BLUME_IGNORE_DIRS):
+        // Astro's content layer roots at the project dir, so a `.`-wide content
+        // root would otherwise re-ingest dependency trees and build output —
+        // e.g. a prior `dist/*.mdx` render — and crash the content-module graph.
+        // The runtime dir (`.blume`, or a custom distDir) is excluded precisely
+        // by `outDirIgnore` instead, so it's left out of this baseline.
+        ...BLUME_IGNORE_DIRS.filter((dir) => dir !== ".blume").map(
+          (dir) => `!**/${dir}/**`
+        ),
         ...outDirIgnore,
       ]
     : [];
@@ -866,7 +880,7 @@ const siteHost = (() => {
 
 export async function GET({ props }) {
   const png = await renderOgImage({
-    accent: data.config.theme.accent,
+    accent: data.config.theme.accent.light,
     brand: data.config.title,
     description: data.config.description,
     logo: data.config.logo?.svg,
@@ -939,7 +953,7 @@ export const catchAllPageTemplate = (options: {
     ? 'import AskAI from "blume/components/islands/AskAI.astro";\n'
     : "";
   const askSlot = options.askEnabled
-    ? '\n  <AskAI slot="ask" strings={ui.ask} />'
+    ? '\n  <AskAI slot="ask" strings={ui.ask} suggestions={data.config.ask?.suggestions ?? []} />'
     : "";
   const mathImport = options.mathEnabled
     ? 'import Math from "blume/components/content/Math.astro";\n'
@@ -1210,7 +1224,9 @@ export const changelogIndexTemplate = (options: {
   const askImport = options.askEnabled
     ? 'import AskAI from "blume/components/islands/AskAI.astro";\n'
     : "";
-  const askSlot = options.askEnabled ? '\n  <AskAI slot="ask" />' : "";
+  const askSlot = options.askEnabled
+    ? '\n  <AskAI slot="ask" strings={data.ui.ask} suggestions={data.config.ask?.suggestions ?? []} />'
+    : "";
   const clientData = options.needsReact
     ? '\n  clientData={{ config: data.config, navigation: data.navigation, page: { route: "/changelog", title: data.config.title + " changelog" } }}'
     : "";
@@ -1259,6 +1275,20 @@ const slugify = (text) =>
   text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") ||
   "update";
 
+// The major of a version's embedded semver (\`1.2.3\` -> 1, \`pkg@2.0.0\` -> 2), or
+// null when there is no full major.minor.patch to key on. Drives the changelog's
+// group-by-major pagination, so it tolerates the scoped tags monorepos publish.
+const majorVersion = (version) => {
+  const match = /(\\d+)\\.\\d+\\.\\d+/.exec(String(version ?? ""));
+  return match ? Number(match[1]) : null;
+};
+
+// Map each entry to its own generated page so the timeline heading can deep-link
+// to it. The collection entry id matches the route manifest's \`entryId\`.
+const routeByEntry = new Map(
+  data.routes.map((route) => [route.entryId, route.path])
+);
+
 const changelogEntries = [
   ...(await getCollection("docs")),${stagedSpread}
 ]
@@ -1280,8 +1310,10 @@ const items = await Promise.all(
     return {
       Content: (await render(entry)).Content,
       date: formatDate(entryDate(entry)),
+      href: routeByEntry.get(entry.id) ?? null,
       id: slugify(label),
       label,
+      major: majorVersion(entry.data.changelog?.version),
       tags: entry.data.changelog?.category
         ? [entry.data.changelog.category]
         : [],
@@ -1289,6 +1321,19 @@ const items = await Promise.all(
   })
 );
 
+// A changelog is semver-paginated only when every visible release parses as
+// semver and they span more than one major line. Older majors then collapse
+// into groups the reader reveals one at a time; otherwise the timeline is flat.
+const majors = items.every((item) => item.major !== null)
+  ? [...new Set(items.map((item) => item.major))].toSorted((a, b) => b - a)
+  : [];
+const paginate = majors.length > 1;
+const majorGroups = majors.map((major) => ({
+  items: items.filter((item) => item.major === major),
+  label: major + ".x",
+  major,
+}));
+
 const headings = items.map((item) => ({
   depth: 2,
   slug: item.id,
@@ -1320,6 +1365,7 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
   }}
   headings={headings}
   toc={data.config.toc}
+  contentLayout="bare"
   themeMode={data.config.theme.mode}
   fontCssVars={data.fontCssVars}
   searchEnabled={data.config.search.enabled}
@@ -1338,16 +1384,50 @@ const LayoutComponent = resolveSlot(layoutOverrides.Layout, RootLayout);
   {
     items.length === 0 ? (
       <p>No changelog entries yet.</p>
+    ) : paginate ? (
+      <blume-changelog class="not-prose mt-8 block">
+        {majorGroups[0].items.map(({ Content, href, id, label, date, tags }) => (
+          <Update description={date} href={href} id={id} label={label} tags={tags}>
+            <Content />
+          </Update>
+        ))}
+        {majorGroups.slice(1).map((group) => (
+          <section
+            aria-label={group.label + " releases"}
+            data-changelog-label={group.label}
+            data-changelog-major={group.major}
+          >
+            {group.items.map(({ Content, href, id, label, date, tags }) => (
+              <Update description={date} href={href} id={id} label={label} tags={tags}>
+                <Content />
+              </Update>
+            ))}
+          </section>
+        ))}
+        <div class="mt-10 flex justify-center">
+          <button
+            class="inline-flex items-center gap-2 rounded-full border border-border bg-background px-4 py-2 font-medium text-muted-foreground text-sm transition-colors hover:bg-muted hover:text-foreground"
+            data-changelog-more
+            hidden
+            type="button"
+          >
+            Show older releases
+          </button>
+        </div>
+      </blume-changelog>
     ) : (
       <div class="not-prose mt-8">
-        {items.map(({ Content, id, label, date, tags }) => (
-          <Update description={date} id={id} label={label} tags={tags}>
+        {items.map(({ Content, href, id, label, date, tags }) => (
+          <Update description={date} href={href} id={id} label={label} tags={tags}>
             <Content />
           </Update>
         ))}
       </div>
     )
   }
+  <script>
+    import "blume/components/content/changelog-element.ts";
+  </script>
 </LayoutComponent>
 `;
 };

package/src/cli/commands/build.ts

@@ -5,11 +5,16 @@ import { build } from "astro";
 import { defineCommand } from "citty";
 import { join } from "pathe";
 
+import { buildAgentReadability } from "../../ai/agent-readability.ts";
 import { buildLlmsFiles } from "../../ai/llms.ts";
 import { ensureGitignore } from "../../core/gitignore.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
 import type { ResolvedConfig } from "../../core/schema.ts";
 import { serverFeatures } from "../../core/server-features.ts";
+import {
+  deployStaticDir,
+  surfaceAdapterOutput,
+} from "../../deploy/adapter-output.ts";
 import {
   buildNetlifyRedirects,
   buildRedirectManifest,
@@ -218,6 +223,19 @@ const publishBuildArtifacts = async (
     logger.success("Generated robots.txt");
   }
 
+  const agentReadability = buildAgentReadability(project);
+  if (
+    agentReadability &&
+    !existsSync(join(distDir, "agent-readability.json"))
+  ) {
+    await writeFile(
+      join(distDir, "agent-readability.json"),
+      `${JSON.stringify(agentReadability, null, 2)}\n`,
+      "utf-8"
+    );
+    logger.success("Generated agent-readability.json");
+  }
+
   await emitRedirectFiles(project.config, distDir);
 
   const { config } = project;
@@ -231,6 +249,7 @@ const publishBuildArtifacts = async (
       `Redirects  ${config.redirects.length}`,
       `Sitemap    ${sitemap ? "yes" : "no (set deployment.site)"}`,
       `Robots     ${robots ? "yes" : "no"}`,
+      `Agent JSON ${agentReadability ? "yes" : "no"}`,
       `LLM files  ${config.ai.llmsTxt ? "yes" : "no"}`,
       `Server features  ${features.length > 0 ? features.join(", ") : "none"}`,
     ].join("\n")
@@ -350,6 +369,27 @@ export const buildCommand = defineCommand({
       return;
     }
 
-    await publishBuildArtifacts(project, distDir, args);
+    // A server adapter (Vercel/Netlify) writes its deploy bundle relative to the
+    // Astro root — which Blume points at the hidden `.blume` runtime — so the
+    // bundle lands where the deploy platform never looks. Surface it up to the
+    // project root before publishing artifacts into the served static dir.
+    const surfaced = await surfaceAdapterOutput(
+      project.config,
+      project.context
+    );
+    if (surfaced.moved) {
+      logger.success(
+        `Surfaced ${project.config.deployment.adapter} output to ${surfaced.to}`
+      );
+      // The surfaced bundle is a build artifact — keep it out of version control
+      // (Vercel's own CLI ignores `.vercel/` for the same reason).
+      await ensureGitignore(root, [surfaced.ignore]);
+    }
+
+    await publishBuildArtifacts(
+      project,
+      deployStaticDir(project.config, project.context),
+      args
+    );
   },
 });

package/src/cli/commands/dev.ts

@@ -6,9 +6,15 @@ import { defineCommand } from "citty";
 import { generateRuntime } from "../../astro/generate.ts";
 import { showBlumeErrorOverlay } from "../../astro/integration.ts";
 import { scanProject } from "../../core/project-graph.ts";
+import { resolveRuntimeDir } from "../../core/project.ts";
 import { parsePort } from "../args.ts";
 import { coalescedRunner } from "../coalesce.ts";
-import { acquireDevLock, isDevLocked } from "../dev-lock.ts";
+import {
+  acquireDevLock,
+  describeDevLock,
+  readDevLock,
+  updateDevLockPort,
+} from "../dev-lock.ts";
 import { logger } from "../log.ts";
 import { prepareProject } from "../prepare.ts";
 
@@ -47,6 +53,23 @@ export const devCommand = defineCommand({
     const explicitPort = parsePort(args.port);
     const port = explicitPort ?? 4321;
     const devServerUrl = `http://localhost:${port}`;
+
+    // Claim the shared `.blume` dir BEFORE preparing: `prepareProject`
+    // regenerates the runtime, so even a refused second dev server would
+    // otherwise clobber the running one's generated tree (with this
+    // invocation's port baked in) on its way out. Dev never relocates the
+    // runtime dir, so the lock always lives at `<root>/.blume`.
+    const outDir = resolveRuntimeDir(root);
+    const running = readDevLock(outDir);
+    if (running) {
+      logger.error(
+        `A \`blume dev\` server is already running${describeDevLock(running)} in this project. Reuse that server instead of starting a second one — two dev servers would corrupt the shared .blume dir. If it crashed, delete .blume/dev.lock.`
+      );
+      process.exit(1);
+    }
+    const releaseLock = acquireDevLock(outDir, port);
+    process.on("exit", releaseLock);
+
     const project = await prepareProject({
       devServerUrl,
       mode: "dev",
@@ -56,19 +79,6 @@ export const devCommand = defineCommand({
       strict: args.strict,
     });
 
-    // Claim the shared `.blume` dir so a concurrent build/eject/sync refuses
-    // rather than regenerating or deleting it out from under this server. A
-    // second dev server would fight over the same generated tree the same
-    // way, so it must refuse too instead of silently clobbering the lock.
-    if (isDevLocked(project.context.outDir)) {
-      logger.error(
-        "Another `blume dev` is already running in this project; two dev servers would corrupt the shared .blume dir. Stop the other one first (or delete .blume/dev.lock if it crashed)."
-      );
-      process.exit(1);
-    }
-    const releaseLock = acquireDevLock(project.context.outDir);
-    process.on("exit", releaseLock);
-
     const server = await dev({
       logLevel: args.debug ? "debug" : "info",
       root: project.context.outDir,
@@ -79,6 +89,13 @@ export const devCommand = defineCommand({
       },
     });
 
+    // Vite bumps to the next free port when the default is taken, so record
+    // the port the server actually bound — the lock's URL is what a refused
+    // second invocation tells its caller to reuse.
+    if (server.address.port !== port) {
+      updateDevLockPort(outDir, server.address.port);
+    }
+
     // Mirror any initial diagnostics into the browser overlay now the server
     // (and its HMR channel) is up.
     showBlumeErrorOverlay(project.diagnostics);