nuxt-ai-ready 2.5.2 → 3.0.0

package/dist/runtime/server/utils/content-negotiation.js

@@ -1,6 +1,7 @@
-export const CONTENT_NEGOTIATION_VARY = "Accept, Sec-Fetch-Dest, User-Agent";
-const NEGOTIATION_CACHE_HEADERS = CONTENT_NEGOTIATION_VARY.split(",").map((header) => header.trim().toLowerCase());
-function cachesWithoutNegotiationVariation(cache) {
+export function getContentNegotiationVary(botNegotiation = false) {
+  return botNegotiation ? "Accept, Sec-Fetch-Dest, User-Agent" : "Accept";
+}
+function cachesWithoutNegotiationVariation(cache, botNegotiation) {
   if (!cache)
     return false;
   if (typeof cache !== "object")
@@ -8,16 +9,16 @@ function cachesWithoutNegotiationVariation(cache) {
   if (cache.headersOnly)
     return false;
   const varies = new Set(cache.varies?.map((header) => header.toLowerCase()));
-  return NEGOTIATION_CACHE_HEADERS.some((header) => !varies.has(header));
+  return getContentNegotiationVary(botNegotiation).split(",").some((header) => !varies.has(header.trim().toLowerCase()));
 }
 export function resolveContentNegotiation(input) {
   if (input.policy === "enabled")
-    return { _tag: "enabled", source: "explicit" };
+    return { _tag: "enabled", source: "explicit", vary: getContentNegotiationVary(input.botNegotiation) };
   if (input.policy === "disabled")
     return { _tag: "disabled", source: "explicit" };
   if (input.routeRule.isr)
     return { _tag: "disabled", source: "isr" };
-  if (cachesWithoutNegotiationVariation(input.routeRule.cache))
+  if (cachesWithoutNegotiationVariation(input.routeRule.cache, input.botNegotiation === true))
     return { _tag: "disabled", source: "route-cache" };
-  return { _tag: "enabled", source: "default" };
+  return { _tag: "enabled", source: "default", vary: getContentNegotiationVary(input.botNegotiation) };
 }

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

@@ -1,4 +1,4 @@
-import type { H3Event } from '#nuxtseo/h3';
+import type { AiReadyDatabaseEvent } from '../db/context.js';
 export interface UniversalContext {
     /** Site URL from nuxt-site-config */
     siteUrl: string | undefined;
@@ -10,8 +10,8 @@ export interface UniversalContext {
  * In request context: uses H3Event and nuxt-site-config middleware
  * In scheduled task: rebuilds from build-time site-config stack
  */
-export declare function createUniversalContext(event: H3Event | undefined): UniversalContext;
+export declare function createUniversalContext(event: AiReadyDatabaseEvent | undefined): UniversalContext;
 /**
  * Get site URL from context, throwing if not configured
  */
-export declare function requireSiteUrl(event: H3Event | undefined): string;
+export declare function requireSiteUrl(event: AiReadyDatabaseEvent | undefined): string;

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

@@ -1,7 +1,7 @@
 import { createSiteConfigStack } from "site-config-stack";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 export function createUniversalContext(event) {
-  const runtimeConfig = useRuntimeConfig(event);
+  const runtimeConfig = useRuntimeConfig();
   let siteUrl = runtimeConfig.site?.url || runtimeConfig.public?.site?.url;
   if (!siteUrl) {
     const siteConfigRuntime = runtimeConfig["nuxt-site-config"];

package/dist/runtime/server/utils/discovery-response.d.ts

@@ -4,6 +4,8 @@ export interface AiCatalog {
     specVersion: '1.0';
     entries: Array<{
         identifier: string;
+        displayName: string;
+        description?: string;
         type: typeof MCP_SERVER_CARD_MEDIA_TYPE;
         url: string;
     }>;

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

@@ -16,8 +16,10 @@ interface LinkHeaderConfig {
     describedby?: boolean;
     i18n?: RuntimeI18nConfig | null;
 }
-/**
- * Build a comma-joined Link header value with the standard alternates plus i18n hreflang variants.
- */
 export declare function buildLinkHeader(path: string, variant: 'html' | 'markdown', config: LinkHeaderConfig, resolveUrl?: LinkUrlResolver, routeContext?: RuntimeRouteContext): string;
+/** Resolve request-specific URLs once for both success and error responses. */
+export declare function buildStatusAwareLinkHeaders(path: string, variant: 'html' | 'markdown', config: LinkHeaderConfig, resolveUrl?: LinkUrlResolver, routeContext?: RuntimeRouteContext): {
+    error: string;
+    success: string;
+};
 export {};

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

@@ -14,7 +14,7 @@ function resolveHeaderUrl(path, resolveUrl) {
     return path;
   }
 }
-export function buildLinkHeader(path, variant, config, resolveUrl, routeContext = {}) {
+function buildBaseParts(path, variant, config, resolveUrl) {
   const parts = [];
   if (variant === "html") {
     const href = resolveHeaderUrl(toMarkdownPath(path), resolveUrl);
@@ -28,6 +28,9 @@ export function buildLinkHeader(path, variant, config, resolveUrl, routeContext
     const href = resolveHeaderUrl(LLMS_TXT_PATH, resolveUrl);
     parts.push(`<${encodePathForHeader(href)}>; rel="describedby"`);
   }
+  return parts;
+}
+function appendLocaleParts(parts, path, variant, config, resolveUrl, routeContext) {
   if (config.i18n) {
     const alternates = computeLocaleAlternates(path, config.i18n, routeContext);
     for (const alt of alternates) {
@@ -39,8 +42,29 @@ export function buildLinkHeader(path, variant, config, resolveUrl, routeContext
       parts.push(`<${encodePathForHeader(href)}>; rel="alternate"; hreflang="${alt.hreflang}"`);
     }
   }
+}
+function appendCatalogPart(parts, config) {
   if (config.apiCatalog) {
-    parts.push(`<${encodePathForHeader(config.apiCatalog.href)}>; rel="api-catalog"`);
+    const catalog = `<${encodePathForHeader(config.apiCatalog.href)}>; rel="api-catalog"`;
+    parts.push(catalog);
+    return catalog;
   }
+}
+export function buildLinkHeader(path, variant, config, resolveUrl, routeContext = {}) {
+  const parts = buildBaseParts(path, variant, config, resolveUrl);
+  appendLocaleParts(parts, path, variant, config, resolveUrl, routeContext);
+  appendCatalogPart(parts, config);
   return parts.join(", ");
 }
+export function buildStatusAwareLinkHeaders(path, variant, config, resolveUrl, routeContext = {}) {
+  const parts = buildBaseParts(path, variant, config, resolveUrl);
+  const safeParts = parts.slice();
+  const catalog = appendCatalogPart(safeParts, config);
+  const error = safeParts.join(", ");
+  if (!config.i18n)
+    return { error, success: error };
+  appendLocaleParts(parts, path, variant, config, resolveUrl, routeContext);
+  if (catalog)
+    parts.push(catalog);
+  return { error, success: parts.join(", ") };
+}

package/dist/runtime/server/utils/markdown-request.d.ts

@@ -13,11 +13,12 @@ export interface MarkdownRequest {
     isPrerender: boolean;
 }
 export declare function toMarkdownRequest(event: H3Event, isPrerender?: boolean): MarkdownRequest;
-export declare function negotiateRequestRepresentation(request: MarkdownRequest): ContentNegotiationResult;
-export declare function negotiateRepresentation(event: H3Event): ContentNegotiationResult;
+export declare function negotiateRequestRepresentation(request: MarkdownRequest, botNegotiation?: boolean): ContentNegotiationResult;
+export declare function negotiateRepresentation(event: H3Event, botNegotiation?: boolean): ContentNegotiationResult;
 export type MarkdownRequestMode = {
     _tag: 'runtime';
     contentNegotiation: boolean;
+    botNegotiation?: boolean;
 } | {
     _tag: 'prerender';
 };
@@ -30,4 +31,4 @@ export type MarkdownRenderInfo = {
 } | null;
 export declare function getRequestRenderInfo(request: MarkdownRequest, mode?: MarkdownRequestMode): MarkdownRenderInfo;
 export declare function getMarkdownRenderInfo(event: H3Event, mode?: MarkdownRequestMode): MarkdownRenderInfo;
-export declare function clientPrefersMarkdown(event: H3Event): boolean;
+export declare function clientPrefersMarkdown(event: H3Event, botNegotiation?: boolean): boolean;

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

@@ -1,4 +1,4 @@
-import { negotiateContent } from "@mdream/js/negotiate";
+import { negotiateContent, parseAcceptHeader } from "@mdream/js/negotiate";
 import { getBotInfo } from "@nuxtjs/robots/util";
 import { getHeaders } from "#nuxtseo/h3";
 import { isReservedPath } from "../../markdown-path.js";
@@ -6,22 +6,24 @@ const RE_MD_EXT = /\.md$/;
 export function toMarkdownRequest(event, isPrerender = !!import.meta.prerender) {
   return { path: event.path, headers: getHeaders(event), isPrerender };
 }
-export function negotiateRequestRepresentation(request) {
+export function negotiateRequestRepresentation(request, botNegotiation = false) {
   if (request.isPrerender || request.headers["x-nitro-prerender"])
     return "html";
   const accept = request.headers.accept;
-  const secFetchDest = request.headers["sec-fetch-dest"];
-  if (negotiateContent(accept) === "markdown")
-    return "markdown";
-  if (secFetchDest === "document")
-    return "html";
+  const preference = negotiateContent(accept);
+  if (!botNegotiation || preference !== "html" || request.headers["sec-fetch-dest"] === "document")
+    return preference;
+  const entries = parseAcceptHeader(accept?.toLowerCase() || "");
+  const matching = ["text/markdown", "text/*", "*/*"].map((type) => entries.filter((entry) => entry.type === type)).find((group) => group.length > 0);
+  if (matching && matching.every((entry) => entry.q === 0))
+    return preference;
   const botInfo = getBotInfo(request.headers);
   if (botInfo?.category === "ai")
     return "markdown";
-  return negotiateContent(accept, secFetchDest);
+  return preference;
 }
-export function negotiateRepresentation(event) {
-  return negotiateRequestRepresentation(toMarkdownRequest(event));
+export function negotiateRepresentation(event, botNegotiation = false) {
+  return negotiateRequestRepresentation(toMarkdownRequest(event), botNegotiation);
 }
 export function getRequestRenderInfo(request, mode = { _tag: "runtime", contentNegotiation: true }) {
   const queryIndex = request.path.indexOf("?");
@@ -41,7 +43,7 @@ export function getRequestRenderInfo(request, mode = { _tag: "runtime", contentN
   const extension = hasExtension ? lastSegment.substring(lastSegment.lastIndexOf(".")) : "";
   if (hasExtension && extension !== ".md")
     return null;
-  const negotiation = isPrerender ? "markdown" : mode.contentNegotiation ? negotiateRequestRepresentation(request) : "html";
+  const negotiation = isPrerender ? "markdown" : mode.contentNegotiation ? negotiateRequestRepresentation(request, mode.botNegotiation) : "html";
   if (isExplicit) {
     const path = normalizePath(originalPath.slice(0, -3));
     return { path, isExplicit: true, negotiation: "markdown" };
@@ -58,6 +60,6 @@ function normalizePath(path) {
     return path.slice(0, -5) || "/";
   return path;
 }
-export function clientPrefersMarkdown(event) {
-  return negotiateRepresentation(event) === "markdown";
+export function clientPrefersMarkdown(event, botNegotiation = false) {
+  return negotiateRepresentation(event, botNegotiation) === "markdown";
 }

package/dist/runtime/server/utils/negotiation-decision.d.ts

@@ -1,6 +1,7 @@
 import type { ContentNegotiationPolicy } from '../../types.js';
 import type { ContentNegotiationResolution, NegotiationRouteRule } from './content-negotiation.js';
 import type { MarkdownRequest } from './markdown-request.js';
+import { getContentNegotiationVary } from './content-negotiation.js';
 /** Marks an internal HTML fetch that must bypass content negotiation. */
 export declare const INTERNAL_HEADER = "x-ai-ready-internal";
 /**
@@ -13,6 +14,7 @@ export interface NegotiationInput {
     request: MarkdownRequest;
     routeRule: NegotiationRouteRule;
     policy: ContentNegotiationPolicy;
+    botNegotiation?: boolean;
     /**
      * Routes that already serve a Markdown file verbatim, such as an agent skill
      * alias. They are answered by their own handler, never rendered.
@@ -24,6 +26,7 @@ export type NegotiationDecision = {
     reason: 'well-known' | 'internal' | 'artifact' | 'not-a-page' | 'deferred';
 } | {
     _tag: 'not-acceptable';
+    vary: ReturnType<typeof getContentNegotiationVary>;
 } | {
     _tag: 'html';
     path: string;
@@ -31,6 +34,7 @@ export type NegotiationDecision = {
 } | {
     _tag: 'redirect';
     path: string;
+    vary: ReturnType<typeof getContentNegotiationVary>;
 } | {
     _tag: 'render';
     path: string;

package/dist/runtime/server/utils/negotiation-decision.js

@@ -1,4 +1,4 @@
-import { resolveContentNegotiation } from "./content-negotiation.js";
+import { getContentNegotiationVary, resolveContentNegotiation } from "./content-negotiation.js";
 import { getRequestRenderInfo } from "./markdown-request.js";
 export const INTERNAL_HEADER = "x-ai-ready-internal";
 export function resolveNegotiationDecision(input) {
@@ -10,20 +10,21 @@ export function resolveNegotiationDecision(input) {
     return { _tag: "skip", reason: "artifact" };
   if (request.headers[INTERNAL_HEADER])
     return { _tag: "skip", reason: "internal" };
-  const negotiation = resolveContentNegotiation({ policy: input.policy, routeRule: input.routeRule });
+  const negotiation = resolveContentNegotiation({ policy: input.policy, routeRule: input.routeRule, botNegotiation: input.botNegotiation });
   const renderInfo = getRequestRenderInfo(request, {
     _tag: "runtime",
-    contentNegotiation: negotiation._tag === "enabled"
+    contentNegotiation: negotiation._tag === "enabled",
+    botNegotiation: input.botNegotiation
   });
   if (!renderInfo)
     return { _tag: "skip", reason: "not-a-page" };
   if ("notAcceptable" in renderInfo)
-    return { _tag: "not-acceptable" };
+    return { _tag: "not-acceptable", vary: getContentNegotiationVary(input.botNegotiation) };
   if (renderInfo.isExplicit) {
     return stage === "early" ? { _tag: "skip", reason: "deferred" } : { _tag: "render", path: renderInfo.path };
   }
   if (renderInfo.negotiation === "markdown")
-    return { _tag: "redirect", path: renderInfo.path };
+    return { _tag: "redirect", path: renderInfo.path, vary: getContentNegotiationVary(input.botNegotiation) };
   return { _tag: "html", path: renderInfo.path, negotiation };
 }
 function withoutQuery(path) {

package/dist/runtime/server/utils/negotiation-response.d.ts

@@ -17,7 +17,7 @@ type NegotiationResponse = Awaited<ReturnType<typeof sendRedirect>> | undefined;
 export declare function setLinkHeader(event: H3Event, ctx: NegotiationContext, variant: 'html' | 'markdown'): void;
 export declare function setStatusAwareHeader(event: H3Event, ctx: NegotiationContext, variant: 'html' | 'markdown'): void;
 export declare function setUncacheableHeaders(event: H3Event): void;
-export declare function setMarkdownHeaders(event: H3Event, ctx: NegotiationContext): void;
+export declare function setMarkdownHeaders(event: H3Event, ctx: NegotiationContext, sourceHeaders?: Headers): void;
 /**
  * Site config is set up by a Nitro middleware. The early negotiation handler
  * runs in front of that middleware, so it must run the setup itself before it

package/dist/runtime/server/utils/negotiation-response.js

@@ -1,14 +1,14 @@
 import { createNitroRouteRuleMatcher } from "nuxtseo-shared/server";
 import { localAgentSkillArtifacts } from "#ai-ready-virtual/agent-skills.mjs";
-import { appendHeader, createError, getRequestHost, getResponseHeader, sendRedirect, setHeader } from "#nuxtseo/h3";
+import { appendHeader, createError, getHeader, getRequestHost, getRequestURL, getResponseHeader, sendRedirect, setHeader } from "#nuxtseo/h3";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
-import { withSiteUrl } from "#site-config/server/composables/utils";
-import initSiteConfig from "#site-config/server/middleware/init";
+import * as siteConfigUtils from "#site-config/server/composables/utils";
+import { initRequestSiteConfig } from "#site-config/server/init";
+import { mergeVaryHeader } from "../../cache-control.js";
 import { toMarkdownPath } from "../../markdown-path.js";
 import { toDeployedRoute } from "../../route-path.js";
 import { setStatusAwareLinkHeader } from "../plugins/link-header.js";
-import { CONTENT_NEGOTIATION_VARY } from "./content-negotiation.js";
-import { buildLinkHeader } from "./link-header.js";
+import { buildLinkHeader, buildStatusAwareLinkHeaders } from "./link-header.js";
 import { toMarkdownRequest } from "./markdown-request.js";
 import { resolveNegotiationDecision } from "./negotiation-decision.js";
 const APPLIED_KEY = "nuxt-ai-ready:negotiation-applied";
@@ -17,17 +17,25 @@ export function agentSkillArtifactPaths() {
   artifactPaths ??= new Set(Object.keys(localAgentSkillArtifacts));
   return artifactPaths;
 }
+function createHeaderUrlResolver(event, ctx) {
+  if (!siteConfigUtils.createSitePathResolver)
+    return ctx.resolveUrl;
+  let resolveUrl;
+  return (path) => {
+    resolveUrl ??= siteConfigUtils.createSitePathResolver(event, { absolute: true, withBase: true });
+    return resolveUrl(ctx.resolvePath(path));
+  };
+}
 export function setLinkHeader(event, ctx, variant) {
-  setHeader(event, "link", buildLinkHeader(ctx.path, variant, ctx.config, ctx.resolveUrl, ctx.routeContext));
+  setHeader(event, "link", buildLinkHeader(ctx.path, variant, ctx.config, createHeaderUrlResolver(event, ctx), ctx.routeContext));
 }
 export function setStatusAwareHeader(event, ctx, variant) {
-  const successHeader = buildLinkHeader(ctx.path, variant, ctx.config, ctx.resolveUrl, ctx.routeContext);
   if (!ctx.config.i18n) {
-    setHeader(event, "link", successHeader);
+    setLinkHeader(event, ctx, variant);
     return;
   }
-  const safeHeader = buildLinkHeader(ctx.path, variant, { ...ctx.config, i18n: null }, ctx.resolveUrl, ctx.routeContext);
-  setStatusAwareLinkHeader(event, safeHeader, successHeader);
+  const headers = buildStatusAwareLinkHeaders(ctx.path, variant, ctx.config, createHeaderUrlResolver(event, ctx), ctx.routeContext);
+  setStatusAwareLinkHeader(event, headers.error, headers.success);
 }
 export function setUncacheableHeaders(event) {
   setHeader(event, "cache-control", "private, no-store");
@@ -42,9 +50,26 @@ export function setUncacheableHeaders(event) {
       setHeader(event, header, "no-store");
   }
 }
-export function setMarkdownHeaders(event, ctx) {
+export function setMarkdownHeaders(event, ctx, sourceHeaders) {
   setHeader(event, "content-type", "text/markdown; charset=utf-8");
+  const vary = [getResponseHeader(event, "vary"), sourceHeaders?.get("vary")].filter(Boolean).join(", ");
+  setHeader(event, "vary", mergeVaryHeader(vary, "Accept"));
   setLinkHeader(event, ctx, "markdown");
+  const privateResponse = [
+    "cache-control",
+    "cdn-cache-control",
+    "cloudflare-cdn-cache-control",
+    "netlify-cdn-cache-control",
+    "vercel-cdn-cache-control",
+    "surrogate-control"
+  ].some((header) => {
+    const value = `${getResponseHeader(event, header) || ""},${sourceHeaders?.get(header) || ""}`;
+    return /(?:^|,)\s*(?:private|no-store|no-cache)\s*(?:,|=|$)/i.test(value);
+  });
+  if (getHeader(event, "cookie") || getHeader(event, "authorization") || getResponseHeader(event, "set-cookie") || sourceHeaders?.has("set-cookie") || privateResponse) {
+    setUncacheableHeaders(event);
+    return;
+  }
   const cacheHeaders = ctx.config.markdownCacheHeaders;
   if (cacheHeaders) {
     const { maxAge, swr } = cacheHeaders;
@@ -53,7 +78,7 @@ export function setMarkdownHeaders(event, ctx) {
 }
 export async function ensureSiteConfig(event) {
   if (!event.context._initedSiteConfig)
-    await initSiteConfig(event);
+    await initRequestSiteConfig(event, getRequestURL(event, { xForwardedHost: true, xForwardedProto: true }).origin, createNitroRouteRuleMatcher(useRuntimeConfig(event))(event.path));
 }
 export function buildNegotiationContext(event, path) {
   const runtimeConfig = useRuntimeConfig(event);
@@ -63,10 +88,11 @@ export function buildNegotiationContext(event, path) {
     config: runtimeConfig["nuxt-ai-ready"],
     path,
     resolvePath,
-    resolveUrl: (target) => withSiteUrl(event, resolvePath(target)),
+    resolveUrl: (target) => siteConfigUtils.withSiteUrl(event, resolvePath(target), { withBase: true }),
     routeContext: { host: getRequestHost(event, { xForwardedHost: true }) }
   };
 }
+const REQUEST_DECISION = Symbol("nuxt-ai-ready:negotiation");
 let matcherCache;
 function getRouteRuleMatcher(runtimeConfig) {
   if (matcherCache?.config !== runtimeConfig)
@@ -76,13 +102,27 @@ function getRouteRuleMatcher(runtimeConfig) {
 export function decideNegotiation(event, stage) {
   const runtimeConfig = useRuntimeConfig(event);
   const config = runtimeConfig["nuxt-ai-ready"];
-  return resolveNegotiationDecision({
-    stage,
-    request: toMarkdownRequest(event),
-    routeRule: getRouteRuleMatcher(runtimeConfig)(event.path),
-    policy: config.contentNegotiation,
-    artifactPaths: agentSkillArtifactPaths()
-  });
+  const context = event.context;
+  const owner = event.node?.req ?? event.req ?? event;
+  let cached = context[REQUEST_DECISION];
+  if (!cached || cached.owner !== owner || cached.path !== event.path || cached.policy !== config.contentNegotiation || cached.botNegotiation !== config.botNegotiation) {
+    cached = {
+      owner,
+      path: event.path,
+      policy: config.contentNegotiation,
+      botNegotiation: config.botNegotiation,
+      decision: resolveNegotiationDecision({
+        stage: "middleware",
+        request: toMarkdownRequest(event),
+        routeRule: getRouteRuleMatcher(runtimeConfig)(event.path),
+        policy: config.contentNegotiation,
+        botNegotiation: config.botNegotiation,
+        artifactPaths: agentSkillArtifactPaths()
+      })
+    };
+    context[REQUEST_DECISION] = cached;
+  }
+  return stage === "early" && cached.decision._tag === "render" ? { _tag: "skip", reason: "deferred" } : cached.decision;
 }
 export async function applyNegotiation(event, decision) {
   if (decision._tag === "skip" || decision._tag === "render")
@@ -92,7 +132,7 @@ export async function applyNegotiation(event, decision) {
     return;
   context[APPLIED_KEY] = true;
   if (decision._tag === "not-acceptable") {
-    appendHeader(event, "vary", CONTENT_NEGOTIATION_VARY);
+    appendHeader(event, "vary", decision.vary);
     setUncacheableHeaders(event);
     throw createError({
       statusCode: 406,
@@ -104,11 +144,11 @@ export async function applyNegotiation(event, decision) {
   const ctx = buildNegotiationContext(event, decision.path);
   if (decision._tag === "html") {
     if (decision.negotiation._tag === "enabled")
-      appendHeader(event, "vary", CONTENT_NEGOTIATION_VARY);
+      appendHeader(event, "vary", decision.negotiation.vary);
     setStatusAwareHeader(event, ctx, "html");
     return;
   }
-  appendHeader(event, "vary", CONTENT_NEGOTIATION_VARY);
+  appendHeader(event, "vary", decision.vary);
   setLinkHeader(event, ctx, "html");
   setUncacheableHeaders(event);
   return sendRedirect(event, ctx.resolvePath(toMarkdownPath(decision.path)), 307);

package/dist/runtime/server/utils/prerender-html.d.ts

@@ -1,2 +1,3 @@
-export declare function storePrerenderedHtml(path: string, html: string): void;
+import type { NuxtRenderHTMLContext } from 'nuxt/app';
+export declare function storePrerenderedHtml(path: string, html: string | NuxtRenderHTMLContext): void;
 export declare function consumePrerenderedHtml(path: string): string | undefined;

package/dist/runtime/server/utils/prerender-html.js

@@ -9,5 +9,7 @@ export function consumePrerenderedHtml(path) {
   const key = normalizeHtmlCachePath(path);
   const html = htmlByPath.get(key);
   htmlByPath.delete(key);
-  return html;
+  if (!html || typeof html === "string")
+    return html;
+  return `<!DOCTYPE html><html ${html.htmlAttrs.join(" ")}><head>${html.head.join("")}</head><body ${html.bodyAttrs.join(" ")}>${html.bodyPrepend.join("")}${html.body.join("")}${html.bodyAppend.join("")}</body></html>`;
 }

package/dist/runtime/types.d.ts

@@ -76,11 +76,10 @@ export interface AgentSkillsConfig {
      */
     skills?: AgentSkillConfig[];
     /**
-     * Directory scanned for `<name>/SKILL.md` in the project root and in every
-     * layer inside it. Each match is published as a local skill and also served
-     * at `/<dir>/<name>/SKILL.md`, mirroring the repository path. `false` turns
-     * discovery off.
-     * @default 'skills'
+     * Explicit directory scanned for `<name>/SKILL.md` in the project root and its layers.
+     * By default, only `skills/<name>/SKILL.md` inside their resolved public directories is discovered.
+     * Public skills are also served at `/skills/<name>/SKILL.md`.
+     * An explicit directory uses `/<dir>/<name>/SKILL.md`. `false` disables discovery.
      */
     dir?: string | false;
     /**
@@ -129,12 +128,21 @@ export interface ModuleOptions {
      */
     debug?: boolean;
     /**
-     * Negotiate Markdown on HTML routes through Accept and User-Agent headers.
+     * Negotiate Markdown on HTML routes through Accept headers.
      * Disable when a deployment cache cannot vary responses by request headers.
      * Explicit .md routes remain available.
+     * On Cloudflare Workers, true also routes prerendered HTML through the Worker.
+     * Automatic negotiation preserves the existing Cloudflare asset routing.
      * @default Automatic per route
      */
     contentNegotiation?: boolean;
+    /**
+     * Offer Markdown to AI bots even when their Accept header prefers HTML.
+     * Requires cache variation on Accept, Sec-Fetch-Dest, and User-Agent.
+     * Disable to avoid fragmenting caches by raw User-Agent strings.
+     * @default false
+     */
+    botNegotiation?: boolean;
     /**
      * Publish an RFC 9727 API Catalog at `/.well-known/api-catalog`.
      * Relative entry URLs resolve against the configured site URL and app base URL.
@@ -286,7 +294,7 @@ export interface ModuleOptions {
         /**
          * Database type - auto-detected if not specified
          * - 'none': No database. Build time generation only.
-         * - 'sqlite': Local SQLite via node:sqlite or better-sqlite3 (default for Node.js)
+         * - 'sqlite': Local SQLite via node:sqlite (default for Node.js)
          * - 'd1': Cloudflare D1 (auto-detected on Cloudflare)
          * - 'bun': Bun SQLite via bun:sqlite (auto-detected on Bun) [experimental]
          * - 'libsql': Turso/LibSQL [experimental]

package/dist/shared/nuxt-ai-ready.B3hAuOLQ.mjs

@@ -0,0 +1,29 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { findPackageJSON } from 'node:module';
+import { isAbsolute, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+function resolvePackageMetadataPath(specifier, base, options) {
+  if (options) {
+    const candidate = join(options.searchDirectory, specifier, "package.json");
+    if (existsSync(candidate))
+      return candidate;
+  }
+  const input = isAbsolute(specifier) ? pathToFileURL(specifier) : specifier;
+  const path = findPackageJSON(input, base && pathToFileURL(join(base, "package.json")));
+  if (!path)
+    throw new Error(`Could not find package metadata for ${specifier}.`);
+  return path;
+}
+async function readPackageMetadata(specifier, base, options) {
+  const metadata = JSON.parse(await readFile(resolvePackageMetadataPath(specifier, base, options), "utf8"));
+  if (typeof metadata !== "object" || metadata === null)
+    throw new Error(`Invalid package metadata for ${specifier}.`);
+  const version = "version" in metadata ? metadata.version : void 0;
+  const peers = "peerDependencies" in metadata ? metadata.peerDependencies : void 0;
+  const peerDependencies = typeof peers === "object" && peers !== null ? Object.fromEntries(Object.entries(peers).filter((entry) => typeof entry[1] === "string")) : {};
+  return typeof version === "string" ? { version, peerDependencies } : { peerDependencies };
+}
+
+export { resolvePackageMetadataPath as a, readPackageMetadata as r };