nuxt-ai-ready 2.5.3 → 3.0.0

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

@@ -1,20 +1,23 @@
 import { createHash, randomBytes } from 'node:crypto';
 import { readFile, mkdir, writeFile, access } from 'node:fs/promises';
 import { createRequire } from 'node:module';
-import { dirname, basename, join } from 'node:path';
-import { hasNuxtModule, useNuxt, useLogger, addTypeTemplate, addTemplate, defineNuxtModule, createResolver, addServerImports, addServerHandler, extendRouteRules, addServerPlugin, addPlugin, addImports } from '@nuxt/kit';
-import defu$1, { defu } from 'defu';
-import { installNuxtSiteConfig, useSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
-import { resolveNuxtContentVersion, renderNitroTypeAugmentations, setupNitroRuntimeCompatibility } from 'nuxtseo-shared/kit';
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
+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 defu$1, { defu } from 'defu';
+import { useSiteConfig, withSiteUrl } from 'nuxt-site-config/kit';
+import { resolveNuxtContentVersion, renderNitroTypeAugmentations, setupRuntimeAliases, setupNitroRuntimeCompatibility } from 'nuxtseo-shared/kit';
+import { r as readPackageMetadata, a as resolvePackageMetadataPath } from './nuxt-ai-ready.B3hAuOLQ.mjs';
 import { hasMarkdownTwin, normalizePagePath, toMarkdownPath } from '../../dist/runtime/markdown-path.js';
+import { toDeployedRoute } from '../../dist/runtime/route-path.js';
 import { SITEMAP_MD_ROUTE } from '../../dist/runtime/server/utils/sitemap-md.js';
-import { publicCacheControl } from '../../dist/runtime/cache-control.js';
+import { publicCacheControl, mergeVaryHeader } from '../../dist/runtime/cache-control.js';
 import { MCP_SERVER_CARD_MEDIA_TYPE, AI_CATALOG_MEDIA_TYPE } from '../../dist/runtime/server/utils/discovery-response.js';
+import { parseTOML, parseJSONC } from 'confbox';
+import { createNitroRouteRuleMatcher } from 'nuxtseo-shared/server';
+import { getContentNegotiationVary, resolveContentNegotiation } from '../../dist/runtime/server/utils/content-negotiation.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) {
@@ -24,12 +27,9 @@ export async function readPageDataFromFilesystem() { return { pages: [], errorRo
 export async function readMarkdownLinkAvailabilityFromFilesystem() { return { runtimeMarkdownAvailable: false, paths: [] } }
 `;
   }
-  const readRows = options.nativeNodeSqlite ? `const { DatabaseSync } = await import('node' + ':sqlite')
+  const readRows = `const { DatabaseSync } = await import('node' + ':sqlite')
   const db = new DatabaseSync(dbPath, { open: true })
   const rows = db.prepare(${JSON.stringify(SELECT_PAGE_DATA)}).all()
-  db.close()` : `const Database = (await import('better-sqlite3')).default
-  const db = new Database(dbPath, { readonly: true })
-  const rows = db.prepare(${JSON.stringify(SELECT_PAGE_DATA)}).all()
   db.close()`;
   return `
 export async function readMarkdownLinkAvailabilityFromFilesystem() {
@@ -85,7 +85,7 @@ const COMARK_MODULE = "@harlan-zw/comark-content";
 const COMARK_MINIMUM = [0, 1, 2];
 async function comarkSatisfiesMinimum() {
   const url = useNuxt().options.rootDir;
-  const pkg = await readPackageJSON(COMARK_MODULE, { url }).catch(() => {
+  const pkg = await readPackageMetadata(COMARK_MODULE, url).catch(() => {
     return null;
   });
   const parts = pkg?.version?.split(".").map((part) => Number.parseInt(part, 10));
@@ -249,15 +249,19 @@ declare module '#ai-ready-virtual/i18n-runtime.mjs' {
 }
 
 declare module '#ai-ready-virtual/db-provider.mjs' {
-  import type { H3Event } from '#nuxtseo/h3'
+  import type { AiReadyDatabaseEvent } from '#ai-ready/server/db/context'
   import type { DrizzleDatabase } from '#ai-ready/server/db/drizzle/client'
-  export function createClient(event?: H3Event): Promise<DrizzleDatabase>
+  export function createClient(event?: AiReadyDatabaseEvent): Promise<DrizzleDatabase>
 }
 
 declare module '#ai-ready-virtual/db-schema.mjs' {
   export * from '#ai-ready/server/db/schema/sqlite'
 }
 
+declare module '#ai-ready-virtual/database-runtime.mjs' {
+  export * from '#ai-ready/server/db/drizzle'
+}
+
 declare module '#ai-ready-virtual/content-lookup.mjs' {
   import type { H3Event } from '#nuxtseo/h3'
   export function lookupContentPage(event: H3Event, path: string): Promise<{
@@ -296,6 +300,7 @@ function resolveExternalSkillUrl(href, indexUrl) {
 }
 
 const AI_CATALOG_PATH = "/.well-known/ai-catalog.json";
+const ARD_PATH = "/.well-known/ard.json";
 function resolveAiCatalog(input) {
   const hostname = new URL(input.siteUrl).hostname;
   const serverName = input.serverCardName.split("/").at(-1);
@@ -303,6 +308,8 @@ function resolveAiCatalog(input) {
     specVersion: "1.0",
     entries: [{
       identifier: `urn:air:${hostname}:mcp:${serverName}`,
+      displayName: input.serverCardTitle || input.serverCardName,
+      ...input.serverCardDescription ? { description: input.serverCardDescription } : {},
       type: MCP_SERVER_CARD_MEDIA_TYPE,
       url: input.serverCardUrl
     }]
@@ -512,16 +519,256 @@ function formatApiCatalogConfigError(error) {
   }
 }
 
-function supportsNativeNodeSqlite(version) {
-  const [major = 0, minor = 0] = version.split(".").map(Number);
-  if (major === 22)
-    return minor >= 13;
-  if (major === 23)
-    return minor >= 4;
-  return major > 23;
+const PARSERS = {
+  "wrangler.json": JSON.parse,
+  "wrangler.jsonc": parseJSONC,
+  "wrangler.toml": parseTOML
+};
+function parseRouting(routing) {
+  if (routing === void 0 || typeof routing === "boolean")
+    return routing;
+  if (Array.isArray(routing) && routing.every((pattern) => typeof pattern === "string"))
+    return routing;
+  throw new Error("Cloudflare assets.run_worker_first must be a boolean or an array of path patterns.");
+}
+async function readCloudflareAssetRouting(rootDir) {
+  let directory = rootDir;
+  while (true) {
+    for (const [name, parse] of Object.entries(PARSERS)) {
+      const source = await readFile(join(directory, name), "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+          return void 0;
+        throw error;
+      });
+      if (source === void 0)
+        continue;
+      const config = parse(source);
+      return {
+        root: parseRouting(config.assets?.run_worker_first),
+        environments: Object.values(config.env || {}).flatMap((env) => {
+          const routing = parseRouting(env.assets?.run_worker_first);
+          return routing === void 0 ? [] : [routing];
+        })
+      };
+    }
+    const parent = dirname(directory);
+    if (parent === directory)
+      return { environments: [] };
+    directory = parent;
+  }
+}
+
+const RE_MD_EXT = /\.md$/;
+function isStaticMarkdownSourceRoute(route) {
+  if (route.includes("*") || route.includes(":"))
+    return false;
+  return hasMarkdownTwin(route.split("?")[0] || route);
+}
+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, artifactRoutes) {
+  const artifacts = new Set(artifactRoutes);
+  const rules = /* @__PURE__ */ new Map();
+  for (const entry of prerenderedRoutes) {
+    if (entry.route !== void 0 && artifacts.has(entry.route) || entry.fileName !== void 0 && artifacts.has(entry.fileName)) {
+      continue;
+    }
+    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",
+          "Vary": "Accept",
+          "Link": buildStaticMarkdownLinkHeader(pageRoute, baseURL, describedby)
+        }
+      });
+    }
+  }
+  return [...rules.values()];
+}
+const RE_EXACT_MARKDOWN_ROUTE$1 = /^\/[^*:\s]*\.md$/;
+function isStaticHeaderRouteRule([, rule]) {
+  return Boolean(rule && "headers" in rule && rule.headers);
+}
+function planStaticMarkdownHeaderRules(routeRules, rules, limit) {
+  if (limit === null)
+    return { _tag: "apply", rules };
+  const entries = Object.entries(routeRules).filter(isStaticHeaderRouteRule);
+  const registeredMarkdown = entries.map(([route]) => route).filter((route) => RE_EXACT_MARKDOWN_ROUTE$1.test(route));
+  const other = entries.length - registeredMarkdown.length;
+  const markdown = /* @__PURE__ */ new Set([...registeredMarkdown, ...rules.map((rule) => rule.route)]);
+  const total = other + markdown.size;
+  if (total <= limit)
+    return { _tag: "apply", rules };
+  return { _tag: "skip", drop: registeredMarkdown, total, dropped: markdown.size };
+}
+function applyStaticMarkdownHeaderPlan(routeRules, plan) {
+  if (plan._tag === "skip") {
+    for (const route of plan.drop) {
+      const rule = routeRules[route];
+      if (rule)
+        rule.headers = void 0;
+    }
+    return;
+  }
+  for (const { route, headers } of plan.rules) {
+    const existing = routeRules[route];
+    const merged = defu({ headers: { ...headers } }, existing);
+    const vary = Object.entries(existing?.headers || {}).filter(([name]) => name.toLowerCase() === "vary").map(([, value]) => value).join(", ");
+    if (headers.Vary) {
+      for (const name of Object.keys(merged.headers)) {
+        if (name.toLowerCase() === "vary")
+          delete merged.headers[name];
+      }
+      merged.headers.Vary = mergeVaryHeader(vary, headers.Vary);
+    }
+    routeRules[route] = merged;
+  }
+}
+
+const MAX_WORKER_FIRST_PATTERNS = 100;
+const RE_PATTERN_CHARACTERS = /[.+?^${}()|[\]\\]/g;
+function cloudflarePrerenderedPages(routes, baseURL) {
+  return [...new Set(routes.filter((entry) => !entry.error && entry.fileName?.endsWith(".html") && isStaticMarkdownSourceRoute(entry.route)).map((entry) => normalizePagePath(toDeployedRoute(normalizePagePath(entry.route), baseURL))))];
+}
+function matchesPattern(path, pattern) {
+  return new RegExp(`^${pattern.replace(RE_PATTERN_CHARACTERS, "\\$&").replaceAll("*", ".*")}$`).test(path);
+}
+function pagePaths(pages) {
+  return pages.flatMap((page) => page === "/" ? ["/"] : [page, `${page}/`]);
+}
+function cloudflareStaticFallbackPaths(existing, pages, environments = []) {
+  if (existing === true || existing === false || environments.includes(true))
+    return [];
+  const patterns = [...existing || [], ...environments.flatMap((routing) => Array.isArray(routing) ? routing : [])];
+  return pagePaths(pages).filter((path) => !patterns.some((pattern) => matchesPattern(path, pattern.startsWith("!") ? pattern.slice(1) : pattern)));
+}
+function cloudflareNegotiationPatterns(existing, pages) {
+  if (existing === true || existing === false || pages.length === 0)
+    return existing;
+  const patterns = [...existing || []];
+  for (const path of cloudflareStaticFallbackPaths(existing, pages)) {
+    if (!patterns.includes(path))
+      patterns.push(path);
+  }
+  if (patterns.length > MAX_WORKER_FIRST_PATTERNS) {
+    throw new Error("Cloudflare Markdown negotiation exceeds 100 worker-first patterns. Configure broader assets.run_worker_first patterns, or disable aiReady.contentNegotiation.");
+  }
+  return patterns;
+}
+
+const CACHE_GUIDE = "https://nuxtseo.com/docs/ai-ready/guides/markdown#cache-safety";
+function cacheFix(botNegotiation = false) {
+  const headers = getContentNegotiationVary(botNegotiation).split(",").map((header) => `'${header.trim().toLowerCase()}'`).join(", ");
+  return [
+    ...botNegotiation ? [
+      "For lower cache cost, set aiReady: { botNegotiation: false } and keep Accept-only negotiation.",
+      "To retain bot negotiation, include all three inputs in this route's cache key.",
+      "Raw User-Agent variation can create many cache entries."
+    ] : [],
+    `Add to this route rule: cache: { varies: [${headers}] }`,
+    "Keep existing cache options and varies entries.",
+    "HTTP Vary alone does not change Nitro's cache key.",
+    "If a CDN ignores Vary, set aiReady: { contentNegotiation: false } and use explicit .md URLs."
+  ].join("\n  ");
+}
+function resolveConfigurationWarnings(input) {
+  const warnings = [];
+  const hostname = input.siteUrl && URL.canParse(input.siteUrl) ? new URL(input.siteUrl).hostname : "";
+  if (!hostname || hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]") {
+    warnings.push('Set site.url to the public production URL. Discovery catalogs and canonical Markdown links need a public origin.\n  In nuxt.config.ts, set site: { url: "https://your-domain.com" }. Replace the example with your production origin.');
+  }
+  if (input.policy === "disabled") {
+    warnings.push(`contentNegotiation: false disables Accept and bot negotiation.
+  Remove aiReady.contentNegotiation from nuxt.config.ts to restore automatic negotiation.
+  If disabled intentionally, link explicit .md URLs and verify they resolve after deployment.
+  Guide: ${CACHE_GUIDE}`);
+  } else if (input.static) {
+    warnings.push(`Static output cannot run Markdown negotiation middleware.
+  Link the generated .md URLs, or use a server deployment for automatic negotiation.
+  For edge negotiation, preserve these inputs: ${getContentNegotiationVary(input.botNegotiation)}.
+  Guide: ${CACHE_GUIDE}`);
+  }
+  const match = createNitroRouteRuleMatcher({ nitro: { routeRules: input.routeRules } });
+  for (const route of Object.keys(input.routeRules).sort()) {
+    if (!hasMarkdownTwin(route) || route.startsWith("/.well-known/"))
+      continue;
+    const rule = match(route);
+    if (rule.redirect || rule.proxy)
+      continue;
+    if (input.static || input.policy === "disabled")
+      continue;
+    const automatic = resolveContentNegotiation({ policy: "auto", routeRule: rule, botNegotiation: input.botNegotiation });
+    const fixCache = cacheFix(input.botNegotiation);
+    if (automatic._tag === "enabled")
+      continue;
+    if (input.policy === "enabled") {
+      const fix = automatic.source === "isr" ? `ISR cannot use automatic negotiation. Set isr: false on this route, or use explicit .md URLs.${rule.cache ? `
+  ${fixCache}` : ""}` : fixCache;
+      warnings.push(`"${route}": contentNegotiation: true overrides cache protection.
+  Remove aiReady.contentNegotiation from nuxt.config.ts to restore automatic cache protection.
+  ${fix}
+  Guide: ${CACHE_GUIDE}`);
+    } else if (automatic.source === "isr") {
+      warnings.push(`"${route}": ISR disables automatic Markdown negotiation.
+  To keep ISR, use explicit .md URLs.
+  To use negotiation, set isr: false on this route in nuxt.config.ts.${rule.cache ? `
+  ${fixCache}` : ""}
+  Guide: ${CACHE_GUIDE}`);
+    } else {
+      warnings.push(`"${route}": response caching disables automatic Markdown negotiation.
+  In nuxt.config.ts:
+  ${fixCache}
+  Guide: ${CACHE_GUIDE}`);
+    }
+  }
+  return warnings;
 }
+
 const DATABASE_TYPE_NONE = "none";
 const DATABASE_DEPENDENT_OPTIONS = ["runtimeSync", "cron"];
+const DATABASE_CONSUMER_LABELS = {
+  runtimeSync: "runtime indexing (`aiReady.runtimeSync`)",
+  cron: "the indexing cron (`aiReady.cron`)",
+  mcp: "MCP site tools (`@nuxtjs/mcp-toolkit`)",
+  webmcp: "WebMCP site tools (`aiReady.webmcp`)"
+};
+function formatMissingDrizzleMessage(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 = [
+    subject,
+    "The database needs `drizzle-orm`. This app does not install it.",
+    `Install it: npx nypm add drizzle-orm${version ? `@${version}` : ""}`
+  ];
+  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`.");
+  return lines.join("\n");
+}
 const DEFAULT_SQLITE_FILENAME = ".data/ai-ready/pages.db";
 function formatConflictMessage(conflicts) {
   const names = conflicts.map((option) => `\`aiReady.${option}\``).join(", ");
@@ -797,7 +1044,10 @@ function parseSupportedMcpProtocolVersions(source) {
 async function resolveInstalledMcpProtocolVersions(input) {
   const resolutionBases = [.../* @__PURE__ */ new Set([...input.modulesDir, input.rootDir])];
   const sdkResolutionAttempts = resolutionBases.map(
-    (base) => resolvePackageJSON("@nuxtjs/mcp-toolkit", { from: base }).then((toolkitPackagePath) => createRequire(toolkitPackagePath).resolve("@modelcontextprotocol/sdk/types.js"))
+    (base) => Promise.resolve().then(() => {
+      const toolkitPackagePath = resolvePackageMetadataPath("@nuxtjs/mcp-toolkit", base, input.modulesDir.includes(base) ? { searchDirectory: base } : void 0);
+      return createRequire(toolkitPackagePath).resolve("@modelcontextprotocol/sdk/types.js");
+    })
   );
   return Promise.allSettled(sdkResolutionAttempts).then((results) => {
     const resolved = results.find((result) => result.status === "fulfilled");
@@ -852,7 +1102,7 @@ function createMcpServerCardEtag(card) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function ensureStaticHeader(contents, route, name, value) {
+function ensureStaticHeader(contents, route, name, value, mode = "default") {
   const eol = contents.includes("\r\n") ? "\r\n" : "\n";
   const routePattern = new RegExp(`^${escapeRegExp(route)}[\\t ]*\\r?$`, "gm");
   const routeMatches = [...contents.matchAll(routePattern)];
@@ -874,13 +1124,60 @@ function ensureStaticHeader(contents, route, name, value) {
     "im"
   );
   if (existingHeaderPattern.test(block)) {
+    if (mode === "append") {
+      const removalPattern = new RegExp(`^[\\t ]+![\\t ]*${escapedName}[\\t ]*\\r?$`, "im");
+      if (removalPattern.test(block))
+        return contents;
+      const valuePattern = new RegExp(`^([\\t ]+${escapedName}[\\t ]*:[\\t ]*)([^\\r\\n]*)(\\r?$)`, "im");
+      const match = block.match(valuePattern);
+      if (match) {
+        const merged = block.replace(valuePattern, (_line, prefix2, current, suffix) => {
+          const appended = name.toLowerCase() === "link" ? current.includes(value) ? current : [current, value].filter(Boolean).join(", ") : mergeVaryHeader(current, value);
+          return `${prefix2}${appended}${suffix}`;
+        });
+        return `${contents.slice(0, blockStart)}${merged}${contents.slice(blockEnd)}`;
+      }
+    }
     return contents;
   }
   const prefix = blockStart === routeLineEnd ? eol : "";
   return `${contents.slice(0, blockStart)}${prefix}  ${name}: ${value}${eol}${contents.slice(blockStart)}`;
 }
+function mergeStaticDiscoveryHeaders(contents, baseURL, entries) {
+  if (entries.length === 0)
+    return contents;
+  const route = toDeployedRoute("/*", baseURL);
+  const blocks = splitHeaderBlocks(contents);
+  const matching = blocks.filter((block) => block.route === route);
+  let merged = matching[0]?.text || "";
+  for (const block of matching.slice(1)) {
+    for (const line of block.text.split(/(?<=\n)/).slice(1)) {
+      const header = line.match(/^[\t ]+([^:\s]+):[\t ]*([^\r\n]*)/);
+      if (header?.[1]?.toLowerCase() === "link") {
+        merged = ensureStaticHeader(merged, route, header[1], header[2], "append");
+      } else if (header) {
+        const existing = new RegExp(`^[\\t ]+${escapeRegExp(header[1])}[\\t ]*:[^\\r\\n]*(?:\\r?\\n|$)`, "gim");
+        merged = ensureStaticHeader(merged.replace(existing, ""), route, header[1], header[2]);
+      } else {
+        merged += line;
+      }
+    }
+  }
+  if (matching.length > 1) {
+    let inserted = false;
+    contents = blocks.map((block) => {
+      if (block.route !== route)
+        return block.text;
+      if (inserted)
+        return "";
+      inserted = true;
+      return merged;
+    }).join("");
+  }
+  return entries.reduce((headers, entry) => ensureStaticHeader(headers, route, "Link", entry, "append"), contents);
+}
 const CLOUDFLARE_STATIC_HEADER_RULE_LIMIT = 100;
-const RE_EXACT_MARKDOWN_ROUTE$1 = /^\/[^*\s]*\.md[\t ]*\r?$/;
+const RE_EXACT_MARKDOWN_ROUTE = /^\/[^*\s]*\.md[\t ]*\r?$/;
 function splitHeaderBlocks(contents) {
   const blocks = [];
   let current = { route: null, text: "" };
@@ -900,7 +1197,7 @@ function enforceStaticHeaderBudget(contents, limit) {
   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$1.test(block.route));
+  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,
@@ -908,85 +1205,6 @@ function enforceStaticHeaderBudget(contents, limit) {
   };
 }
 
-const RE_MD_EXT = /\.md$/;
-function isStaticMarkdownSourceRoute(route) {
-  if (route.includes("*") || route.includes(":"))
-    return false;
-  return hasMarkdownTwin(route.split("?")[0] || route);
-}
-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, artifactRoutes) {
-  const artifacts = new Set(artifactRoutes);
-  const rules = /* @__PURE__ */ new Map();
-  for (const entry of prerenderedRoutes) {
-    if (entry.route !== void 0 && artifacts.has(entry.route) || entry.fileName !== void 0 && artifacts.has(entry.fileName)) {
-      continue;
-    }
-    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 RE_EXACT_MARKDOWN_ROUTE = /^\/[^*:\s]*\.md$/;
-function isStaticHeaderRouteRule([, rule]) {
-  return Boolean(rule && "headers" in rule && rule.headers);
-}
-function planStaticMarkdownHeaderRules(routeRules, rules, limit) {
-  if (limit === null)
-    return { _tag: "apply", rules };
-  const entries = Object.entries(routeRules).filter(isStaticHeaderRouteRule);
-  const registeredMarkdown = entries.map(([route]) => route).filter((route) => RE_EXACT_MARKDOWN_ROUTE.test(route));
-  const other = entries.length - registeredMarkdown.length;
-  const markdown = /* @__PURE__ */ new Set([...registeredMarkdown, ...rules.map((rule) => rule.route)]);
-  const total = other + markdown.size;
-  if (total <= limit)
-    return { _tag: "apply", rules };
-  return { _tag: "skip", drop: registeredMarkdown, total, dropped: markdown.size };
-}
-function applyStaticMarkdownHeaderPlan(routeRules, plan) {
-  if (plan._tag === "skip") {
-    for (const route of plan.drop) {
-      const rule = routeRules[route];
-      if (rule)
-        rule.headers = void 0;
-    }
-    return;
-  }
-  for (const { route, headers } of plan.rules)
-    routeRules[route] = defu({ headers }, routeRules[route]);
-}
-
 const DEFAULT_MAX_OUTPUT_CHARS = 1500;
 const DEFAULT_LIST_LIMIT = 20;
 const DEFAULT_SEARCH_LIMIT = 10;
@@ -1104,22 +1322,24 @@ const module$1 = defineNuxtModule({
   meta: {
     name: "nuxt-ai-ready",
     compatibility: {
-      nuxt: ">=4.0.0"
+      nuxt: "^4.6.0 || ^5.0.0-0"
     },
     configKey: "aiReady"
   },
   moduleDependencies: {
-    "@nuxtjs/robots": {
-      version: ">=6.0.0"
+    [fileURLToPath(import.meta.resolve("@nuxtjs/robots"))]: {
+      version: ">=7.0.0"
     },
-    "@nuxtjs/sitemap": {
-      version: ">=8.3.0"
+    [fileURLToPath(import.meta.resolve("@nuxtjs/sitemap"))]: {
+      version: ">=9.0.0"
     },
-    "nuxt-site-config": {
-      version: ">=3.2"
+    // Keep package-relative resolution until the minimum Nuxt version includes this fix:
+    // https://github.com/nuxt/nuxt/pull/36542
+    [fileURLToPath(import.meta.resolve("nuxt-site-config"))]: {
+      version: ">=5.0.0"
     },
-    "nuxtseo-shared": {
-      version: ">=5.3.11"
+    [fileURLToPath(import.meta.resolve("nuxtseo-shared"))]: {
+      version: ">=6.0.0"
     },
     "@nuxtjs/mcp-toolkit": {
       version: ">=0.18.0",
@@ -1148,13 +1368,14 @@ const module$1 = defineNuxtModule({
     const resolveFromModule = createRequire(moduleEntryUrl);
     const nuxtSeoSharedI18nRuntimePath = resolveFromModule.resolve("nuxtseo-shared/i18n-runtime");
     const nuxtSeoSharedUtilsPath = resolveFromModule.resolve("nuxtseo-shared/utils");
-    const { resolve } = createResolver(moduleEntryUrl);
-    const { version } = await readPackageJSON(resolve("../package.json"));
+    const { resolve: resolve$1 } = createResolver(moduleEntryUrl);
+    const { version, peerDependencies } = await readPackageMetadata(resolve$1("../package.json"));
     logger.level = config.debug || nuxt.options.debug ? 4 : 3;
     if (config.enabled === false) {
       logger.debug("Module is disabled, skipping setup.");
       return;
     }
+    setupRuntimeAliases({ namespace: "#ai-ready", app: resolve$1("./runtime/app"), server: resolve$1("./runtime/server") }, nuxt);
     const agentSkillsConfig = config.agentSkills === false ? false : config.agentSkills ?? {};
     const agentSkillsError = (issues) => {
       const details = issues.map((issue) => `${issue.index === void 0 ? "agentSkills" : `agentSkills.skills[${issue.index}]`}.${issue.field}: ${issue.message}`).join("\n");
@@ -1166,7 +1387,8 @@ ${details}`);
       const { applyRootAlias, prepareAgentSkills, resolveAgentSkillsConfig } = await import('../chunks/agent-skills.mjs');
       const prepared = await prepareAgentSkills(agentSkillsConfig, {
         rootDir: nuxt.options.rootDir,
-        scanDirs: nuxt.options._layers.map((layer) => layer.config.rootDir ?? layer.cwd)
+        scanDirs: getLayerDirectories(nuxt).map((layer) => layer.root),
+        publicDirs: getLayerDirectories(nuxt).map((layer) => layer.public)
       });
       if (prepared._tag === "Invalid")
         throw agentSkillsError(prepared.issues);
@@ -1178,7 +1400,7 @@ ${details}`);
       agentSkillsResult = await resolveAgentSkillsConfig(
         { ...agentSkillsConfig, skills: rooted.skills },
         nuxt.options.rootDir,
-        { sitemapMd: config.sitemapMd !== false }
+        { sitemapMd: config.sitemapMd !== false, publicDirs: getLayerDirectories(nuxt).map((layer) => layer.public) }
       );
       if (agentSkillsResult._tag === "Invalid")
         throw agentSkillsError(agentSkillsResult.issues);
@@ -1205,18 +1427,19 @@ ${details}`);
     });
     const mcpNeedsDatabase = mcpToolkitState._tag === "Enabled" && (config.mcp?.resources !== false || config.mcp?.tools !== false && Object.values(requestedSiteTools.config).some((tool) => tool.mcp.enabled));
     const webmcpNeedsDatabase = !!config.webmcp && (config.webmcp === true || config.webmcp.tools !== false) && Object.values(requestedSiteTools.config).some((tool) => tool.webmcp.enabled);
+    const databaseRequested = {
+      runtimeSync: !!config.runtimeSync,
+      cron: !!config.cron,
+      mcp: mcpNeedsDatabase,
+      webmcp: webmcpNeedsDatabase
+    };
     const databaseResolution = resolveDatabaseConfig({
       database: config.database,
       rootDir: nuxt.options.rootDir,
       preset: String(nuxt.options.nitro.preset || ""),
       // Vercel Postgres sets POSTGRES_URL.
       hasPostgresUrl: !!(process.env.POSTGRES_URL || process.env.DATABASE_URL || (config.database || void 0)?.url),
-      requested: {
-        runtimeSync: !!config.runtimeSync,
-        cron: !!config.cron,
-        mcp: mcpNeedsDatabase,
-        webmcp: webmcpNeedsDatabase
-      }
+      requested: databaseRequested
     });
     if (databaseResolution._tag === "Invalid")
       throw new Error(`[nuxt-ai-ready] ${databaseResolution.message}`);
@@ -1224,6 +1447,11 @@ ${details}`);
       logger[log.level](log.message);
     const database = databaseResolution.database;
     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"] })}`);
+    }
     if (!databaseEnabled)
       logger.debug("Database disabled. Page storage, runtime indexing and site tools are off.");
     const siteToolsResult = databaseEnabled ? requestedSiteTools : resolveSiteToolsConfig(config.tools, { database });
@@ -1231,7 +1459,6 @@ ${details}`);
       logger.warn(warning);
     const siteToolsConfig = siteToolsResult.config;
     const hasMcpSiteTools = Object.values(siteToolsConfig).some((tool) => tool.mcp.enabled);
-    await installNuxtSiteConfig();
     const nitroCompatibility = setupNitroRuntimeCompatibility(nuxt);
     const siteConfig = useSiteConfig();
     const apiCatalogResult = resolveApiCatalogConfig(config.apiCatalog, {
@@ -1260,6 +1487,10 @@ ${details}`);
       nuxt.options.mcp = configuredMcpOptions;
       nuxt.options.mcp.name = mcpServerCardName;
     }
+    if (nuxt.options.mcp !== false && config.mcp?.tools !== false && hasMcpSiteTools) {
+      nuxt.options.mcp = configuredMcpOptions;
+      nuxt.options.mcp.instructions ??= "Use this server when you need information from this site's indexed pages. Read the available tool descriptions before choosing a tool.";
+    }
     const i18nConfig = await detectI18n({ autoI18n: config.autoI18n });
     if (i18nConfig) {
       logger.info(`i18n detected: ${i18nConfig.locales.length} locales (default: ${i18nConfig.defaultLocale}, strategy: ${i18nConfig.strategy})`);
@@ -1289,7 +1520,7 @@ ${details}`);
       });
     }
     const ftsTokenizer = i18nConfig && hasCjkLocale(i18nConfig) ? "trigram" : "unicode61 remove_diacritics 2";
-    nuxt.options.alias["#ai-ready"] = resolve("./runtime");
+    nuxt.options.alias["#ai-ready"] = resolve$1("./runtime");
     addServerImports([
       "countPages",
       "indexPage",
@@ -1299,26 +1530,11 @@ ${details}`);
       "streamPages"
     ].map((name) => ({
       name,
-      from: resolve("./runtime")
+      from: resolve$1("./runtime")
     })));
-    let betterSqlite3Availability;
-    const hasBetterSqlite3 = () => {
-      betterSqlite3Availability ||= resolvePackageJSON("better-sqlite3", { from: nuxt.options.rootDir }).then(
-        () => true,
-        // Missing is expected when no requested feature uses SQLite.
-        () => false
-      );
-      return betterSqlite3Availability;
-    };
-    const nativeNodeSqlite = supportsNativeNodeSqlite(process.versions.node || "");
-    if (database._tag === "Enabled" && database.type === "sqlite" && !nativeNodeSqlite && !await hasBetterSqlite3()) {
-      throw new Error(
-        `[nuxt-ai-ready] SQLite needs "better-sqlite3" on Node ${process.versions.node}, but it isn't installed. Add it to your app: \`npm i better-sqlite3\` (or \`pnpm add\` / \`yarn add\`). Node 22.13 and later use built-in \`node:sqlite\`. For edge deployments, configure D1, Neon, LibSQL, or Bun instead.`
-      );
-    }
     let mcpAvailable = mcpToolkitState._tag === "Enabled";
     nuxt.hook("mcp:definitions:paths", (paths) => {
-      const mcpRuntimeDir = resolve("./runtime/server/mcp");
+      const mcpRuntimeDir = resolve$1("./runtime/server/mcp");
       const mcpConfig = config.mcp || {};
       if (mcpConfig.tools !== false && hasMcpSiteTools)
         (paths.tools ||= []).push(`${mcpRuntimeDir}/tools`);
@@ -1396,18 +1612,13 @@ ${details}`);
     const hasPrerenderedRoutes = !!(nuxt.options.nitro.prerender?.routes?.length || nuxt.options.nitro.prerender?.crawlLinks);
     const preparing = nuxt.options._prepare === true;
     const prerenderEnabled = !preparing && !!(isStatic || hasPrerenderedRoutes);
-    if (prerenderEnabled && !nativeNodeSqlite && !await hasBetterSqlite3()) {
-      throw new Error(
-        `[nuxt-ai-ready] Build time page indexing needs "better-sqlite3" on Node ${process.versions.node}. Add it to your app: \`npm i better-sqlite3\` (or \`pnpm add\` / \`yarn add\`). Node 22.13 and later need no extra package.`
-      );
-    }
     const isSPA = nuxt.options.ssr === false;
     let apiCatalogRegistered = false;
     const registerApiCatalog = (catalog) => {
       if (apiCatalogRegistered)
         return;
       apiCatalogRegistered = true;
-      addServerHandler({ route: API_CATALOG_PATH, handler: resolve("./runtime/server/routes/api-catalog"), lazy: true });
+      addServerHandler({ route: API_CATALOG_PATH, handler: resolve$1("./runtime/server/routes/api-catalog"), lazy: true });
       const apiCatalogLink = `<${catalog.href}>; rel="api-catalog"`;
       extendRouteRules("/**", {
         headers: { Link: apiCatalogLink }
@@ -1466,7 +1677,7 @@ ${details}`);
       const mcpLink = {
         title: "MCP",
         href: withSiteUrl(finalMcpToolkitState.route, { withBase: true }),
-        description: "Model Context Protocol server endpoint for AI agent integration."
+        description: config.mcp?.tools !== false && hasMcpSiteTools ? "Use this MCP endpoint when you need information from this site's indexed pages." : "Model Context Protocol server endpoint for AI agent integration."
       };
       const firstSection = mergedLlmsTxt.sections?.[0];
       if (firstSection) {
@@ -1550,7 +1761,7 @@ ${details}`);
         cacheMaxAge: mcpServerCardResult.config.cacheMaxAge,
         etag
       };
-      const handler = resolve("./runtime/server/routes/mcp-server-card");
+      const handler = resolve$1("./runtime/server/routes/mcp-server-card");
       addServerHandler({ route: mcpServerCardRoute, method: "get", handler, lazy: true });
       addServerHandler({ route: mcpServerCardRoute, method: "head", handler, lazy: true });
       addServerHandler({ route: mcpServerCardRoute, method: "options", handler, lazy: true });
@@ -1570,6 +1781,8 @@ ${details}`);
         const document = resolveAiCatalog({
           siteUrl: siteConfig.url,
           serverCardName: card.name,
+          serverCardTitle: card.title,
+          serverCardDescription: card.description,
           serverCardUrl: withSiteUrl(mcpServerCardRoute, { withBase: true })
         });
         const aiCatalogEtag = createAiCatalogEtag(document);
@@ -1579,22 +1792,24 @@ ${details}`);
           document,
           etag: aiCatalogEtag
         };
-        const aiCatalogHandler = resolve("./runtime/server/routes/ai-catalog");
-        addServerHandler({ route: AI_CATALOG_PATH, method: "get", handler: aiCatalogHandler, lazy: true });
-        addServerHandler({ route: AI_CATALOG_PATH, method: "head", handler: aiCatalogHandler, lazy: true });
-        addServerHandler({ route: AI_CATALOG_PATH, method: "options", handler: aiCatalogHandler, lazy: true });
-        extendRouteRules(AI_CATALOG_PATH, {
-          sitemap: false,
-          headers: {
-            "Access-Control-Allow-Headers": "Content-Type, If-None-Match",
-            "Access-Control-Allow-Methods": "GET, HEAD",
-            "Access-Control-Allow-Origin": "*",
-            "Access-Control-Expose-Headers": "ETag",
-            "Cache-Control": `public, max-age=${aiCatalogCacheMaxAge}`,
-            "Content-Type": AI_CATALOG_MEDIA_TYPE,
-            "ETag": aiCatalogEtag
-          }
-        });
+        const aiCatalogHandler = resolve$1("./runtime/server/routes/ai-catalog");
+        for (const route of [ARD_PATH, AI_CATALOG_PATH]) {
+          addServerHandler({ route, method: "get", handler: aiCatalogHandler, lazy: true });
+          addServerHandler({ route, method: "head", handler: aiCatalogHandler, lazy: true });
+          addServerHandler({ route, method: "options", handler: aiCatalogHandler, lazy: true });
+          extendRouteRules(route, {
+            sitemap: false,
+            headers: {
+              "Access-Control-Allow-Headers": "Content-Type, If-None-Match",
+              "Access-Control-Allow-Methods": "GET, HEAD",
+              "Access-Control-Allow-Origin": "*",
+              "Access-Control-Expose-Headers": "ETag",
+              "Cache-Control": `public, max-age=${aiCatalogCacheMaxAge}`,
+              "Content-Type": AI_CATALOG_MEDIA_TYPE,
+              "ETag": aiCatalogEtag
+            }
+          });
+        }
       }
     });
     const sitemapConfig = nuxt.options.sitemap;
@@ -1614,6 +1829,15 @@ ${details}`);
       await writeFile(join(cacheDir, "secret"), runtimeSyncSecret);
     }
     nuxt.hooks.hook("nitro:config", (nitroConfig) => {
+      if (getNitroVersion(nuxt) === 3) {
+        const nativeConfig = nitroConfig;
+        if (nativeConfig.noExternals !== true)
+          nativeConfig.noExternals = [...nativeConfig.noExternals || [], "nuxt-ai-ready"];
+      } else {
+        const externals = nitroConfig.externals ||= {};
+        externals.inline ||= [];
+        externals.inline.push(resolve$1("./runtime"));
+      }
       nitroConfig.experimental = nitroConfig.experimental || {};
       nitroConfig.experimental.asyncContext = true;
       const preset = String(nitroConfig.preset || "");
@@ -1622,20 +1846,11 @@ ${details}`);
         nitroConfig.experimental.wasm = true;
       if (nitroCompatibility._tag === "nitro-v3") {
         const nitro3Config = nitroConfig;
-        const noExternals = Array.isArray(nitro3Config.noExternals) ? nitro3Config.noExternals : [];
-        noExternals.push("sitemapd");
-        nitro3Config.noExternals = noExternals;
+        if (nitro3Config.noExternals !== true)
+          nitro3Config.noExternals = [...nitro3Config.noExternals || [], "sitemapd"];
         if (!isEdgePreset) {
           nitro3Config.traceDeps ||= [];
           nitro3Config.traceDeps.push("mdream*");
-          nitro3Config.rolldownConfig ||= {};
-          const external = nitro3Config.rolldownConfig.external;
-          if (Array.isArray(external))
-            external.push("mdream");
-          else if (typeof external === "string" || external instanceof RegExp)
-            nitro3Config.rolldownConfig.external = [external, "mdream"];
-          else if (!external)
-            nitro3Config.rolldownConfig.external = ["mdream"];
         }
       } else {
         const externals = nitroConfig.externals ||= {};
@@ -1666,7 +1881,7 @@ ${details}`);
           nitroConfig.experimental.tasks = true;
           nitroConfig.tasks = nitroConfig.tasks || {};
           nitroConfig.tasks["ai-ready:cron"] = {
-            handler: resolve("./runtime/server/tasks/ai-ready-cron")
+            handler: resolve$1("./runtime/server/tasks/ai-ready-cron")
           };
           nitroConfig.scheduledTasks = nitroConfig.scheduledTasks || {};
           nitroConfig.scheduledTasks[cronSchedule] = nitroConfig.scheduledTasks[cronSchedule] || [];
@@ -1701,7 +1916,6 @@ export const localAgentSkillArtifacts = ${JSON.stringify(agentSkillsResult.local
       nitroConfig.virtual["#ai-ready-virtual/read-page-data.mjs"] = createBuildPageDataVirtual({
         buildDbPath,
         markdownLinkAvailabilityPath,
-        nativeNodeSqlite,
         dev: nuxt.options.dev
       });
       nitroConfig.virtual["#ai-ready-virtual/page-data.mjs"] = `export const pages = []
@@ -1711,7 +1925,7 @@ import { createModuleLogger } from ${JSON.stringify(nuxtSeoSharedUtilsPath)}
 export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
 `;
       const providerMap = {
-        sqlite: nativeNodeSqlite ? "#ai-ready/server/db/drizzle/providers/node-sqlite" : "#ai-ready/server/db/drizzle/providers/sqlite",
+        sqlite: "#ai-ready/server/db/drizzle/providers/node-sqlite",
         bun: "#ai-ready/server/db/drizzle/providers/bun",
         d1: "#ai-ready/server/db/drizzle/providers/d1",
         libsql: "#ai-ready/server/db/drizzle/providers/libsql",
@@ -1721,8 +1935,52 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       nitroConfig.virtual["#ai-ready-virtual/db-provider.mjs"] = database._tag === "Enabled" ? `export { createClient } from '${providerMap[database.type] || providerMap.sqlite}'` : `export function createClient() {
   throw new Error('[nuxt-ai-ready] The database is disabled. Set \`aiReady.database\` to store pages at runtime.')
 }`;
+      const databaseRuntime = "#ai-ready-virtual/database-runtime.mjs";
+      if (database._tag === "Disabled") {
+        const databaseExports = [
+          "useDrizzle",
+          "useRawDb",
+          "completeCronRun",
+          "countPages",
+          "deleteInfoValue",
+          "getAllPages",
+          "getContentHashes",
+          "getInfoValue",
+          "getNextSitemapToCrawl",
+          "getPageByRoute",
+          "getPageLastmods",
+          "getPendingPages",
+          "getRecentCronRuns",
+          "getSitemapStatus",
+          "initSchema",
+          "markPageIndexed",
+          "markRoutesPending",
+          "markSitemapCrawled",
+          "markSitemapCrawlPartial",
+          "markSitemapError",
+          "markSitemapSeeded",
+          "resetSitemapErrors",
+          "searchPages",
+          "seedRoutes",
+          "setInfoValue",
+          "startCronRun",
+          "syncSitemaps",
+          "upsertPage"
+        ];
+        nitroConfig.virtual[databaseRuntime] = `
+async function unavailable() {
+  throw new Error('[nuxt-ai-ready] The database is disabled. Set \`aiReady.database\` to store pages at runtime.')
+}
+export { ${databaseExports.map((name) => `unavailable as ${name}`).join(", ")} }
+export async function closeDrizzle() {}
+export async function finishDrizzleResponse() {}
+export function trackDrizzleWork(event, work) { return work }
+`;
+      } else {
+        nitroConfig.virtual[databaseRuntime] = `export * from '#ai-ready/server/db/drizzle'`;
+      }
       const schemaPath = database._tag === "Enabled" && (database.type === "neon" || database.type === "postgres") ? "#ai-ready/server/db/schema/postgres" : "#ai-ready/server/db/schema/sqlite";
-      nitroConfig.virtual["#ai-ready-virtual/db-schema.mjs"] = `export * from '${schemaPath}'`;
+      nitroConfig.virtual["#ai-ready-virtual/db-schema.mjs"] = database._tag === "Enabled" ? `export * from '${schemaPath}'` : "export {}";
       nitroConfig.virtual["#ai-ready-virtual/devtools-meta.mjs"] = `export const devtoolsMeta = ${JSON.stringify({
         contentSignal: config.contentSignal || false,
         mcp: { enabled: mcpAvailable, tools: mcpAvailable && config.mcp?.tools !== false && hasMcpSiteTools, resources: mcpAvailable && config.mcp?.resources !== false },
@@ -1735,6 +1993,7 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       debug: config.debug || false,
       debugCron: config.debugCron || false,
       contentNegotiation: config.contentNegotiation === void 0 ? "auto" : config.contentNegotiation ? "enabled" : "disabled",
+      botNegotiation: config.botNegotiation === true,
       mdreamOptions: config.mdreamOptions || {},
       sitemapMd: config.sitemapMd !== false,
       describedby: config.describedby !== false,
@@ -1759,35 +2018,38 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       apiCatalog: apiCatalogConfig
     };
     if (prerenderEnabled) {
-      addServerPlugin(resolve("./runtime/server/plugins/html-capture.prerender"));
+      addNitroPlugin(resolve$1("./runtime/server/plugins/html-capture.prerender"));
       addServerHandler({
         middleware: true,
-        handler: resolve("./runtime/server/middleware/markdown.prerender")
+        handler: resolve$1("./runtime/server/middleware/markdown.prerender")
       });
       addPlugin({
         mode: "server",
-        src: resolve("./runtime/app/plugins/md-hints.prerender")
+        src: resolve$1("./runtime/app/plugins/md-hints.prerender")
       });
     }
     addServerHandler({
       middleware: true,
-      handler: resolve("./runtime/server/middleware/markdown")
+      handler: resolve$1("./runtime/server/middleware/markdown")
     });
-    addServerPlugin(resolve("./runtime/server/plugins/link-header"));
-    addServerPlugin(resolve("./runtime/server/plugins/markdown-negotiation"));
+    if (getNitroVersion(nuxt) === 3) {
+      extendRouteRules("/**.md", { cache: false });
+    }
+    addNitroPlugin(resolve$1(getNitroVersion(nuxt) === 3 ? "./runtime/server/plugins/link-header-nitro3" : "./runtime/server/plugins/link-header"));
+    addNitroPlugin(resolve$1("./runtime/server/plugins/markdown-negotiation"));
     addPlugin({
       mode: "server",
-      src: resolve("./runtime/app/plugins/md-alternate.server")
+      src: resolve$1("./runtime/app/plugins/md-alternate.server")
     });
-    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 });
+    addServerHandler({ route: "/llms.txt", handler: resolve$1("./runtime/server/routes/llms.txt.get"), lazy: true });
+    addServerHandler({ route: "/llms-full.txt", handler: resolve$1("./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 });
+      addServerHandler({ route: SITEMAP_MD_ROUTE, handler: resolve$1("./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 });
+      addServerHandler({ route: AGENT_SKILLS_INDEX_ROUTE, handler: resolve$1("./runtime/server/routes/agent-skills-index"), lazy: true });
       for (const route of Object.keys(agentSkillsResult.localArtifacts)) {
-        addServerHandler({ route, handler: resolve("./runtime/server/routes/agent-skills-artifact"), lazy: true });
+        addServerHandler({ route, handler: resolve$1("./runtime/server/routes/agent-skills-artifact"), lazy: true });
         extendRouteRules(route, {
           headers: {
             "Content-Type": "text/markdown; charset=utf-8",
@@ -1820,39 +2082,38 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
     if (webmcpConfig) {
       addImports(["useWebMcpSupported", "useWebMcpTool"].map((name) => ({
         name,
-        from: resolve("./runtime/app/composables/webmcp")
+        from: resolve$1("./runtime/app/composables/webmcp")
       })));
       nuxt.options.runtimeConfig.public["nuxt-ai-ready"] = {
         webmcp: webmcpConfig
       };
-      addPlugin({ mode: "client", src: resolve("./runtime/app/plugins/webmcp.client") });
+      addPlugin({ mode: "client", src: resolve$1("./runtime/app/plugins/webmcp.client") });
       if (Object.keys(webmcpConfig.tools).length) {
-        addServerHandler({ route: "/__ai-ready/pages", handler: resolve("./runtime/server/routes/__ai-ready/pages.get"), lazy: true });
+        addServerHandler({ route: "/__ai-ready/pages", handler: resolve$1("./runtime/server/routes/__ai-ready/pages.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 });
+      addServerHandler({ route: "/__ai-ready__/debug.json", handler: resolve$1("./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 });
+      addServerHandler({ route: "/__ai-ready-debug", handler: resolve$1("./runtime/server/routes/__ai-ready-debug.get"), lazy: true });
     }
     if (runtimeSyncEnabled) {
-      addServerHandler({ route: "/__ai-ready/status", handler: resolve("./runtime/server/routes/__ai-ready/status.get"), lazy: true });
-      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"));
+      addServerHandler({ route: "/__ai-ready/status", handler: resolve$1("./runtime/server/routes/__ai-ready/status.get"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/poll", method: "post", handler: resolve$1("./runtime/server/routes/__ai-ready/poll.post"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/prune", method: "post", handler: resolve$1("./runtime/server/routes/__ai-ready/prune.post"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/restore", method: "post", handler: resolve$1("./runtime/server/routes/__ai-ready/restore.post"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/reindex", method: "post", handler: resolve$1("./runtime/server/routes/__ai-ready/reindex.post"), lazy: true });
+      addNitroPlugin(resolve$1("./runtime/server/plugins/sitemap-seeder"));
     }
     if (config.cron && !nuxt.options.dev) {
-      addServerHandler({ route: "/__ai-ready/cron", handler: resolve("./runtime/server/routes/__ai-ready/cron.get"), lazy: true });
+      addServerHandler({ route: "/__ai-ready/cron", handler: resolve$1("./runtime/server/routes/__ai-ready/cron.get"), lazy: true });
     }
     if (apiCatalogConfig)
       registerApiCatalog(apiCatalogConfig);
     if (!nuxt.options.dev && !nuxt.options._prepare) {
       if (isSPA && !hasPrerenderedRoutes) {
         logger.warn("SPA mode detected without prerendering. llms-full.txt will not be generated.");
-        logger.warn("For full functionality, enable SSR or prerender routes.");
       } else if (!isStatic && !hasPrerenderedRoutes) {
         logger.info("SSR-only mode: llms-full.txt requires prerendering. Runtime markdown conversion available.");
       }
@@ -1869,8 +2130,9 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         artifactRoutes: agentSkillsResult._tag === "Enabled" ? Object.keys(agentSkillsResult.localArtifacts) : []
       });
     }
-    if (databaseEnabled)
-      addServerPlugin(resolve("./runtime/server/plugins/db-lifecycle"));
+    if (databaseEnabled) {
+      addNitroPlugin(resolve$1(getNitroVersion(nuxt) === 3 ? "./runtime/server/plugins/db-lifecycle-nitro3" : "./runtime/server/plugins/db-lifecycle"));
+    }
     if (nuxt.options.dev) {
       const { setupDevToolsUI } = await import('nuxtseo-shared/devtools');
       setupDevToolsUI({
@@ -1878,7 +2140,7 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         name: "nuxt-ai-ready",
         title: "AI Ready",
         icon: "carbon:ai-label"
-      }, resolve, nuxt);
+      }, resolve$1, nuxt);
     }
     for (const route of ["/llms.txt", "/llms-full.txt"]) {
       extendRouteRules(route, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
@@ -1887,19 +2149,59 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
       extendRouteRules(SITEMAP_MD_ROUTE, { headers: { "Content-Type": "text/markdown; charset=utf-8" } });
     }
     const staticBaseURL = nuxt.options.app.baseURL || "/";
+    const emittedWarnings = /* @__PURE__ */ new Set();
+    const warnConfiguration = (nitro) => {
+      if (preparing)
+        return;
+      const warnings = resolveConfigurationWarnings({
+        policy: nuxt.options.runtimeConfig["nuxt-ai-ready"].contentNegotiation,
+        botNegotiation: config.botNegotiation === true,
+        static: nitro.options.static === true || isStatic,
+        siteUrl: siteConfig.url || void 0,
+        routeRules: nitro.options.routeRules
+      });
+      for (const warning of warnings) {
+        if (!emittedWarnings.has(warning)) {
+          emittedWarnings.add(warning);
+          logger.warn(warning);
+        }
+      }
+    };
+    nuxt.hook("nitro:init", (nitro) => {
+      warnConfiguration(nitro);
+      nitro.hooks.hook("rollup:reload", () => warnConfiguration(nitro));
+    });
+    nuxt.hook("nitro:build:before", warnConfiguration);
     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)
+          "Link": buildStaticMarkdownLinkHeader(route, staticBaseURL, config.describedby !== false),
+          "Vary": "Accept"
         }
       });
     }
     nuxt.hooks.hook("nitro:build:before", (nitro) => {
       const isCloudflarePreset = String(nitro.options.preset || "").startsWith("cloudflare");
-      nitro.hooks.hook("prerender:done", () => {
+      nitro.hooks.hook("prerender:done", async () => {
+        if (["cloudflare", "cloudflare-module", "cloudflare-durable"].includes(String(nitro.options.preset)) && !nitro.options.static && config.contentNegotiation === true) {
+          const pages = cloudflarePrerenderedPages(nitro._prerenderedRoutes || [], staticBaseURL);
+          const cloudflare = nitro.options.cloudflare ||= {};
+          const wrangler = cloudflare.wrangler ||= {};
+          const assets = wrangler.assets ||= {};
+          const fileRouting = await readCloudflareAssetRouting(nitro.options.rootDir);
+          const routing = defu$1({ value: assets.run_worker_first }, { value: fileRouting.root }).value;
+          cloudflareNegotiationPatterns(routing, pages);
+          const environmentConfig = wrangler;
+          const configuredEnvironments = Object.values(environmentConfig.env || {}).flatMap((env) => env.assets?.run_worker_first === void 0 ? [] : [env.assets.run_worker_first]);
+          const fallbackPaths = cloudflareStaticFallbackPaths(routing, pages, [...fileRouting.environments, ...configuredEnvironments]);
+          const addedPaths = cloudflareStaticFallbackPaths(routing, pages);
+          if (addedPaths.length > 0)
+            assets.run_worker_first = [...Array.isArray(assets.run_worker_first) ? assets.run_worker_first : [], ...addedPaths];
+          nitro.options.runtimeConfig["nuxt-ai-ready"].cloudflarePrerenderedPages = fallbackPaths;
+        }
         const plan = planStaticMarkdownHeaderRules(
           nitro.options.routeRules,
           prerenderedMarkdownHeaderRules(
@@ -1918,26 +2220,65 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
         applyStaticMarkdownHeaderPlan(nitro.options.routeRules, plan);
       });
       nitro.hooks.hook("compiled", async () => {
-        const headersPath = join(nitro.options.output.publicDir, "_headers");
+        const generatedHeadersPath = join(nitro.options.output.publicDir, "_headers");
+        let headersPath = generatedHeadersPath;
+        let staticDiscoverySupported = isCloudflarePreset;
+        if (isCloudflarePreset) {
+          const wranglerPath = join(nitro.options.output.serverDir, "wrangler.json");
+          const wrangler = await readFile(wranglerPath, "utf8").then((contents) => JSON.parse(contents)).catch((error) => {
+            if (error.code === "ENOENT")
+              return void 0;
+            throw error;
+          });
+          const assetsDirectory = wrangler?.assets?.directory || wrangler?.pages_build_output_dir;
+          const assetsRoot = assetsDirectory ? resolve(dirname(wranglerPath), assetsDirectory) : String(nitro.options.preset).startsWith("cloudflare-pages") ? nitro.options.output.dir : resolve(nitro.options.output.publicDir, ...staticBaseURL.split("/").filter(Boolean).map(() => ".."));
+          const assetPath = relative(nitro.options.output.dir, assetsRoot);
+          if (assetPath === ".." || assetPath.startsWith("../")) {
+            staticDiscoverySupported = false;
+            logger.warn("Skipped shared discovery headers because Cloudflare assets are outside the Nitro output directory.");
+          } else {
+            headersPath = join(assetsRoot, "_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");
+        if (exists || isCloudflarePreset) {
+          const readHeaders = (path) => readFile(path, "utf8").catch((error) => {
+            if (error.code === "ENOENT")
+              return "";
+            throw error;
+          });
+          const rootHeaders = exists ? await readHeaders(headersPath) : "";
+          const generatedHeaders = generatedHeadersPath === headersPath ? "" : await readHeaders(generatedHeadersPath);
+          const headers = [rootHeaders, generatedHeaders].filter(Boolean).join("\n");
+          const markdownPattern = isCloudflarePreset ? toDeployedRoute("/*.md", staticBaseURL) : "/*.md";
           let mergedHeaders = ensureStaticHeader(
             headers,
-            "/*.md",
+            markdownPattern,
             "Content-Type",
             "text/markdown; charset=utf-8"
           );
+          mergedHeaders = ensureStaticHeader(mergedHeaders, markdownPattern, "Vary", "Accept", "append");
           if (config.describedby !== false) {
             mergedHeaders = ensureStaticHeader(
               mergedHeaders,
-              "/*.md",
+              markdownPattern,
               "Link",
               staticDescribedbyEntry(nitro.options.baseURL || "/")
             );
           }
           if (isCloudflarePreset) {
+            const hasArtifact = (route) => access(join(nitro.options.output.publicDir, route)).then(() => true).catch((error) => {
+              if (error.code === "ENOENT")
+                return false;
+              throw error;
+            });
+            const discovery = [];
+            if (staticDiscoverySupported && config.describedby !== false && await hasArtifact("/llms.txt"))
+              discovery.push(staticDescribedbyEntry(staticBaseURL));
+            if (staticDiscoverySupported && apiCatalogConfig && await hasArtifact(API_CATALOG_PATH))
+              discovery.push(`<${encodeURI(apiCatalogConfig.href)}>; rel="api-catalog"`);
+            mergedHeaders = mergeStaticDiscoveryHeaders(mergedHeaders, staticBaseURL, discovery);
             const budget = enforceStaticHeaderBudget(mergedHeaders, CLOUDFLARE_STATIC_HEADER_RULE_LIMIT);
             if (budget.dropped > 0) {
               mergedHeaders = budget.contents;
@@ -1946,7 +2287,7 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
             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) {
+          if (mergedHeaders !== rootHeaders || !exists) {
             await writeFile(headersPath, mergedHeaders);
             logger.debug("Merged .md charset header into _headers");
           }
@@ -1956,4 +2297,4 @@ export const logger = createModuleLogger('nuxt-ai-ready', ${!!config.debug})
   }
 });
 
-export { AGENT_SKILLS_SCHEMA as A, MARKDOWN_LINK_AVAILABILITY_FILE as M, logger as l, module$1 as m, supportsNativeNodeSqlite as s };
+export { AGENT_SKILLS_SCHEMA as A, MARKDOWN_LINK_AVAILABILITY_FILE as M, logger as l, module$1 as m };