blume 1.3.1 → 1.4.1

package/src/ai/agent-readability.ts

@@ -93,12 +93,15 @@ export const buildAgentReadability = (
 
   // Advertise `Accept: text/markdown` negotiation only where the deployed site
   // actually honors it — a Vercel server build, whose routing config gets the
-  // rewrite rules (see `deploy/vercel-negotiation.ts`). Static builds and other
-  // adapters serve prerendered pages from a static layer with no request-time
-  // hook, so agents there should fetch the `.md` pattern directly.
+  // rewrite rules (see `deploy/vercel-negotiation.ts`), and a Cloudflare server
+  // build, whose deploy bundle gets a wrapper Worker (see
+  // `deploy/cloudflare-negotiation.ts`). Static builds and other adapters serve
+  // prerendered pages from a static layer with no request-time hook, so agents
+  // there should fetch the `.md` pattern directly.
   const negotiates =
     config.deployment.output === "server" &&
-    config.deployment.adapter === "vercel";
+    (config.deployment.adapter === "vercel" ||
+      config.deployment.adapter === "cloudflare");
   const artifacts: Record<string, unknown> = {
     markdown: {
       ...(negotiates ? { contentNegotiation: "text/markdown" } : {}),

package/src/ai/ask-context.ts

@@ -226,12 +226,9 @@ export const createAskContext = (
       ? byRoute.get(normalizeRoute(page.path))
       : undefined;
     const db = await index();
-    const hits = await queryOramaIndex(
-      db,
-      query,
-      MAX_RESULTS,
-      current?.locale || undefined
-    );
+    const hits = await queryOramaIndex(db, query, MAX_RESULTS, {
+      locale: current?.locale || undefined,
+    });
 
     const seen = new Set<string>();
     const sections: string[] = [];

package/src/ai/component-markdown.ts

@@ -1,3 +1,4 @@
+import { markdownTable } from "markdown-table";
 import { mdxToMdast } from "satteri";
 
 import { parseYouTubeId } from "../components/content/youtube.ts";
@@ -238,15 +239,15 @@ const typeTable: ComponentMarkdown = ({ children, props }) => {
         .filter((part) => typeof part === "string" && part !== "")
         .join(" ")
     );
-    return `| ${prop} | ${typeCell} | ${defaultCell} | ${description} |`;
+    return [prop, typeCell, defaultCell, description];
   });
   const table =
     rows.length > 0
-      ? [
-          "| Prop | Type | Default | Description |",
-          "| --- | --- | --- | --- |",
-          ...rows,
-        ].join("\n")
+      ? markdownTable([["Prop", "Type", "Default", "Description"], ...rows], {
+          // Unpadded columns: cells hold prose and the output is for model
+          // consumption, so aligned delimiter rows are wasted tokens.
+          alignDelimiters: false,
+        })
       : "";
   // The component renders its slot after the table.
   return [table, children].filter(Boolean).join("\n\n");

package/src/ai/mcp/data.ts

@@ -2,6 +2,7 @@ import { normalizeBasePath } from "../../core/base-path.ts";
 import type { BlumeProject } from "../../core/project-graph.ts";
 import type { Navigation } from "../../core/types.ts";
 import { buildSearchDocuments } from "../../search/documents.ts";
+import { pageFacets } from "../../search/facets.ts";
 import type { OramaDoc } from "../../search/orama-index.ts";
 import { agentMarkdown, buildRawMarkdown } from "../markdown.ts";
 
@@ -9,6 +10,8 @@ import { agentMarkdown, buildRawMarkdown } from "../markdown.ts";
 export interface McpRoute {
   contentType: string;
   description?: string;
+  /** Declared facet values (`content.types.<type>.facets`), key → value. */
+  facets?: Record<string, string>;
   indexable: boolean;
   lastModified: string | null;
   route: string;
@@ -67,18 +70,19 @@ export const buildMcpData = async (project: BlumeProject): Promise<McpData> => {
     ])
   );
 
-  const descriptionById = new Map(
-    graph.pages.map((page) => [page.id, page.description])
-  );
+  const pageById = new Map(graph.pages.map((page) => [page.id, page]));
 
   const routes: McpRoute[] = [];
   for (const route of manifest.routes) {
     if (route.hidden) {
       continue;
     }
+    const page = pageById.get(route.id);
+    const facets = page ? pageFacets(page, config) : undefined;
     routes.push({
       contentType: route.contentType,
-      description: descriptionById.get(route.id),
+      description: page?.description,
+      ...(facets ? { facets } : {}),
       indexable: route.indexable,
       lastModified: route.lastModified ?? null,
       route: route.path,
@@ -91,7 +95,9 @@ export const buildMcpData = async (project: BlumeProject): Promise<McpData> => {
     defaultLocale: config.i18n?.defaultLocale,
     documents: documents.map((doc) => ({
       content: doc.content,
+      contentType: doc.contentType,
       description: doc.description,
+      ...(doc.facets ? { facets: doc.facets } : {}),
       route: doc.route,
       title: doc.title,
     })),

package/src/ai/mcp/server.ts

@@ -33,6 +33,22 @@ const CORS_HEADERS: Record<string, string> = {
   "Access-Control-Expose-Headers": "Mcp-Session-Id",
 };
 
+/** The optional content-type filter `search_docs` and `list_pages` share. */
+const CONTENT_TYPES_SCHEMA = {
+  description:
+    'Only include pages of these content types (frontmatter `type`, e.g. `["doc", "rfc"]`). `list_pages` shows each page\'s type. Omit to include every type.',
+  items: { type: "string" },
+  type: "array",
+} as const;
+
+/** The optional facet filter `search_docs` and `list_pages` share. */
+const FILTERS_SCHEMA = {
+  additionalProperties: { type: "string" },
+  description:
+    'Only include pages matching every facet, key → required value (e.g. `{"status": "enforced"}`). Facets are metadata the site declares per content type; `list_pages` shows each page\'s facet values. Omit for no facet filtering.',
+  type: "object",
+} as const;
+
 /** JSON Schema for each tool's input, keyed by tool name. */
 const INPUT_SCHEMAS: Record<string, Record<string, unknown>> = {
   get_navigation: { properties: {}, type: "object" },
@@ -46,9 +62,17 @@ const INPUT_SCHEMAS: Record<string, Record<string, unknown>> = {
     required: ["route"],
     type: "object",
   },
-  list_pages: { properties: {}, type: "object" },
+  list_pages: {
+    properties: {
+      contentTypes: CONTENT_TYPES_SCHEMA,
+      filters: FILTERS_SCHEMA,
+    },
+    type: "object",
+  },
   search_docs: {
     properties: {
+      contentTypes: CONTENT_TYPES_SCHEMA,
+      filters: FILTERS_SCHEMA,
       limit: {
         description: `Maximum hits to return (default ${DEFAULT_SEARCH_LIMIT}).`,
         maximum: MAX_SEARCH_LIMIT,
@@ -74,6 +98,39 @@ const TOOL_DEFINITIONS = MCP_TOOLS.map((tool) => ({
 const asString = (value: unknown): string =>
   typeof value === "string" ? value : "";
 
+/**
+ * The `contentTypes` filter as a string array, or `undefined` when absent or
+ * empty — an agent sending `[]` means "no filter", not "match nothing". A bare
+ * string is accepted as a one-element list.
+ */
+const asContentTypes = (value: unknown): string[] | undefined => {
+  const list = Array.isArray(value)
+    ? value.filter((entry): entry is string => typeof entry === "string")
+    : [value].filter((entry): entry is string => typeof entry === "string");
+  return list.length > 0 ? list : undefined;
+};
+
+/**
+ * The `filters` facet map with only its string-valued entries, or `undefined`
+ * when nothing usable remains — an empty `{}` means "no filter".
+ */
+const asFacetFilters = (value: unknown): Record<string, string> | undefined => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return;
+  }
+  const entries = Object.entries(value).filter(
+    (entry): entry is [string, string] => typeof entry[1] === "string"
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+};
+
+/** Whether a page's facet values satisfy every requested filter entry. */
+const matchesFacets = (
+  facets: Record<string, string> | undefined,
+  filters: Record<string, string>
+): boolean =>
+  Object.entries(filters).every(([key, value]) => facets?.[key] === value);
+
 const asLimit = (value: unknown): number => {
   const num = typeof value === "number" ? value : Number(value);
   if (!Number.isFinite(num)) {
@@ -181,12 +238,18 @@ export const buildServer = (
       const hits = await queryOramaIndex(
         db,
         asString(args.query),
-        asLimit(args.limit)
+        asLimit(args.limit),
+        {
+          contentTypes: asContentTypes(args.contentTypes),
+          facets: asFacetFilters(args.filters),
+        }
       );
       // `route` is the key `get_page` takes (the tool descriptions promise
       // it); `url` is where the page is served.
       const results = hits.map((doc: OramaDoc) => ({
+        contentType: doc.contentType,
         excerpt: excerptFor(doc),
+        facets: doc.facets,
         route: doc.route,
         title: doc.title,
         url: urlFor(doc.route, data),
@@ -207,11 +270,19 @@ export const buildServer = (
     }
 
     if (name === "list_pages") {
+      const contentTypes = asContentTypes(args.contentTypes);
+      const filters = asFacetFilters(args.filters);
+      const routes = data.routes.filter(
+        (route) =>
+          (!contentTypes || contentTypes.includes(route.contentType)) &&
+          (!filters || matchesFacets(route.facets, filters))
+      );
       return text(
         JSON.stringify(
-          data.routes.map((route) => ({
+          routes.map((route) => ({
             contentType: route.contentType,
             description: route.description,
+            facets: route.facets,
             lastModified: route.lastModified,
             route: route.route,
             title: route.title,

package/src/ai/mcp/tools.ts

@@ -19,7 +19,7 @@ export const MCP_TOOLS: McpToolMeta[] = [
   {
     annotations: READ_ONLY,
     description:
-      "Full-text search across the documentation. Returns matching pages with their title, route, and a short excerpt. Use this first to discover relevant pages, then `get_page` to read one in full.",
+      'Full-text search across the documentation. Returns matching pages with their title, route, content type, and a short excerpt; pass `contentTypes` to search only pages of certain types (e.g. `rfc`, `changelog`), and `filters` to require facet values the site declares per type (e.g. `{"status": "enforced"}`). Use this first to discover relevant pages, then `get_page` to read one in full.',
     name: "search_docs",
     title: "Search documentation",
   },
@@ -33,7 +33,7 @@ export const MCP_TOOLS: McpToolMeta[] = [
   {
     annotations: READ_ONLY,
     description:
-      "List every documentation page with its route, title, description, and content type. Useful for enumerating the docs or finding a page when search is too narrow.",
+      "List every documentation page with its route, title, description, content type, and any declared facet values; pass `contentTypes` and/or `filters` to narrow the list. Useful for enumerating the docs, discovering the types and facets in use, or finding a page when search is too narrow.",
     name: "list_pages",
     title: "List pages",
   },

package/src/astro/generate.ts

@@ -6,10 +6,8 @@ import {
   readFile,
   readlink,
   realpath,
-  rename,
   rm,
   symlink,
-  writeFile,
 } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
@@ -33,6 +31,7 @@ import type {
   BlumeLogo,
 } from "../core/data.ts";
 import { BlumeError } from "../core/diagnostics.ts";
+import { writeTextAtomic } from "../core/fs-atomic.ts";
 import { EN_UI, resolveUIStrings } from "../core/i18n-ui.ts";
 import { resolveFallbackLocale } from "../core/i18n.ts";
 import {
@@ -762,17 +761,9 @@ const writeIfChanged = async (
   if (existing === content) {
     return false;
   }
-  await mkdir(dirname(path), { recursive: true });
-  // Write to a temp file then atomically rename into place, so a watching dev
-  // server never observes a missing or half-written file mid-regeneration.
-  const tmp = `${path}.${process.pid}.tmp`;
-  await writeFile(tmp, content, "utf-8");
-  try {
-    await rename(tmp, path);
-  } catch (error) {
-    await rm(tmp, { force: true });
-    throw error;
-  }
+  // Atomic temp-write + rename, so a watching dev server never observes a
+  // missing or half-written file mid-regeneration.
+  await writeTextAtomic(path, content);
   return true;
 };
 

package/src/astro/integration.ts

@@ -114,7 +114,9 @@ const isHomeUrl = (rawUrl: string | undefined, base?: string): boolean => {
  * production the content pages are prerendered and served from the platform's
  * static layer, which this middleware never fronts. Vercel server builds get
  * the same negotiation from routing rules spliced into the Build Output config
- * (see `deploy/vercel-negotiation.ts`); every other build exposes the same
+ * (see `deploy/vercel-negotiation.ts`), Cloudflare server builds from a
+ * wrapper Worker routed to by `assets.run_worker_first` (see
+ * `deploy/cloudflare-negotiation.ts`); every other build exposes the same
  * content at the `.md` URL. Only routes with a Markdown variant are rewritten,
  * so user `.astro` pages keep serving HTML — except the homepage, whose
  * variant falls back to the synthesized llms.txt mirror when it's a landing

package/src/astro/islands.ts

@@ -83,7 +83,10 @@ export const discoverIslands = async (
   root: string
 ): Promise<IslandDiscovery> => {
   const dir = join(root, "islands");
-  const matches = await glob(["**/*.{jsx,svelte,tsx,vue}"], {
+  // Enumerate everything and let ISLAND_FILE do the filtering below, so
+  // unknown extensions take the skip guard instead of relying on a glob
+  // pattern staying in sync with the regex and framework map.
+  const matches = await glob(["**/*"], {
     absolute: true,
     cwd: dir,
     onlyFiles: true,

package/src/astro/markdown-negotiation.ts

@@ -3,6 +3,11 @@
  * endpoints already serve a page's source verbatim; these helpers let the dev
  * server honor `Accept: text/markdown` by transparently rewriting a page
  * request to its `.md` variant.
+ *
+ * The Cloudflare negotiation Worker embeds a plain-JavaScript copy of these
+ * helpers (`deploy/cloudflare-negotiation.ts` — its deploy bundle is uploaded
+ * unbundled, so it cannot import this module); when editing here, mirror the
+ * change there. Parity is enforced by `test/cloudflare-negotiation.test.ts`.
  */
 
 interface AcceptEntry {

package/src/astro/templates.ts

@@ -370,6 +370,38 @@ const renderImageOption = (config: ResolvedConfig): string =>
     ? `\n  image: ${JSON.stringify(config.image)},`
     : "";
 
+/**
+ * Startup-scan entry points and forced includes for the dev dep optimizer:
+ * the Vite root is the generated runtime, so user pages, convention islands,
+ * and alias-reachable components all live outside it and are otherwise only
+ * crawled when first requested. The compiler runtime rides the include list
+ * because it is Babel-injected and no source scan can see it. See the
+ * optimizeDeps comment in the generated config for the failure this prevents.
+ */
+const resolveOptimizeDeps = (options: {
+  aliases: Record<string, string> | undefined;
+  context: ProjectContext;
+  needsReact: boolean;
+  reactCompilerPath: string | null | undefined;
+}): { optimizeDepsEntries: string[]; optimizeDepsInclude: string[] } => {
+  const { context } = options;
+  const optimizeDepsEntries = [
+    ...(context.pagesRoot ? [`${context.pagesRoot}/**/*.astro`] : []),
+    `${context.root}/islands/**/*.{jsx,svelte,tsx,vue}`,
+    ...[...new Set(Object.values(options.aliases ?? {}))]
+      .toSorted()
+      .map((dir) => `${dir}/**/*.{astro,jsx,svelte,tsx,vue}`),
+  ];
+  const optimizeDepsInclude = [
+    "blume > mermaid",
+    "blume > epub-gen-memory/bundle",
+    ...(options.needsReact && options.reactCompilerPath
+      ? ["react/compiler-runtime"]
+      : []),
+  ];
+  return { optimizeDepsEntries, optimizeDepsInclude };
+};
+
 export const astroConfigTemplate = (options: {
   context: ProjectContext;
   config: ResolvedConfig;
@@ -424,6 +456,13 @@ export const astroConfigTemplate = (options: {
   // KaTeX fonts under a monorepo's root node_modules) stay servable in dev.
   const fsAllow = [...new Set([findWorkspaceRoot(context.root), context.root])];
 
+  const { optimizeDepsEntries, optimizeDepsInclude } = resolveOptimizeDeps({
+    aliases: options.aliases,
+    context,
+    needsReact,
+    reactCompilerPath: options.reactCompilerPath,
+  });
+
   const adapterImport =
     server && deployment.adapter
       ? `import adapter from "${ADAPTER_IMPORTS[deployment.adapter]}";\n`
@@ -642,24 +681,32 @@ ${userConfigSetup}export default defineConfig({
   devToolbar: { enabled: false },
   vite: {
     plugins: [tailwindcss(), prerenderDepsPlugin(), serverAppResolvePlugin()],
-    // The lazy client-side imports both land on CJS/UMD files: mermaid (for
-    // diagrams) statically imports dayjs as CJS (\`dayjs/dayjs.min.js\`), and
-    // epub-gen-memory's browser bundle is a browserified UMD. In dev, an
-    // un-pre-bundled dependency is served as raw ESM, where such a file
-    // exposes no \`default\` export — mermaid throws on load and diagrams
-    // render blank, and the EPUB export throws \`epub is not a function\`
-    // (the UMD finds no \`exports\`/\`define\` and strands its callable on
-    // \`window.epubGen\` instead). Forcing them through the dep optimizer
-    // restores the CJS interop. In a standalone install these dynamic imports
-    // live inside \`node_modules/blume\`, which Vite's optimizer scan doesn't
-    // crawl, so neither is discovered on its own — hence the explicit
-    // includes. They resolve through the \`blume\` package (they aren't direct
-    // deps of the generated project), so the nested \`blume > x\` form is
-    // required, and epub-gen-memory must name the \`/bundle\` subpath that is
-    // actually imported: optimizing the package root leaves that entry out.
-    // Production (Rollup) already handles the interop, so this only affects dev.
+    // Everything hydration can reach must be part of the dev dep optimizer's
+    // FIRST run. The Vite root is the generated runtime, so user pages,
+    // islands, and aliased components live outside it and are only crawled
+    // when first requested — and \`react/compiler-runtime\` is Babel-injected,
+    // so no source scan can ever see it. A dependency discovered after
+    // hydration begins triggers a mid-session re-optimization whose new
+    // generation imports React through new \`?v=\` URLs; the browser then
+    // evaluates a second React copy and every island tears down with
+    // "Invalid hook call" (#157). \`entries\` points the startup scanner at
+    // the user's files (the scanner follows their imports, so their deps land
+    // in the initial optimization); the compiler runtime rides the include
+    // list because only the transform pipeline knows it exists.
+    //
+    // The mermaid/epub includes fix CJS interop instead: both lazy client-side
+    // imports land on CJS/UMD files (mermaid statically imports dayjs as CJS,
+    // epub-gen-memory's browser bundle is a browserified UMD) that break when
+    // served as raw ESM — mermaid throws on load and the EPUB export throws
+    // \`epub is not a function\`. They resolve through the \`blume\` package
+    // (they aren't direct deps of the generated project), so the nested
+    // \`blume > x\` form is required, and epub-gen-memory must name the
+    // \`/bundle\` subpath that is actually imported: optimizing the package
+    // root leaves that entry out. Production (Rollup) already handles the
+    // interop, so all of this only affects dev.
     optimizeDeps: {
-      include: ["blume > mermaid", "blume > epub-gen-memory/bundle"],
+      entries: ${JSON.stringify(optimizeDepsEntries)},
+      include: ${JSON.stringify(optimizeDepsInclude)},
     },
     // Blume's render-time deps are forced external on both build environments so
     // native bindings resolve at runtime and isolated linkers don't bundle
@@ -1080,10 +1127,9 @@ export const searchClientTemplate = (config: ResolvedConfig): string => {
   if (search.provider === "orama" || search.provider === "flexsearch") {
     // Only Orama derives a tokenizer from the locale; FlexSearch has no
     // equivalent hook, so its client keeps the bare index URL.
-    return staticSearchClient(
-      search.provider,
-      search.provider === "orama" ? config.i18n?.defaultLocale : undefined
-    );
+    const locale =
+      search.provider === "orama" ? config.i18n?.defaultLocale : undefined;
+    return staticSearchClient(search.provider, locale);
   }
 
   const hosted = hostedSearchOptions(search);
@@ -1309,11 +1355,12 @@ export const mcpEndpointTemplate = (route: string): string => {
   return `// Generated by Blume. Do not edit.
 import type { APIRoute } from "astro";
 import { createMcpFetchHandler } from "blume/ai/mcp/server.ts";
+import type { McpData } from "blume/ai/mcp/data.ts";
 import data from "${up}generated/mcp-data.json";
 
 export const prerender = false;
 
-const handler = createMcpFetchHandler(data);
+const handler = createMcpFetchHandler(data as McpData);
 
 export const ALL: APIRoute = ({ request }) => handler(request);
 `;

package/src/audit/checks/indexability.ts

@@ -8,12 +8,9 @@ import type { AuditContext, CheckModule, PageSnapshot } from "../types.ts";
 import { decodePath, 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;
-  }
+const parseCanonical = (canonical: string): URL | null => {
   try {
-    return new URL(page.canonical);
+    return new URL(canonical);
   } catch {
     return null;
   }
@@ -48,7 +45,7 @@ const canonicalChecks = (
       : [];
   }
 
-  const canonical = parseCanonical(page);
+  const canonical = parseCanonical(page.canonical);
   if (!canonical) {
     return [
       finding(

package/src/audit/checks/robots.ts

@@ -1,40 +1,16 @@
+import robotsParser from "robots-parser";
+
 import type { Diagnostic } from "../../core/types.ts";
 import { finding } from "../catalog.ts";
 import type { CheckModule } from "../types.ts";
 import { normalizePath } from "../url.ts";
 
 /**
- * Whether a robots.txt `Disallow` value covers a path. robots.txt matching is
- * prefix-based, with `*` as a wildcard and `$` anchoring the end.
+ * robots-parser needs full URLs on a single origin; the origin itself is
+ * irrelevant to path matching, so a fixed placeholder keeps the check
+ * independent of whether the project configured `deployment.site`.
  */
-export const disallowMatches = (rule: string, path: string): boolean => {
-  const anchored = rule.endsWith("$");
-  const pattern = anchored ? rule.slice(0, -1) : rule;
-  const parts = pattern.split("*");
-
-  let cursor = 0;
-  for (const [index, part] of parts.entries()) {
-    if (part === "") {
-      continue;
-    }
-    // The first segment is anchored to the start of the path (robots.txt rules
-    // are prefix matches); every later segment may appear anywhere after the
-    // previous one, which is what makes `*` a wildcard.
-    let at: number;
-    if (index === 0) {
-      at = path.startsWith(part) ? 0 : -1;
-    } else {
-      at = path.indexOf(part, cursor);
-    }
-    if (at === -1) {
-      return false;
-    }
-    cursor = at + part.length;
-  }
-  // A wildcard just before `$` (`/docs*$`) absorbs the rest of the path, so
-  // the anchor is already satisfied by any prefix match.
-  return anchored && !pattern.endsWith("*") ? cursor === path.length : true;
-};
+const MATCH_ORIGIN = "https://robots-audit.invalid";
 
 /**
  * robots.txt: is it there, is it well-formed, does it point at the sitemap, and
@@ -82,8 +58,13 @@ export const robotsChecks: CheckModule = {
     }
 
     // A page can't be both blocked from crawling and advertised for indexing.
-    // Checking the disallow rules against the sitemap (rather than against every
-    // built file) keeps this to the pages the site actually wants indexed.
+    // Checking the rules against the sitemap (rather than against every built
+    // file) keeps this to the pages the site actually wants indexed.
+    // robots-parser resolves Allow/Disallow by longest match, so the common
+    // `Disallow: /` + `Allow: /docs/` pattern doesn't flag every page, and
+    // consecutive User-agent lines form one group as the spec requires.
+    const parser = robotsParser(`${MATCH_ORIGIN}/robots.txt`, robots.raw);
+    const lines = robots.raw.split(/\r?\n/u);
     for (const loc of context.sitemap?.urls ?? []) {
       let pathname: string;
       try {
@@ -94,15 +75,15 @@ export const robotsChecks: CheckModule = {
       // Match the pathname as served: robots.txt rules are literal prefixes,
       // so `Disallow: /page/` must see the trailing slash to match.
       const path = normalizePath(pathname);
-      const rule = robots.disallow.find((entry) =>
-        disallowMatches(entry, pathname)
-      );
-      if (rule) {
+      const url = `${MATCH_ORIGIN}${pathname}`;
+      if (parser.isDisallowed(url, "*")) {
+        const line = parser.getMatchingLineNumber(url, "*");
+        const rule = line > 0 ? lines[line - 1]?.trim() : undefined;
         found.push(
           finding(
             "BLUME_AUDIT_ROBOTS_DISALLOWS_INDEXABLE",
             { file: robots.file, url: path },
-            `robots.txt "Disallow: ${rule}" blocks ${path}, which sitemap.xml advertises.`
+            `robots.txt "${rule ?? "Disallow"}" blocks ${path}, which sitemap.xml advertises.`
           )
         );
       }