nuxt-ai-ready 2.1.0 → 2.2.1

package/dist/runtime/server/utils/i18n.js

@@ -7,3 +7,16 @@ export {
 export function getRuntimeI18n(aiReadyConfig) {
   return aiReadyConfig.i18n || null;
 }
+export function normalizeHost(value) {
+  return value.trim().toLowerCase().replace(/^[a-z][a-z\d+.-]*:\/\//, "").split("/")[0];
+}
+export function hostMatchesLocaleDomain(host, i18n) {
+  if (!host)
+    return false;
+  const normalized = normalizeHost(host);
+  if (!normalized)
+    return false;
+  return i18n.locales.some(
+    (locale) => [...locale.domains ?? [], locale.domain, ...locale.defaultForDomains ?? []].some((domain) => domain && normalizeHost(domain) === normalized)
+  );
+}

package/dist/runtime/server/utils/indexPage.js

@@ -98,5 +98,11 @@ export async function indexPageByRoute(route, event, options = {}) {
     }
     return { success: false, error: `Failed to fetch HTML for ${route}` };
   }
-  return indexPage(route, html, options, event);
+  try {
+    return await indexPage(route, html, options, event);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    logger.warn(`[indexPageByRoute] Failed to index ${route}:`, message);
+    return { success: false, error: message || `Failed to index ${route}` };
+  }
 }

package/dist/runtime/server/utils/link-header.d.ts

@@ -8,10 +8,12 @@ import type { RuntimeI18nConfig, RuntimeRouteContext } from './i18n.js';
  */
 export declare function encodePathForHeader(path: string): string;
 type LinkUrlResolver = (path: string) => string;
