nuxt-ai-ready 3.0.1 → 3.0.3

package/dist/chunks/agent-skills.mjs

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { realpath, readFile, readdir } from 'node:fs/promises';
 import { join, resolve, isAbsolute, relative, sep } from 'node:path';
 import { parseDocument } from 'yaml';
-import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.C34F0LJo.mjs';
+import { A as AGENT_SKILLS_SCHEMA } from '../shared/nuxt-ai-ready.CsGXtlrU.mjs';
 import 'node:module';
 import 'node:url';
 import '@nuxt/kit';

package/dist/chunks/prerender.mjs

@@ -6,7 +6,7 @@ import { resolveLocaleFromRoute } from 'nuxtseo-shared/i18n-runtime';
 import { createPrerenderFetch } from 'nuxtseo-shared/prerender';
 import { collectSitemap } from 'sitemapd/parse';
 import { withLeadingSlash, joinURL, withBase } from 'ufo';
-import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.C34F0LJo.mjs';
+import { l as logger, M as MARKDOWN_LINK_AVAILABILITY_FILE } from '../shared/nuxt-ai-ready.CsGXtlrU.mjs';
 import { normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-path.js';
 import { toDeployedRoute, toLogicalRoute } from '../../dist/runtime/route-path.js';
 import { initSchema, computeContentHash, insertPage, queryAllPages, exportDbDump } from '../../dist/runtime/server/db/shared.js';
@@ -299,7 +299,7 @@ async function prerenderRoute(nitro, route, fetch) {
   nitro._prerenderedRoutes.push(_route);
   return stat(filePath);
 }
-function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras = {}) {
+function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras) {
   const nuxt = useNuxt();
   nuxt.hooks.hook("nitro:init", async (nitro) => {
     const llmsFullTxtPath = join(nitro.options.output.publicDir, "llms-full.txt");
@@ -390,20 +390,22 @@ function setupPrerenderHandler(options, dbPath, siteInfo, llmsTxtConfig, extras
         logger.debug(`Writing pages.json: ${publicJsonPath} (${(jsonContent.length / 1024).toFixed(1)}kb)`);
         await writeFile(publicJsonPath, jsonContent, "utf-8");
         logger.debug(`Wrote ${pages.length} pages to __ai-ready/pages.json`);
-        const dumpData = await exportDbDump(state.db);
-        const dumpPath = join(publicDataDir, "pages.dump");
-        logger.debug(`Writing pages.dump: ${dumpPath} (${(dumpData.length / 1024).toFixed(1)}kb)`);
-        await writeFile(dumpPath, dumpData, "utf-8");
-        logger.debug(`Created database dump at __ai-ready/pages.dump (${(dumpData.length / 1024).toFixed(1)}kb compressed)`);
-        const buildId = Date.now().toString(36);
-        const metaContent = JSON.stringify({
-          buildId,
-          pageCount: pages.length,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        logger.debug(`Writing pages.meta.json (${(metaContent.length / 1024).toFixed(1)}kb)`);
-        await writeFile(join(publicDataDir, "pages.meta.json"), metaContent, "utf-8");
-        logger.debug(`Wrote build metadata: buildId=${buildId}`);
+        if (extras.runtimeDatabase === "Enabled") {
+          const dumpData = await exportDbDump(state.db);
+          const dumpPath = join(publicDataDir, "pages.dump");
+          logger.debug(`Writing pages.dump: ${dumpPath} (${(dumpData.length / 1024).toFixed(1)}kb)`);
+          await writeFile(dumpPath, dumpData, "utf-8");
+          logger.debug(`Created database dump at __ai-ready/pages.dump (${(dumpData.length / 1024).toFixed(1)}kb compressed)`);
+          const buildId = Date.now().toString(36);
+          const metaContent = JSON.stringify({
+            buildId,
+            pageCount: pages.length,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          logger.debug(`Writing pages.meta.json (${(metaContent.length / 1024).toFixed(1)}kb)`);
+          await writeFile(join(publicDataDir, "pages.meta.json"), metaContent, "utf-8");
+          logger.debug(`Wrote build metadata: buildId=${buildId}`);
+        }
       }
       if (state.dbPath && state.llmsTxtConfig?.markdownLinks) {
         const availabilityFile = join(dirname(state.dbPath), MARKDOWN_LINK_AVAILABILITY_FILE);

package/dist/module.d.mts

@@ -6,6 +6,22 @@ import { ResolvedWebMcpToolsConfig } from '../dist/runtime/site-tool-config.js';
 export { GetPageMarkdownToolOptions, ListPagesToolOptions, McpSiteToolAttachmentOptions, SearchPagesToolOptions, SiteToolOptions, SiteToolsConfig, WebMcpSiteToolAttachmentOptions } from '../dist/runtime/site-tool-config.js';
 import { AiCatalog } from '../dist/runtime/server/utils/discovery-response.js';
 
+type DatabaseType = 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon' | 'postgres';
+/**
+ * Database state after parsing. Every consumer reads `_tag` first, so a
+ * disabled database can never carry a driver, a path, or credentials.
+ */
+type ResolvedDatabase = {
+    _tag: 'Disabled';
+} | {
+    _tag: 'Enabled';
+    type: DatabaseType;
+    filename?: string;
+    bindingName?: string;
+    url?: string;
+    authToken?: string;
+};
+
 interface ParsedMarkdownResult {
     markdown: string;
     title: string;
@@ -31,22 +47,6 @@ interface ResolvedApiCatalogConfig {
     };
 }
 
-type DatabaseType = 'sqlite' | 'bun' | 'd1' | 'libsql' | 'neon' | 'postgres';
-/**
- * Database state after parsing. Every consumer reads `_tag` first, so a
- * disabled database can never carry a driver, a path, or credentials.
- */
-type ResolvedDatabase = {
-    _tag: 'Disabled';
-} | {
-    _tag: 'Enabled';
-    type: DatabaseType;
-    filename?: string;
-    bindingName?: string;
-    url?: string;
-    authToken?: string;
-};
-
 interface ResolvedWebMcpConfig {
     tools: ResolvedWebMcpToolsConfig;
     exposedTo?: string[];

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": "^4.6.0 || ^5.0.0-0"
   },
   "configKey": "aiReady",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -7,7 +7,7 @@ import '@nuxt/kit';
 import 'defu';
 import 'nuxt-site-config/kit';
 import 'nuxtseo-shared/kit';
-export { m as default } from './shared/nuxt-ai-ready.C34F0LJo.mjs';
+export { m as default } from './shared/nuxt-ai-ready.CsGXtlrU.mjs';
 import './shared/nuxt-ai-ready.B3hAuOLQ.mjs';
 import '../dist/runtime/markdown-path.js';
 import '../dist/runtime/route-path.js';

package/dist/runtime/server/plugins/link-header-nitro3.js

@@ -1,20 +1,21 @@
 import { defineNitroPlugin } from "#nuxtseo/nitro";
-import { ERROR_LINK_HEADER, STATUS_AWARE_LINK_HEADER } from "./link-header.js";
+import { STATUS_AWARE_LINK_HEADER } from "./link-header.js";
 function readHeader(event) {
   return event.context[STATUS_AWARE_LINK_HEADER];
 }
+function setLinkUnlessImmutable(response, value) {
+  try {
+    response.headers.set("link", value);
+  } catch (error) {
+    if (!(error instanceof TypeError))
+      throw error;
+  }
+}
 export default defineNitroPlugin((nitro) => {
   const hooks = nitro.hooks;
-  hooks.hook("error", (_error, { event }) => {
-    if (!event)
-      return;
-    const header = readHeader(event);
-    if (header)
-      event.req.headers.set(ERROR_LINK_HEADER, header.error);
-  });
   hooks.hook("response", (response, event) => {
     const header = readHeader(event);
     if (header)
-      response.headers.set("link", response.status >= 400 ? header.error : header.success);
+      setLinkUnlessImmutable(response, response.status >= 400 ? header.error : header.success);
   });
 });

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

@@ -18,6 +18,8 @@ export default defineNitroPlugin((nitro) => {
       event.node.req.headers[ERROR_LINK_HEADER] = header.error;
   });
   nitro.hooks.hook("beforeResponse", (event) => {
+    if (event.node.res.headersSent)
+      return;
     const header = event.context[STATUS_AWARE_LINK_HEADER];
     if (!header)
       return;

package/dist/shared/{nuxt-ai-ready.C34F0LJo.mjs → nuxt-ai-ready.CsGXtlrU.mjs}

@@ -3,7 +3,7 @@ import { readFile, mkdir, writeFile, access } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { dirname, basename, join, resolve, relative } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { hasNuxtModule, useNuxt, useLogger, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, getLayerDirectories, tryResolveModule, directoryToURL, addServerImports, addServerHandler, extendRouteRules, getNitroVersion, addNitroPlugin, addPlugin, addImports } from '@nuxt/kit';
+import { hasNuxtModule, useNuxt, useLogger, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, getLayerDirectories, tryResolveModule, directoryToURL, addServerImports, addServerHandler, extendRouteRules, getNitroVersion, addPlugin, addNitroPlugin, addImports } from '@nuxt/kit';
 import defu$1, { defu } from 'defu';
 import { useSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
 import { resolveNuxtContentVersion, renderNitroTypeAugmentations, setupRuntimeAliases, setupNitroRuntimeCompatibility } from 'nuxtseo-shared/kit';
@@ -756,14 +756,81 @@ const DATABASE_CONSUMER_LABELS = {
   mcp: "MCP site tools (`@nuxtjs/mcp-toolkit`)",
   webmcp: "WebMCP site tools (`aiReady.webmcp`)"
 };
-function formatMissingDrizzleMessage(input) {
+const RE_SEMVER = /^v?(\d+)\.(\d+)\.(\d+)(?:-([\da-z-]+(?:\.[\da-z-]+)*))?(?:\+[\da-z-]+(?:\.[\da-z-]+)*)?$/i;
+const RE_NUMERIC = /^\d+$/;
+function parseSemVer(input) {
+  const match = RE_SEMVER.exec(input.trim());
+  if (!match)
+    return void 0;
+  return {
+    core: [Number(match[1]), Number(match[2]), Number(match[3])],
+    prerelease: match[4]?.split(".") ?? []
+  };
+}
+function compareCore(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i])
+      return a[i] < b[i] ? -1 : 1;
+  }
+  return 0;
+}
+function comparePrerelease(a, b) {
+  if (a.length === 0 && b.length === 0)
+    return 0;
+  if (a.length === 0)
+    return 1;
+  if (b.length === 0)
+    return -1;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const left = a[i];
+    const right = b[i];
+    if (left === void 0)
+      return -1;
+    if (right === void 0)
+      return 1;
+    if (left === right)
+      continue;
+    const leftNumeric = RE_NUMERIC.test(left);
+    const rightNumeric = RE_NUMERIC.test(right);
+    if (leftNumeric && rightNumeric)
+      return Number(left) < Number(right) ? -1 : 1;
+    if (leftNumeric !== rightNumeric)
+      return leftNumeric ? -1 : 1;
+    return left < right ? -1 : 1;
+  }
+  return 0;
+}
+function matchCaretRange(version, range) {
+  const installed = parseSemVer(version);
+  const minimum = range.trim().startsWith("^") ? parseSemVer(range.trim().slice(1)) : void 0;
+  if (!installed || !minimum)
+    return { _tag: "Unparsed" };
+  const [major, minor, patch] = minimum.core;
+  const ceiling = major > 0 ? [major + 1, 0, 0] : minor > 0 ? [0, minor + 1, 0] : [0, 0, patch + 1];
+  const sameCore = compareCore(installed.core, minimum.core) === 0;
+  const satisfied = (compareCore(installed.core, minimum.core) > 0 || sameCore && comparePrerelease(installed.prerelease, minimum.prerelease) >= 0) && compareCore(installed.core, ceiling) < 0 && (installed.prerelease.length === 0 || sameCore && minimum.prerelease.length > 0);
+  return satisfied ? { _tag: "Satisfied" } : { _tag: "Unsatisfied" };
+}
+function checkDrizzleInstall(install, peerRange) {
+  if (install._tag === "Missing")
+    return { _tag: "Missing" };
+  if (!install.version || !peerRange)
+    return void 0;
+  return matchCaretRange(install.version, peerRange)._tag === "Unsatisfied" ? { _tag: "OutOfRange", version: install.version } : void 0;
+}
+function formatDrizzleMessage(input) {
   const consumers = Object.keys(DATABASE_CONSUMER_LABELS).filter((consumer) => input.requested[consumer]);
   const subject = consumers.length === 0 ? "The `aiReady.database` option turns on the database." : `These features need the database: ${consumers.map((consumer) => DATABASE_CONSUMER_LABELS[consumer]).join(", ")}.`;
   const version = input.peerRange?.replace(/^\^/, "");
-  const lines = [
+  const command = `npx nypm add drizzle-orm${version ? `@${version}` : ""}`;
+  const lines = input.problem._tag === "Missing" ? [
     subject,
     "The database needs `drizzle-orm`. This app does not install it.",
-    `Install it: npx nypm add drizzle-orm${version ? `@${version}` : ""}`
+    `Install it: ${command}`
+  ] : [
+    subject,
+    `The database needs \`drizzle-orm\` ${input.peerRange}. This app installs ${input.problem.version}.`,
+    `Upgrade it: ${command}`
   ];
   if (consumers.length > 0 && consumers.every((consumer) => consumer === "mcp" || consumer === "webmcp"))
     lines.push("If you do not need the site tools, set `aiReady.database: false`.");
@@ -1176,6 +1243,137 @@ function mergeStaticDiscoveryHeaders(contents, baseURL, entries) {
   }
   return entries.reduce((headers, entry) => ensureStaticHeader(headers, route, "Link", entry, "append"), contents);
 }
+function parseHeaderLine(line) {
+  const colon = line.indexOf(":");
+  if (!/^[\t ]/.test(line) || colon < 0)
+    return void 0;
+  const name = line.slice(0, colon).trim();
+  if (!name || name.startsWith("!") || /\s/.test(name))
+    return void 0;
+  const eol = line.endsWith("\r\n") ? "\r\n" : line.endsWith("\n") ? "\n" : "";
+  return {
+    name,
+    value: line.slice(colon + 1, line.length - eol.length).trim(),
+    withValue: (value) => `${line.slice(0, colon + 1)} ${value}${eol}`
+  };
+}
+const RE_DETACH_LINE = /^[\t ]+![\t ]*([^\s:]+)/;
+function patternToRegExp(pattern) {
+  const source = pattern.split(/(\*|:\w+)/).map((part) => part === "*" ? ".*" : part.startsWith(":") ? "[^/]+" : escapeRegExp(part)).join("");
+  return new RegExp(`^${source}$`);
+}
+function coversPattern(broad, narrow) {
+  if (broad === narrow || !broad.startsWith("/") || !narrow.startsWith("/"))
+    return false;
+  if (!/[*:]/.test(narrow))
+    return patternToRegExp(broad).test(narrow);
+  return broad.indexOf("*") === broad.length - 1 && !broad.includes(":") && narrow.startsWith(broad.slice(0, -1));
+}
+function splitLinkEntries(value) {
+  const entries = [];
+  let current = "";
+  let inUrl = false;
+  let inQuote = false;
+  for (const char of value) {
+    if (char === "<" && !inQuote)
+      inUrl = true;
+    else if (char === ">" && !inQuote)
+      inUrl = false;
+    else if (char === '"' && !inUrl)
+      inQuote = !inQuote;
+    if (char === "," && !inUrl && !inQuote) {
+      entries.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  entries.push(current.trim());
+  return entries.filter(Boolean);
+}
+function headerTokens(name, value) {
+  if (name === "link")
+    return splitLinkEntries(value);
+  if (name === "vary")
+    return value.split(",").map((token) => token.trim()).filter(Boolean);
+  return [value.trim()];
+}
+function tokenKey(name, token) {
+  return name === "vary" ? token.toLowerCase() : token;
+}
+function dedupeStaticHeaders(contents, names) {
+  const owned = new Set(names.map((name) => name.toLowerCase()));
+  const blocks = splitHeaderBlocks(contents);
+  const detached = /* @__PURE__ */ new Set();
+  const parsed = blocks.map((block) => {
+    const headers = [];
+    for (const line of block.text.split(/(?<=\n)/).slice(block.route === null ? 0 : 1)) {
+      const detach = line.match(RE_DETACH_LINE);
+      if (detach) {
+        detached.add(detach[1].toLowerCase());
+        continue;
+      }
+      const header = parseHeaderLine(line);
+      if (!header)
+        continue;
+      const name = header.name.toLowerCase();
+      if (owned.has(name))
+        headers.push({ name, tokens: headerTokens(name, header.value) });
+    }
+    return headers;
+  });
+  const lastRuleIndex = /* @__PURE__ */ new Map();
+  blocks.forEach((block, index) => {
+    if (block.route !== null)
+      lastRuleIndex.set(block.route, index);
+  });
+  let changed = false;
+  const output = blocks.map((block) => {
+    const route = block.route;
+    if (route === null)
+      return block.text;
+    const provided = /* @__PURE__ */ new Map();
+    lastRuleIndex.forEach((index, pattern) => {
+      if (!coversPattern(pattern, route))
+        return;
+      for (const { name, tokens } of parsed[index]) {
+        if (detached.has(name))
+          continue;
+        const values = provided.get(name) ?? /* @__PURE__ */ new Set();
+        tokens.forEach((token) => values.add(tokenKey(name, token)));
+        provided.set(name, values);
+      }
+    });
+    if (provided.size === 0)
+      return block.text;
+    const [routeLine, ...lines] = block.text.split(/(?<=\n)/);
+    let headerLines = 0;
+    const kept = lines.flatMap((line) => {
+      const header = parseHeaderLine(line);
+      if (!header) {
+        if (RE_DETACH_LINE.test(line))
+          headerLines++;
+        return [line];
+      }
+      headerLines++;
+      const name = header.name.toLowerCase();
+      const covered = provided.get(name);
+      if (!covered)
+        return [line];
+      const tokens = headerTokens(name, header.value);
+      const remaining = tokens.filter((token) => !covered.has(tokenKey(name, token)));
+      if (remaining.length === tokens.length)
+        return [line];
+      changed = true;
+      if (remaining.length > 0)
+        return [header.withValue(remaining.join(", "))];
+      headerLines--;
+      return [];
+    });
+    return headerLines === 0 ? kept.join("") : `${routeLine}${kept.join("")}`;
+  });
+  return changed ? output.join("") : contents;
+}
 const CLOUDFLARE_STATIC_HEADER_RULE_LIMIT = 100;
 const RE_EXACT_MARKDOWN_ROUTE = /^\/[^*\s]*\.md[\t ]*\r?$/;
 function splitHeaderBlocks(contents) {
@@ -1449,8 +1647,10 @@ ${details}`);
     const databaseEnabled = database._tag === "Enabled";
     if (databaseEnabled) {
       const drizzle = await tryResolveModule("drizzle-orm", directoryToURL(nuxt.options.rootDir));
-      if (!drizzle)
-        throw new Error(`[nuxt-ai-ready] ${formatMissingDrizzleMessage({ requested: databaseRequested, peerRange: peerDependencies["drizzle-orm"] })}`);
+      const peerRange = peerDependencies["drizzle-orm"];
+      const problem = checkDrizzleInstall(drizzle ? { _tag: "Installed", version: (await readPackageMetadata(drizzle)).version } : { _tag: "Missing" }, peerRange);
+      if (problem)
+        throw new Error(`[nuxt-ai-ready] ${formatDrizzleMessage({ problem, requested: databaseRequested, peerRange })}`);
     }
     if (!databaseEnabled)
       logger.debug("Database disabled. Page storage, runtime indexing and site tools are off.");
@@ -2018,11 +2218,17 @@ export function trackDrizzleWork(event, work) { return work }
       apiCatalog: apiCatalogConfig
     };
     if (prerenderEnabled) {
-      addNitroPlugin(resolve$1("./runtime/server/plugins/html-capture.prerender"));
       addServerHandler({
         middleware: true,
+        env: "prerender",
         handler: resolve$1("./runtime/server/middleware/markdown.prerender")
       });
+      const htmlCapturePlugin = resolve$1("./runtime/server/plugins/html-capture.prerender");
+      nuxt.hook("nitro:init", (nitro) => {
+        nitro.hooks.hook("prerender:config", (prerenderConfig) => {
+          prerenderConfig.plugins = [...prerenderConfig.plugins || [], htmlCapturePlugin];
+        });
+      });
       addPlugin({
         mode: "server",
         src: resolve$1("./runtime/app/plugins/md-hints.prerender")
@@ -2127,7 +2333,8 @@ export function trackDrizzleWork(event, work) { return work }
       }, mergedLlmsTxt, {
         ftsTokenizer,
         i18n: i18nConfig,
-        artifactRoutes: agentSkillsResult._tag === "Enabled" ? Object.keys(agentSkillsResult.localArtifacts) : []
+        artifactRoutes: agentSkillsResult._tag === "Enabled" ? Object.keys(agentSkillsResult.localArtifacts) : [],
+        runtimeDatabase: database._tag
       });
     }
     if (databaseEnabled) {
@@ -2183,6 +2390,13 @@ export function trackDrizzleWork(event, work) { return work }
         }
       });
     }
+    let sharedMarkdownRuleNoted = false;
+    const noteSharedMarkdownRule = (total, dropped) => {
+      if (sharedMarkdownRuleNoted)
+        return;
+      sharedMarkdownRuleNoted = true;
+      logger.info(`Cloudflare allows ${CLOUDFLARE_STATIC_HEADER_RULE_LIMIT} _headers rules. One rule per Markdown page would make ${total}. The ${dropped} Markdown pages share the /*.md rule, which sends no per-page canonical Link header.`);
+    };
     nuxt.hooks.hook("nitro:build:before", (nitro) => {
       const isCloudflarePreset = String(nitro.options.preset || "").startsWith("cloudflare");
       nitro.hooks.hook("prerender:done", async () => {
@@ -2214,7 +2428,7 @@ export function trackDrizzleWork(event, work) { return work }
         );
         if (plan._tag === "skip") {
           applyStaticMarkdownHeaderPlan(nitro.options.routeRules, plan);
-          logger.warn(`_headers would hold ${plan.total} rules and Cloudflare allows ${CLOUDFLARE_STATIC_HEADER_RULE_LIMIT}. Skipped the ${plan.dropped} per-page .md rules; the /*.md glob still sets the charset and describedby entries, but static markdown does not send a per-page canonical Link.`);
+          noteSharedMarkdownRule(plan.total, plan.dropped);
           return;
         }
         applyStaticMarkdownHeaderPlan(nitro.options.routeRules, plan);
@@ -2279,10 +2493,11 @@ export function trackDrizzleWork(event, work) { return work }
             if (staticDiscoverySupported && apiCatalogConfig && await hasArtifact(API_CATALOG_PATH))
               discovery.push(`<${encodeURI(apiCatalogConfig.href)}>; rel="api-catalog"`);
             mergedHeaders = mergeStaticDiscoveryHeaders(mergedHeaders, staticBaseURL, discovery);
+            mergedHeaders = dedupeStaticHeaders(mergedHeaders, ["Content-Type", "Link", "Vary"]);
             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.`);
+              noteSharedMarkdownRule(budget.total + budget.dropped, budget.dropped);
             }
             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}.`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-ai-ready",
   "type": "module",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "Best practice AI & LLM discoverability for Nuxt sites.",
   "author": {
     "name": "Harlan Wilton",

package/skills/nuxt-ai-ready/SKILL.md

@@ -99,7 +99,7 @@ Runtime indexing, database drivers, Cloudflare D1, and the server query helpers:
 - **Root `skills/` folders require explicit publication.** Automatic discovery scans public directories only. Set `agentSkills.dir: 'skills'` to publish root skills intentionally.
 - **The same hook name exists twice.** `ai-ready:page:markdown` is a Nuxt hook (`nuxt.config` `hooks`, prerender only) and a Nitro hook (`nitroApp.hooks`, every HTML conversion). They receive different context. The Nitro `ctx.event` is undefined when indexing runs outside a request.
 - **`database: false` conflicts with `runtimeSync` and `cron`.** The build fails and names the option.
-- **A database feature without `drizzle-orm` fails the build.** `runtimeSync`, `cron`, MCP site tools, WebMCP site tools, and an explicit `database` option turn on the database. The error names the feature and the install command. If MCP Toolkit serves only your own tools, set `database: false` instead.
+- **A database feature without `drizzle-orm` 1.x fails the build.** `runtimeSync`, `cron`, MCP site tools, WebMCP site tools, and an explicit `database` option turn on the database. A `drizzle-orm` 0.x install fails too. The error names the feature and the install command. If MCP Toolkit serves only your own tools, set `database: false` instead.
 
 ## Version limits