+export declare const LLMS_TXT_PATH = "/llms.txt";
 interface LinkHeaderConfig {
     apiCatalog?: {
         href: string;
     };
+    describedby?: boolean;
     i18n?: RuntimeI18nConfig | null;
 }
 /**

package/dist/runtime/server/utils/link-header.js

@@ -4,6 +4,7 @@ import { computeLocaleAlternates } from "./i18n.js";
 export function encodePathForHeader(path) {
   return encodeURI(path);
 }
+export const LLMS_TXT_PATH = "/llms.txt";
 function resolveHeaderUrl(path, resolveUrl) {
   if (!resolveUrl)
     return path;
@@ -21,6 +22,11 @@ export function buildLinkHeader(path, variant, config, resolveUrl, routeContext
   } else {
     const href = resolveHeaderUrl(path, resolveUrl);
     parts.push(`<${encodePathForHeader(href)}>; rel="alternate"; type="text/html"`);
+    parts.push(`<${encodePathForHeader(href)}>; rel="canonical"`);
+  }
+  if (config.describedby !== false) {
+    const href = resolveHeaderUrl(LLMS_TXT_PATH, resolveUrl);
+    parts.push(`<${encodePathForHeader(href)}>; rel="describedby"`);
   }
   if (config.i18n) {
     const alternates = computeLocaleAlternates(path, config.i18n, routeContext);

package/dist/runtime/server/utils/markdown-request.js

@@ -1,6 +1,8 @@
 import { negotiateContent } from "@mdream/js/negotiate";
 import { getBotInfo } from "@nuxtjs/robots/util";
 import { getHeaders } from "#nuxtseo/h3";
+import { isReservedPath } from "../../markdown-path.js";
+const RE_MD_EXT = /\.md$/;
 export function toMarkdownRequest(event, isPrerender = !!import.meta.prerender) {
   return { path: event.path, headers: getHeaders(event), isPrerender };
 }
@@ -25,7 +27,7 @@ export function getRequestRenderInfo(request, mode = { _tag: "runtime", contentN
   const queryIndex = request.path.indexOf("?");
   const originalPath = queryIndex === -1 ? request.path : request.path.slice(0, queryIndex);
   const isPrerender = mode._tag === "prerender";
-  if (originalPath.startsWith("/api") || originalPath.startsWith("/_") || originalPath.startsWith("/@"))
+  if (isReservedPath(originalPath.replace(RE_MD_EXT, "")))
     return null;
   const accept = request.headers.accept || "";
   if (!originalPath.endsWith(".md") && accept && /\b(?:application\/json|text\/event-stream)\b/i.test(accept) && !/text\/(?:html|markdown|plain)\b|\*\/\*/i.test(accept)) {

package/dist/runtime/server/utils/runCron.d.ts

@@ -1,6 +1,25 @@
 import type { H3Event } from '#nuxtseo/h3';
 import type { StaleCheckResult } from './checkStale.js';
+/**
+ * Why a run could not finish.
+ *
+ * `lock` means the run never started, so nothing was changed. `run` means it
+ * started and stopped part way, so some work may already be committed.
+ */
+export interface CronFailure {
+    stage: 'lock' | 'run';
+    message: string;
+}
 export interface CronResult {
+    /**
+     * Set when the run failed.
+     *
+     * A scheduled task that throws reaches Cloudflare as `scriptThrewException`,
+     * which carries no stage, no message, and nothing a host can report. The
+     * failure travels back as a value instead, so the caller decides what to do
+     * with it.
+     */
+    failed?: CronFailure;
     runId?: number | null;
     stale?: StaleCheckResult;
     sitemap?: {
@@ -19,6 +38,11 @@ export interface CronResult {
 }
 /**
  * Run cron job logic - shared between scheduled task and HTTP endpoint
+ *
+ * This is the error boundary for the whole run. Nothing throws past it: the
+ * scheduled task has no request context and no handler above it, so a throw
+ * here becomes an opaque platform exception rather than something the host can
+ * report. Every failure comes back as `CronResult.failed`.
  */
 export declare function runCron(event: H3Event | undefined, options?: {
     batchSize?: number;

package/dist/runtime/server/utils/runCron.js

@@ -6,17 +6,34 @@ import { checkAndHandleStale, STALE_CHECK_INTERVAL_MS } from "./checkStale.js";
 import { resolveCronPlan, resolveSitemapIntervalMinutes } from "./cron-plan.js";
 import { crawlSitemapByRoute, getSitemapsFromConfig } from "./sitemap.js";
 import { mapSitemapRoutes } from "./sitemap-routes.js";
+function describeFailure(error) {
+  if (error instanceof Error)
+    return error.message;
+  return String(error);
+}
 export async function runCron(event, options) {
   if (import.meta.dev)
     return {};
+  return executeCron(event, options).catch((error) => {
+    const message = describeFailure(error);
+    logger.error(`[cron] Run failed: ${message}`);
+    return { failed: { stage: "run", message } };
+  });
+}
+async function executeCron(event, options) {
   const config = useRuntimeConfig()["nuxt-ai-ready"];
   const debug = config.debug;
   const startTime = Date.now();
   const results = {};
   const allErrors = [];
   const sitemapIntervalMinutes = resolveSitemapIntervalMinutes(config.runtimeSync.ttl);
-  const acquired = await tryAcquireCronLock(event);
-  if (!acquired) {
+  const lock = await tryAcquireCronLock(event).catch((error) => {
+    logger.error(`[cron] Could not acquire the lock: ${describeFailure(error)}`);
+    return null;
+  });
+  if (lock === null)
+    return { failed: { stage: "lock", message: "Could not acquire the cron lock" } };
+  if (lock._tag === "held") {
     if (debug) {
       logger.info(`[cron] Skipping - another cron run is in progress`);
     }
@@ -122,7 +139,7 @@ export async function runCron(event, options) {
     }
     return results;
   } finally {
-    await releaseCronLock(event).catch((err) => {
+    await releaseCronLock(event, lock.token).catch((err) => {
       logger.warn(`[cron] Failed to release lock: ${err?.message || err}`);
     });
   }
@@ -152,7 +169,7 @@ async function pingSitemap(event, config, sitemapIntervalMinutes, debug) {
     route: nextSitemap.route,
     state: nextSitemap.crawlState
   });
-  const routes = [...mapSitemapRoutes(result.urls).keys()];
+  const routes = [...mapSitemapRoutes(result.urls).entries()].map(([route, url]) => ({ route, url: url.loc }));
   if (routes.length > 0)
     await seedRoutes(event, routes);
   if (result._tag === "failed") {

package/dist/runtime/server/utils/sitemap-md.d.ts

@@ -0,0 +1,13 @@
+export declare const SITEMAP_MD_ROUTE = "/sitemap.md";
+export interface SitemapMdEntry {
+    route: string;
+    title?: string;
+    updatedAt?: string;
+}
+export interface SitemapMdOptions {
+    siteName?: string;
+    resolveHref?: (route: string) => string;
+}
+export declare function buildSitemapMd(entries: SitemapMdEntry[], options?: SitemapMdOptions): string;
+export declare function appendSitemapSection(markdown: string, sitemapHref?: string): string;
+export declare function isSitemapMdRequest(path: string, baseURL: string, enabled: boolean): boolean;

package/dist/runtime/server/utils/sitemap-md.js

@@ -0,0 +1,65 @@
+import { toMarkdownPath } from "../../markdown-path.js";
+import { toDeployedRoute } from "../../route-path.js";
+export const SITEMAP_MD_ROUTE = "/sitemap.md";
+function topSegment(route) {
+  return route.split("/").filter(Boolean)[0] || "";
+}
+function escapeTitle(title) {
+  return title.replaceAll("[", "\\[").replaceAll("]", "\\]");
+}
+function formatEntry(entry, resolveHref) {
+  const title = escapeTitle(entry.title?.trim() || entry.route);
+  const href = resolveHref(entry.route);
+  if (entry.updatedAt) {
+    const parsed = new Date(entry.updatedAt);
+    if (!Number.isNaN(parsed.getTime()))
+      return `- [${title}](${href} "${parsed.toISOString()}")`;
+  }
+  return `- [${title}](${href})`;
+}
+export function buildSitemapMd(entries, options = {}) {
+  const resolveHref = options.resolveHref || toMarkdownPath;
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of [...entries].sort((a, b) => a.route.localeCompare(b.route))) {
+    const key = topSegment(entry.route);
+    const group = groups.get(key);
+    if (group)
+      group.push(entry);
+    else
+      groups.set(key, [entry]);
+  }
+  const keys = [...groups.keys()].sort((a, b) => {
+    if (a === "")
+      return -1;
+    if (b === "")
+      return 1;
+    return a.localeCompare(b);
+  });
+  const parts = [`# ${options.siteName || "Site"} Sitemap`, "", "All pages in Markdown format."];
+  for (const key of keys) {
+    parts.push("", `## ${key || "Root"}`);
+    for (const entry of groups.get(key))
+      parts.push(formatEntry(entry, resolveHref));
+  }
+  return `${parts.join("\n")}
+`;
+}
+export function appendSitemapSection(markdown, sitemapHref = SITEMAP_MD_ROUTE) {
+  const section = `## Sitemap
+
+See the full [sitemap](${sitemapHref}) for all pages.`;
+  const trimmed = markdown.trimEnd();
+  if (trimmed.endsWith(section))
+    return `${trimmed}
+`;
+  return `${trimmed}
+
+${section}
+`;
+}
+export function isSitemapMdRequest(path, baseURL, enabled) {
+  if (!enabled)
+    return false;
+  const withoutQuery = path.split("?")[0] || path;
+  return withoutQuery === SITEMAP_MD_ROUTE || withoutQuery === toDeployedRoute(SITEMAP_MD_ROUTE, baseURL);
+}

package/dist/runtime/types.d.ts

@@ -149,6 +149,19 @@ export interface ModuleOptions {
      * Structured llms.txt configuration
      */
     llmsTxt?: LlmsTxtConfig;
+    /**
+     * Generate a Markdown sitemap at `/sitemap.md` from indexed pages and end
+     * every Markdown page with a `## Sitemap` section linking to it.
+     * @default true
+     */
+    sitemapMd?: boolean;
+    /**
+     * Advertise llms.txt as `rel="describedby"` from HTML and Markdown
+     * responses, as the llms.txt v2 spec requires. Emits an HTML `<link>` tag
+     * and a Link header entry pointing at the llms.txt route.
+     * @default true
+     */
+    describedby?: boolean;
     /**
      * Content Signal Directives
      */
@@ -258,7 +271,7 @@ export interface ModuleOptions {
         filename?: string;
         /**
          * D1 binding name for Cloudflare Workers/Pages
-         * @default 'AI_READY_DB'
+         * @default 'DB'
          */
         bindingName?: string;
         /**
@@ -272,7 +285,7 @@ export interface ModuleOptions {
         authToken?: string;
     };
     /**
-     * Enable scheduled cron task (runs every minute)
+     * Enable scheduled cron task (runs every 5 minutes)
      * When true, automatically enables runtimeSync for background indexing
      */
     cron?: boolean;
@@ -322,7 +335,7 @@ export interface ModuleOptions {
         ttl?: number;
         /**
          * Pages to index per batch
-         * @default 20
+         * @default 50
          */
         batchSize?: number;
         /**

package/dist/shared/{nuxt-ai-ready.BTQAkSYt.mjs → nuxt-ai-ready.BVWXwmUS.mjs}

@@ -8,9 +8,12 @@ import { installNuxtSiteConfig, useSiteConfig, withSiteUrl } from 'nuxt-site-con
 import { resolveNuxtContentVersion, renderNitroTypeAugmentations, setupNitroRuntimeCompatibility } from 'nuxtseo-shared/kit';
 import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isReservedPath, normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-path.js';
+import { SITEMAP_MD_ROUTE } from '../../dist/runtime/server/utils/sitemap-md.js';
 import { MCP_SERVER_CARD_MEDIA_TYPE, AI_CATALOG_MEDIA_TYPE } from '../../dist/runtime/server/utils/discovery-response.js';
 import { isAbsolute, join as join$1 } from 'pathe';
 import { resolveI18nConfig, toRuntimeI18nConfig as toRuntimeI18nConfig$1 } from 'nuxtseo-shared/i18n';
+import { toDeployedRoute } from '../../dist/runtime/route-path.js';
 
 const SELECT_PAGE_DATA = "SELECT route, title, description, markdown, headings, keywords, updated_at, is_error, locale FROM ai_ready_pages";
 function createBuildPageDataVirtual(options) {
@@ -175,7 +178,7 @@ function resolveModuleEntryUrl(url) {
 
 const MARKDOWN_LINK_AVAILABILITY_FILE = "markdown-link-availability.json";
 
-const declarativeWebMcpTypes = `
+const webmcpTypes = `
 import type { WebMcpToolsContext } from 'nuxt-ai-ready/webmcp'
 
 declare module '#app' {
@@ -184,37 +187,6 @@ declare module '#app' {
     'ai-ready:webmcp:tools': (context: WebMcpToolsContext) => void | Promise<void>
   }
 }
-
-declare module '@vue/runtime-dom' {
-  interface HTMLAttributes {
-    /** Names the tool this form exposes to agents. */
-    toolname?: string
-    /** Describes what submitting this form does. */
-    tooldescription?: string
-    /** Describes this field as a tool parameter. */
-    toolparamdescription?: string
-    /** Submit the form as soon as an agent fills it in. */
-    toolautosubmit?: boolean | ''
-  }
-}
-
-declare global {
-  interface SubmitEvent {
-    /** Whether an agent triggered this submit through a tool call. */
-    readonly agentInvoked?: boolean
-    /** Return a result to the agent. Call preventDefault() first. */
-    respondWith?: (result: Promise<unknown>) => void
-  }
-
-  interface WebMcpToolEvent extends Event {
-    readonly toolName: string
-  }
-
-  interface WindowEventMap {
-    toolactivated: WebMcpToolEvent
-    toolcancel: WebMcpToolEvent
-  }
-}
 `;
 function registerTypeTemplates(ctx) {
   const nitroTypes = renderNitroTypeAugmentations(ctx.nitroCompatibility, {
@@ -231,7 +203,7 @@ import type { MarkdownContext, MarkdownSourceContext, PageIndexedContext } from
 import type { MdreamOptions } from 'mdream'
 
 ${nitroTypes}
-${ctx.config.webmcp ? declarativeWebMcpTypes : ""}
+${ctx.config.webmcp ? webmcpTypes : ""}
 export {}
 `
   });
@@ -891,6 +863,85 @@ function ensureStaticHeader(contents, route, name, value) {
   const prefix = blockStart === routeLineEnd ? eol : "";
   return `${contents.slice(0, blockStart)}${prefix}  ${name}: ${value}${eol}${contents.slice(blockStart)}`;
 }
+const CLOUDFLARE_STATIC_HEADER_RULE_LIMIT = 100;
+const RE_EXACT_MARKDOWN_ROUTE = /^\/[^*\s]*\.md[\t ]*\r?$/;
+function splitHeaderBlocks(contents) {
+  const blocks = [];
+  let current = { route: null, text: "" };
+  for (const line of contents.split(/(?<=\n)/)) {
+    const isRoute = /^[^\s#]/.test(line);
+    if (isRoute) {
+      blocks.push(current);
+      current = { route: line.trimEnd(), text: "" };
+    }
+    current.text += line;
+  }
+  blocks.push(current);
+  return blocks;
+}
+function enforceStaticHeaderBudget(contents, limit) {
+  const blocks = splitHeaderBlocks(contents);
+  const ruleCount = blocks.filter((block) => block.route !== null).length;
+  if (ruleCount <= limit)
+    return { contents, total: ruleCount, dropped: 0 };
+  const kept = blocks.filter((block) => block.route === null || !RE_EXACT_MARKDOWN_ROUTE.test(block.route));
+  return {
+    contents: kept.map((block) => block.text).join(""),
+    total: kept.filter((block) => block.route !== null).length,
+    dropped: ruleCount - kept.filter((block) => block.route !== null).length
+  };
+}
+
+const RE_MD_EXT = /\.md$/;
+function isStaticMarkdownSourceRoute(route) {
+  if (route.includes("*") || route.includes(":"))
+    return false;
+  const path = route.split("?")[0] || route;
+  if (isReservedPath(path))
+    return false;
+  const lastSegment = path.split("/").pop() || "";
+  return !lastSegment.includes(".");
+}
+function staticDescribedbyEntry(baseURL) {
+  return `<${encodeURI(toDeployedRoute("/llms.txt", baseURL))}>; rel="describedby"`;
+}
+function buildStaticMarkdownLinkHeader(route, baseURL, describedby) {
+  const htmlRoute = encodeURI(toDeployedRoute(normalizePagePath(route), baseURL));
+  const parts = [
+    `<${htmlRoute}>; rel="alternate"; type="text/html"`,
+    `<${htmlRoute}>; rel="canonical"`
+  ];
+  if (describedby)
+    parts.push(staticDescribedbyEntry(baseURL));
+  return parts.join(", ");
+}
+function pageRouteFromMarkdownTwin(fileName) {
+  if (!fileName?.endsWith(".md") || fileName === SITEMAP_MD_ROUTE)
+    return null;
+  const pageRoute = normalizePagePath(fileName.replace(RE_MD_EXT, ""));
+  if (pageRoute === "/index")
+    return "/";
+  return isStaticMarkdownSourceRoute(pageRoute) ? pageRoute : null;
+}
+function prerenderedMarkdownHeaderRules(prerenderedRoutes, baseURL, describedby) {
+  const rules = /* @__PURE__ */ new Map();
+  for (const entry of prerenderedRoutes) {
+    const pageRoute = pageRouteFromMarkdownTwin(entry.fileName);
+    if (pageRoute === null)
+      continue;
+    const mdRoute = toMarkdownPath(pageRoute);
+    if (!rules.has(mdRoute)) {
+      rules.set(mdRoute, {
+        route: mdRoute,
+        headers: {
+          "Content-Type": "text/markdown; charset=utf-8",
+          "Link": buildStaticMarkdownLinkHeader(pageRoute, baseURL, describedby)
+        }
+      });
+    }
+  }
+  return [...rules.values()];
+}
 
 const DEFAULT_MAX_OUTPUT_CHARS = 1500;
 const DEFAULT_LIST_LIMIT = 20;
@@ -1216,7 +1267,12 @@ ${details}`);
         userAgent: "*",
         // Preserve nuxt-robots' default wildcard rule so the injected group remains valid.
         disallow: [""],
-        contentSignal: [`ai-train=${config.contentSignal.aiTrain ? "yes" : "no"}`, `search=${config.contentSignal.search ? "yes" : "no"}`, `ai-input=${config.contentSignal.aiInput ? "yes" : "no"}`]
+        // Object form renders one comma-separated line; an array renders one line per entry, which validators reject.
+        contentSignal: {
+          "ai-train": config.contentSignal.aiTrain ? "yes" : "no",
+          "search": config.contentSignal.search ? "yes" : "no",
+          "ai-input": config.contentSignal.aiInput ? "yes" : "no"
+        }
       };
       if (config.contentSignal.contentUsage !== false)
         group.contentUsage = [`train-ai=${config.contentSignal.aiTrain ? "y" : "n"}`];
@@ -1600,6 +1656,8 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       debugCron: config.debugCron || false,
       contentNegotiation: config.contentNegotiation === void 0 ? "auto" : config.contentNegotiation ? "enabled" : "disabled",
       mdreamOptions: config.mdreamOptions || {},
+      sitemapMd: config.sitemapMd !== false,
+      describedby: config.describedby !== false,
       markdownCacheHeaders: defu(config.markdownCacheHeaders, {
         maxAge: 3600,
         swr: true
@@ -1643,6 +1701,9 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
     });
     addServerHandler({ route: "/llms.txt", handler: resolve("./runtime/server/routes/llms.txt.get"), lazy: true });
     addServerHandler({ route: "/llms-full.txt", handler: resolve("./runtime/server/routes/llms-full.txt.get"), lazy: true });
+    if (config.sitemapMd !== false) {
+      addServerHandler({ route: SITEMAP_MD_ROUTE, handler: resolve("./runtime/server/routes/sitemap.md.get"), lazy: true });
+    }
     if (agentSkillsResult._tag === "Enabled") {
       addServerHandler({ route: AGENT_SKILLS_INDEX_ROUTE, handler: resolve("./runtime/server/routes/agent-skills-index"), lazy: true });
       for (const route of Object.keys(agentSkillsResult.localArtifacts)) {
@@ -1689,7 +1750,9 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         addServerHandler({ route: "/__ai-ready/pages", handler: resolve("./runtime/server/routes/__ai-ready/pages.get"), lazy: true });
       }
     }
-    addServerHandler({ route: "/__ai-ready__/debug.json", handler: resolve("./runtime/server/routes/__ai-ready/devtools.get"), lazy: true });
+    if (nuxt.options.dev || config.debug) {
+      addServerHandler({ route: "/__ai-ready__/debug.json", handler: resolve("./runtime/server/routes/__ai-ready/devtools.get"), lazy: true });
+    }
     if (config.debug) {
       addServerHandler({ route: "/__ai-ready-debug", handler: resolve("./runtime/server/routes/__ai-ready-debug.get"), lazy: true });
     }
@@ -1698,6 +1761,7 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       addServerHandler({ route: "/__ai-ready/poll", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/poll.post"), lazy: true });
       addServerHandler({ route: "/__ai-ready/prune", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/prune.post"), lazy: true });
       addServerHandler({ route: "/__ai-ready/restore", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/restore.post"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/reindex", method: "post", handler: resolve("./runtime/server/routes/__ai-ready/reindex.post"), lazy: true });
       addServerPlugin(resolve("./runtime/server/plugins/sitemap-seeder"));
     }
     if (config.cron && !nuxt.options.dev) {
@@ -1735,19 +1799,59 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
     for (const route of ["/llms.txt", "/llms-full.txt"]) {
       extendRouteRules(route, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
     }
+    if (config.sitemapMd !== false) {
+      extendRouteRules(SITEMAP_MD_ROUTE, { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
+    }
+    const staticBaseURL = nuxt.options.app.baseURL || "/";
+    for (const route of nuxt.options.nitro.prerender?.routes || []) {
+      if (!isStaticMarkdownSourceRoute(route))
+        continue;
+      extendRouteRules(toMarkdownPath(route), {
+        headers: {
+          "Content-Type": "text/markdown; charset=utf-8",
+          "Link": buildStaticMarkdownLinkHeader(route, staticBaseURL, config.describedby !== false)
+        }
+      });
+    }
     nuxt.hooks.hook("nitro:build:before", (nitro) => {
+      nitro.hooks.hook("prerender:done", () => {
+        for (const { route, headers } of prerenderedMarkdownHeaderRules(
+          nitro._prerenderedRoutes || [],
+          staticBaseURL,
+          config.describedby !== false
+        )) {
+          nitro.options.routeRules[route] = defu({ headers }, nitro.options.routeRules[route]);
+        }
+      });
       nitro.hooks.hook("compiled", async () => {
         const headersPath = join(nitro.options.output.publicDir, "_headers");
         logger.debug(`Checking for _headers file: ${headersPath}`);
         const exists = await access(headersPath).then(() => true).catch(() => false);
         if (exists) {
           const headers = await readFile(headersPath, "utf8");
-          const mergedHeaders = ensureStaticHeader(
+          let mergedHeaders = ensureStaticHeader(
             headers,
             "/*.md",
             "Content-Type",
             "text/markdown; charset=utf-8"
           );
+          if (config.describedby !== false) {
+            mergedHeaders = ensureStaticHeader(
+              mergedHeaders,
+              "/*.md",
+              "Link",
+              staticDescribedbyEntry(nitro.options.baseURL || "/")
+            );
+          }
+          if (String(nitro.options.preset || "").startsWith("cloudflare")) {
+            const budget = enforceStaticHeaderBudget(mergedHeaders, CLOUDFLARE_STATIC_HEADER_RULE_LIMIT);
+            if (budget.dropped > 0) {
+              mergedHeaders = budget.contents;
+              logger.warn(`_headers had ${budget.total + budget.dropped} rules and Cloudflare allows ${CLOUDFLARE_STATIC_HEADER_RULE_LIMIT}. Dropped the ${budget.dropped} per-page .md rules; the /*.md glob still sets the charset and describedby entries, but static markdown no longer sends a per-page canonical Link.`);
+            }
+            if (budget.total > CLOUDFLARE_STATIC_HEADER_RULE_LIMIT)
+              logger.warn(`_headers still has ${budget.total} rules after dropping the .md rules. Cloudflare will reject the deploy until the other rules fit under ${CLOUDFLARE_STATIC_HEADER_RULE_LIMIT}.`);
+          }
           if (mergedHeaders !== headers) {
             await writeFile(headersPath, mergedHeaders);
             logger.debug("Merged .md charset header into _headers");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",
@@ -66,17 +66,17 @@
     }
   },
   "dependencies": {
-    "@mdream/js": "^1.7.0",
+    "@mdream/js": "^1.7.1",
     "@nuxt/kit": "^4.5.2",
     "citty": "^0.2.2",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
-    "drizzle-orm": "^1.0.0-rc.4",
-    "mdream": "^1.7.0",
+    "drizzle-orm": "1.0.0-rc.4",
+    "mdream": "^1.7.1",
     "nuxt-site-config": "^4.2.3",
     "nuxtseo-shared": "^5.3.14",
     "pathe": "^2.0.3",
-    "pkg-types": "^2.3.1",
+    "pkg-types": "^2.3.2",
     "site-config-stack": "^4.2.3",
     "sitemapd": "^0.2.2",
     "ufo": "^1.6.4",
@@ -84,10 +84,10 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^9.3.0",
+    "@antfu/eslint-config": "^9.5.1",
     "@arethetypeswrong/cli": "^0.18.5",
     "@harlan-zw/comark-content": "^0.1.5",
-    "@libsql/client": "^0.17.4",
+    "@libsql/client": "^0.18.0",
     "@nuxt/content": "^3.16.0",
     "@nuxt/module-builder": "^1.0.3",
     "@nuxt/test-utils": "^4.2.0",
@@ -96,31 +96,31 @@
     "@nuxtjs/robots": "^6.2.0",
     "@nuxtjs/sitemap": "^8.5.0",
     "@types/better-sqlite3": "^9.6.0",
-    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/coverage-v8": "^5.0.0",
     "@vue/test-utils": "^2.5.0",
     "@vueuse/nuxt": "^14.4.0",
     "better-sqlite3": "^13.0.3",
-    "bumpp": "^12.2.2",
-    "eslint": "^10.9.1",
-    "eslint-plugin-harlanzw": "^0.21.0",
+    "bumpp": "^12.3.0",
+    "eslint": "^10.10.0",
+    "eslint-plugin-harlanzw": "^0.21.1",
     "execa": "^10.0.1",
     "h3": "^1.15.11",
-    "happy-dom": "^20.12.0",
+    "happy-dom": "^20.14.0",
     "nitropack": "^2.13.4",
     "nuxt": "^4.5.2",
     "nuxt-site-config": "^4.2.3",
     "nuxtseo-layer-devtools": "^5.3.14",
-    "playwright": "^1.62.1",
-    "playwright-core": "^1.62.1",
+    "playwright": "^1.63.0",
+    "playwright-core": "^1.63.0",
     "postgres": "^3.4.9",
     "tinyglobby": "^0.2.17",
     "typescript": "6.0.3",
     "unbuild": "^3.6.1",
-    "vitest": "^4.1.11",
+    "vitest": "^5.0.0",
     "vue": "^3.5.42",
-    "vue-router": "^5.3.0",
+    "vue-router": "^5.3.1",
     "vue-tsc": "^3.3.11",
-    "wrangler": "^4.127.1",
+    "wrangler": "^4.129.0",
     "zod": "^4.5.4"
   },
   "scripts": {