nuxt-ai-ready 3.2.0 → 3.3.1

package/dist/module.mjs

@@ -7,8 +7,9 @@ import '@nuxt/kit';
 import 'defu';
 import 'nuxt-site-config/kit';
 import 'nuxtseo-shared/kit';
-export { m as default } from './shared/nuxt-ai-ready.DH9mSayy.mjs';
+export { m as default } from './shared/nuxt-ai-ready.CKXM1jnE.mjs';
 import './shared/nuxt-ai-ready.B3hAuOLQ.mjs';
+import '../dist/runtime/llms-txt-files.js';
 import '../dist/runtime/route-path.js';
 import '../dist/runtime/server/utils/sitemap-md.js';
 import '../dist/runtime/server/utils/discovery-response.js';

package/dist/runtime/llms-txt-files.d.ts

@@ -0,0 +1,30 @@
+import type { LlmsTxtConfig, LlmsTxtSection } from './types.js';
+export interface LlmsTxtPage {
+    pathname: string;
+    href?: string;
+    title?: string;
+    description?: string;
+    locale?: string;
+}
+export declare function llmsTxtSectionPath(section: LlmsTxtSection): string;
+export type ParsedLlmsTxtConfig = {
+    _tag: 'Valid';
+    config: LlmsTxtConfig;
+} | {
+    _tag: 'Invalid';
+    message: string;
+};
+/** Parse the public configuration once, before Nitro registers routes. */
+export declare function parseLlmsTxtConfig(input: unknown): ParsedLlmsTxtConfig;
+interface LlmsTxtFilesInput {
+    rootContent?: string;
+    header: string;
+    config: LlmsTxtConfig;
+    sections: LlmsTxtSection[];
+    pages: LlmsTxtPage[];
+    sitemapPages: ReadonlyMap<string, LlmsTxtPage[]>;
+    resolveUrl: (path: string) => string;
+}
+/** A bounded tree of file lists. Every page appears once; every file is reachable from the root. */
+export declare function createLlmsTxtFiles(input: LlmsTxtFilesInput): Map<string, string>;
+export {};

package/dist/runtime/llms-txt-files.js

@@ -0,0 +1,196 @@
+import { formatLlmsTxtPageLink, normalizeLlmsTxtConfig } from "./llms-txt-format.js";
+const FILE_PATH = /^\/llms\/[a-z0-9][\w-]*\.txt$/i;
+const SITEMAP_NAME = /^[a-z0-9][\w-]*$/i;
+export function llmsTxtSectionPath(section) {
+  const name = Array.isArray(section.sitemap) ? section.sitemap[0] : section.sitemap;
+  return section.path || `/llms/${name}.txt`;
+}
+export function parseLlmsTxtConfig(input) {
+  const invalid = (message) => ({ _tag: "Invalid", message });
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return invalid("llmsTxt must be an object or false.");
+  const config = input;
+  if (config.pages !== void 0 && config.pages !== false && config.pages !== "sitemap" && config.pages !== "all")
+    return invalid("llmsTxt.pages must be sitemap, all, or false.");
+  if (config.maxLength !== void 0 && (!Number.isSafeInteger(config.maxLength) || config.maxLength < 1024))
+    return invalid("llmsTxt.maxLength must be an integer of at least 1024.");
+  if (config.sitemaps !== void 0 && (!Array.isArray(config.sitemaps) || config.sitemaps.some((name) => typeof name !== "string" || !SITEMAP_NAME.test(name))))
+    return invalid("llmsTxt.sitemaps must contain sitemap names.");
+  if (config.sections !== void 0 && !Array.isArray(config.sections))
+    return invalid("llmsTxt.sections must be an array.");
+  const paths = /* @__PURE__ */ new Set();
+  for (const section of config.sections || []) {
+    if (!section || typeof section !== "object" || typeof section.title !== "string")
+      return invalid("Each llmsTxt section needs a title.");
+    if (section.sitemap === void 0) {
+      if (section.path !== void 0)
+        return invalid("A section path requires a sitemap.");
+      continue;
+    }
+    const names = Array.isArray(section.sitemap) ? section.sitemap : [section.sitemap];
+    if (!names.length || names.some((name) => typeof name !== "string" || !SITEMAP_NAME.test(name)))
+      return invalid("Each section sitemap must contain a sitemap name.");
+    const path = llmsTxtSectionPath(section);
+    if (!FILE_PATH.test(path))
+      return invalid("A section path must use /llms/<name>.txt.");
+    if (paths.has(path))
+      return invalid(`Duplicate llmsTxt section path: ${path}.`);
+    paths.add(path);
+  }
+  return { _tag: "Valid", config };
+}
+export function createLlmsTxtFiles(input) {
+  const files = /* @__PURE__ */ new Map();
+  const maxLength = input.config.maxLength ?? 8e4;
+  const link = (title, path, description) => formatLlmsTxtPageLink({ pathname: path, href: input.resolveUrl(path), title, description });
+  const render = (header, title, lines) => `${header.trim()}
+
+## ${title.replace(/\s+/g, " ").trim()}
+
+${lines.join("\n")}
+`;
+  function tree(path, prefix, header, title, lines, level = 0) {
+    const body = render(header, title, lines);
+    if (body.length <= maxLength) {
+      files.set(path, body);
+      return;
+    }
+    const overhead = render(header, title, []).length;
+    const chunks = [];
+    let chunk = [];
+    let length = overhead;
+    for (const line of lines) {
+      if (overhead + line.length + 1 > maxLength)
+        throw new Error("An llms.txt entry exceeds llmsTxt.maxLength. Shorten the entry or increase the limit.");
+      if (length + line.length + 1 > maxLength) {
+        chunks.push(chunk);
+        chunk = [];
+        length = overhead;
+      }
+      chunk.push(line);
+      length += line.length + 1;
+    }
+    if (chunk.length)
+      chunks.push(chunk);
+    const links = chunks.map((entries, index) => {
+      const child = `/llms/_${prefix}-${level}-${index + 1}.txt`;
+      files.set(child, render(header, title, entries));
+      return link(`${title} ${index + 1}`, child);
+    });
+    if (chunks.length >= lines.length && render(header, title, links).length >= body.length)
+      throw new Error("llmsTxt.maxLength cannot fit an index. Increase the limit.");
+    tree(path, prefix, header, title, links, level + 1);
+  }
+  const sections = [];
+  const assigned = /* @__PURE__ */ new Set();
+  for (const [index, section] of input.sections.entries()) {
+    if (!section.sitemap) {
+      sections.push(section);
+      continue;
+    }
+    const names = Array.isArray(section.sitemap) ? section.sitemap : [section.sitemap];
+    const pages2 = /* @__PURE__ */ new Map();
+    for (const name of names) {
+      for (const page of input.sitemapPages.get(name) || []) {
+        if (!assigned.has(page.pathname))
+          pages2.set(page.pathname, page);
+      }
+    }
+    const entries = [...(section.links || []).map((entry) => formatLlmsTxtPageLink({ pathname: entry.href, ...entry })), ...[...pages2.values()].map(formatLlmsTxtPageLink)];
+    if (!entries.length)
+      continue;
+    for (const pathname of pages2.keys())
+      assigned.add(pathname);
+    const path = llmsTxtSectionPath(section);
+    const description = Array.isArray(section.description) ? section.description.join(" ") : section.description;
+    const preamble = normalizeLlmsTxtConfig({ notes: description });
+    tree(path, `section-${index + 1}`, `${input.header.trim()}
+
+${preamble}
+
+${link("llms.txt", "/llms.txt")}`, section.title, entries);
+    sections.push({ ...section, sitemap: void 0, path: void 0, links: [{ title: section.title, href: input.resolveUrl(path), description }] });
+  }
+  const rootPreamble = `${input.header.trim()}
+
+${normalizeLlmsTxtConfig({ notes: input.config.notes })}${input.rootContent ? `
+
+${input.rootContent}` : ""}`;
+  const pageIndexSpace = input.pages.some((page) => !assigned.has(page.pathname)) ? render("", "Pages", [link("Pages", "/llms/_pages.txt")]).length : 1;
+  let rootHeader = `${input.header.trim()}
+
+${normalizeLlmsTxtConfig({ ...input.config, sections })}${input.rootContent ? `
+
+${input.rootContent}` : ""}`;
+  if (rootHeader.length + pageIndexSpace > maxLength) {
+    const references = sections.flatMap((section, index) => {
+      const path = `/llms/_configured-${index + 1}.txt`;
+      if (!section.links?.length) {
+        const context = normalizeLlmsTxtConfig({ sections: [section] });
+        if (!context)
+          return [];
+        const body = `${input.header.trim()}
+
+${context}
+
+${link("llms.txt", "/llms.txt")}
+`;
+        if (body.length > maxLength)
+          throw new Error("An llms.txt entry exceeds llmsTxt.maxLength. Shorten the entry or increase the limit.");
+        files.set(path, body);
+        return [{ title: section.title, links: [{ title: section.title, href: input.resolveUrl(path) }] }];
+      }
+      const text = normalizeLlmsTxtConfig({ sections: [{ ...section, description: section.optional ? section.description : void 0 }] });
+      const lines = text.split("\n").slice(2);
+      const description = Array.isArray(section.description) ? section.description.join(" ") : section.description;
+      const preamble = section.optional ? "" : normalizeLlmsTxtConfig({ notes: description });
+      tree(path, `configured-${index + 1}`, `${input.header.trim()}
+
+${preamble}
+
+${link("llms.txt", "/llms.txt")}`, section.optional ? "Optional" : section.title, lines);
+      return [{ title: section.title, optional: section.optional, links: [{ title: section.title, href: input.resolveUrl(path), description }] }];
+    });
+    rootHeader = `${rootPreamble}
+
+${normalizeLlmsTxtConfig({ sections: references })}`;
+    if (rootHeader.length + pageIndexSpace > maxLength) {
+      const indexes = [];
+      for (const optional of [false, true]) {
+        const selected = references.filter((section) => Boolean(section.optional) === optional);
+        if (!selected.length)
+          continue;
+        const title = optional ? "Optional" : "Sections";
+        const path = optional ? "/llms/_optional.txt" : "/llms/_sections.txt";
+        const text = normalizeLlmsTxtConfig({ sections: selected.map((section) => ({ ...section, optional: true })) });
+        tree(path, optional ? "optional" : "sections", input.header, title, text.split("\n").slice(2));
+        indexes.push({ title, optional, links: [{ title, href: input.resolveUrl(path) }] });
+      }
+      rootHeader = `${rootPreamble}
+
+${normalizeLlmsTxtConfig({ sections: indexes })}`;
+    }
+  }
+  const pages = input.pages.filter((page) => !assigned.has(page.pathname)).map(formatLlmsTxtPageLink);
+  if (!pages.length && rootHeader.length + 1 <= maxLength) {
+    files.set("/llms.txt", `${rootHeader.trim()}
+`);
+  } else {
+    const inline = render(rootHeader, "Pages", pages);
+    if (inline.length <= maxLength) {
+      files.set("/llms.txt", inline);
+    } else {
+      tree("/llms/_pages.txt", "pages", input.header, "Pages", pages);
+      const root = `${rootHeader.trim()}
+
+## Pages
+
+${link("Pages", "/llms/_pages.txt")}
+`;
+      if (root.length > maxLength)
+        throw new Error("llms.txt sections exceed llmsTxt.maxLength. Shorten the sections or increase the limit.");
+      files.set("/llms.txt", root);
+    }
+  }
+  return files;
+}

package/dist/runtime/llms-txt-format.js

@@ -1,3 +1,4 @@
+import { escapeMarkdownHtml } from "./markdown-text.js";
 const RE_INLINE_WHITESPACE = /\s+/g;
 const RE_LINK_TITLE_BRACKET = /[[\]]/g;
 const RE_LINK_HREF_UNSAFE = /[\s()]/g;
@@ -6,7 +7,7 @@ function normalizeInlineText(value) {
   return value.trim().replace(RE_INLINE_WHITESPACE, " ");
 }
 function normalizeLinkTitle(value) {
-  return normalizeInlineText(value).replace(RE_LINK_TITLE_BRACKET, (bracket) => bracket === "[" ? "[" : "]");
+  return escapeMarkdownHtml(normalizeInlineText(value)).replace(RE_LINK_TITLE_BRACKET, (bracket) => bracket === "[" ? "[" : "]");
 }
 function normalizeLinkHref(value) {
   return value.trim().replace(RE_LINK_HREF_UNSAFE, (character) => {
@@ -29,7 +30,7 @@ function normalizeLink(link, descriptionPrefixes = []) {
   return `- [${normalizeLinkTitle(link.title)}](${normalizeLinkHref(link.href)})${description ? `: ${description}` : ""}`;
 }
 function normalizeSection(section) {
-  const parts = [`## ${normalizeInlineText(section.title)}`];
+  const parts = [`## ${escapeMarkdownHtml(normalizeInlineText(section.title))}`];
   if (section.links?.length)
     parts.push("", ...section.links.map((link) => normalizeLink(link)));
   return parts.join("\n");
@@ -46,7 +47,7 @@ function normalizePreamble(config) {
       continue;
     const descriptions = normalizePreambleBlocks(section.description);
     if (descriptions.length)
-      parts.push([`**${normalizeInlineText(section.title)}:**`, ...descriptions].join("\n\n"));
+      parts.push([`**${escapeMarkdownHtml(normalizeInlineText(section.title))}:**`, ...descriptions].join("\n\n"));
   }
   return parts;
 }
@@ -67,7 +68,7 @@ export function formatLlmsTxtPageLink(page) {
   const title = normalizedTitle && normalizedTitle !== page.pathname ? normalizedTitle : page.pathname;
   const href = (page.href || page.pathname).trim();
   const truncatedDescription = description ? `${description.substring(0, 160)}${description.length > 160 ? "..." : ""}` : void 0;
-  return normalizeLink({ title, href, description: truncatedDescription });
+  return normalizeLink({ title, href, description: truncatedDescription ? escapeMarkdownHtml(truncatedDescription) : void 0 });
 }
 export function normalizeLlmsTxtConfig(config) {
   const required = config.sections?.filter((section) => !section.optional) ?? [];

package/dist/runtime/llms-txt-utils.d.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from '#nuxtseo/h3';
-import { normalizeLlmsTxtConfig } from './llms-txt-format.js';
-export { normalizeLlmsTxtConfig };
+export { normalizeLlmsTxtConfig } from './llms-txt-format.js';
+/** One discovery snapshot supplies the root and every bounded child file. */
+export declare function buildLlmsTxtFiles(event: H3Event): Promise<Record<string, string>>;
 export declare function buildLlmsTxt(event: H3Event): Promise<string>;

package/dist/runtime/llms-txt-utils.js

@@ -1,23 +1,18 @@
 import { decodePath } from "ufo";
-import { getRequestHost } from "#nuxtseo/h3";
+import { createError, getRequestHost, getRequestURL } from "#nuxtseo/h3";
 import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 import { withSiteTrailingSlash, withSiteUrl } from "#site-config/server/composables/utils";
-import { formatLlmsTxtPageLink, normalizeLlmsTxtConfig } from "./llms-txt-format.js";
-import { absoluteSiteUrl } from "./markdown-links.js";
+import { createLlmsTxtFiles } from "./llms-txt-files.js";
 import { hasMarkdownTwin, toMarkdownPath } from "./markdown-path.js";
 import { normalizePersistedRoute, toDeployedRoute, toLogicalRoute } from "./route-path.js";
-import { queryPages } from "./server/db/queries.js";
+import { queryPageMetadata, queryPages } from "./server/db/queries.js";
 import { logger } from "./server/logger.js";
-import { fetchSitemapUrls } from "./server/utils/sitemap.js";
-export { normalizeLlmsTxtConfig };
+import { fetchSitemapUrlGroups, getSitemapsFromConfig } from "./server/utils/sitemap.js";
+export { normalizeLlmsTxtConfig } from "./llms-txt-format.js";
 async function findMarkdownLinkAvailability() {
-  if (!import.meta.prerender) {
-    return {
-      runtimeMarkdownAvailable: true,
-      paths: /* @__PURE__ */ new Set()
-    };
-  }
+  if (!import.meta.prerender)
+    return { runtimeMarkdownAvailable: true, paths: /* @__PURE__ */ new Set() };
   const { readMarkdownLinkAvailabilityFromFilesystem } = await import("#ai-ready-virtual/read-page-data.mjs");
   const availability = await readMarkdownLinkAvailabilityFromFilesystem();
   return {
@@ -25,231 +20,97 @@ async function findMarkdownLinkAvailability() {
     paths: new Set(availability.paths.map(decodePath))
   };
 }
-function getGroupPrefix(url, depth) {
-  const segments = url.split("/").filter(Boolean);
-  if (segments.length === 0)
-    return "/";
-  if (depth === 1 || segments.length === 1)
-    return `/${segments[0]}`;
-  return `/${segments[0]}/${segments[1]}`;
-}
-function getPathSegments(pathname) {
-  return pathname.split("/").filter((s) => Boolean(s));
-}
-function analyzePageGroups(pages) {
-  const twoSegmentCount = /* @__PURE__ */ new Map();
-  const segmentHasNested = /* @__PURE__ */ new Map();
-  for (const page of pages) {
-    const prefix = getGroupPrefix(page.pathname, 2);
-    twoSegmentCount.set(prefix, (twoSegmentCount.get(prefix) || 0) + 1);
-    const segments = getPathSegments(page.pathname);
-    const firstSegment = segments[0] || "";
-    if (!segmentHasNested.has(firstSegment))
-      segmentHasNested.set(firstSegment, false);
-    if (segments.length > 1)
-      segmentHasNested.set(firstSegment, true);
-  }
-  return { twoSegmentCount, segmentHasNested };
-}
-function getPageGroupKey(pathname, { twoSegmentCount, segmentHasNested }) {
-  const segments = getPathSegments(pathname);
-  const firstSegment = segments[0] || "";
-  const twoSegPrefix = getGroupPrefix(pathname, 2);
-  const twoSegCount = twoSegmentCount.get(twoSegPrefix) || 0;
-  let groupKey = twoSegCount > 1 ? twoSegPrefix : `/${firstSegment}`;
-  if (segments.length <= 1 && !segmentHasNested.get(firstSegment))
-    groupKey = "";
-  return groupKey;
-}
-function sortPagesByPath(pages) {
-  const analysis = analyzePageGroups(pages);
-  return pages.sort((a, b) => {
-    const segmentsA = getPathSegments(a.pathname);
-    const segmentsB = getPathSegments(b.pathname);
-    const groupKeyA = getPageGroupKey(a.pathname, analysis);
-    const groupKeyB = getPageGroupKey(b.pathname, analysis);
-    if (groupKeyA === "" && groupKeyB !== "")
-      return -1;
-    if (groupKeyA !== "" && groupKeyB === "")
-      return 1;
-    if (groupKeyA !== groupKeyB)
-      return groupKeyA.localeCompare(groupKeyB);
-    if (segmentsA.length === 0)
-      return -1;
-    if (segmentsB.length === 0)
-      return 1;
-    const minLen = Math.min(segmentsA.length, segmentsB.length);
-    for (let i = 0; i < minLen; i++) {
-      const cmp = segmentsA[i].localeCompare(segmentsB[i]);
-      if (cmp !== 0)
-        return cmp;
-    }
-    return segmentsA.length - segmentsB.length;
-  });
-}
-function formatPagesWithGroups(pages) {
-  if (pages.length === 0)
-    return [];
-  const analysis = analyzePageGroups(pages);
-  const lines = [];
-  let currentGroup = "";
-  let segmentGroupIndex = 0;
-  let urlsInCurrentGroup = 0;
-  for (const page of pages) {
-    const groupKey = getPageGroupKey(page.pathname, analysis);
-    if (groupKey !== currentGroup) {
-      if (urlsInCurrentGroup > 0) {
-        const shouldAddBlankLine = segmentGroupIndex === 0 || segmentGroupIndex >= 1 && segmentGroupIndex <= 2 && urlsInCurrentGroup > 1;
-        if (shouldAddBlankLine)
-          lines.push("");
-      }
-      currentGroup = groupKey;
-      segmentGroupIndex++;
-      urlsInCurrentGroup = 0;
-    }
-    urlsInCurrentGroup++;
-    lines.push(formatLlmsTxtPageLink(page));
-  }
-  return lines;
-}
-export async function buildLlmsTxt(event) {
+export async function buildLlmsTxtFiles(event) {
   const runtimeConfig = useRuntimeConfig(event);
   const aiReadyConfig = runtimeConfig["nuxt-ai-ready"];
-  const sitemapConfig = runtimeConfig.sitemap;
   const siteConfig = getSiteConfig(event);
-  const llmsTxtConfig = aiReadyConfig.llmsTxt;
-  const i18n = aiReadyConfig.i18n;
-  const i18nRuntime = i18n ? { _tag: "enabled", config: i18n, ...await import("./llms-txt-i18n.js") } : { _tag: "disabled" };
-  const i18nContext = { host: getRequestHost(event, { xForwardedHost: true }) };
+  const config = aiReadyConfig.llmsTxt;
   const baseURL = runtimeConfig.app.baseURL;
-  const resolvePath = (path) => withSiteTrailingSlash(event, toDeployedRoute(path, baseURL));
   const resolveUrl = (path) => withSiteUrl(event, toDeployedRoute(path, baseURL), { withBase: true });
+  const resolvePageUrl = (path) => resolveUrl(withSiteTrailingSlash(event, path));
   const canonicalSiteUrl = siteConfig.url ? resolveUrl("/") : void 0;
-  const parts = [];
-  parts.push(`# ${siteConfig.name || canonicalSiteUrl}`);
-  if (siteConfig.description) {
-    parts.push(`
-> ${siteConfig.description}`);
-  }
-  if (canonicalSiteUrl) {
-    parts.push(`
-Canonical Origin: ${canonicalSiteUrl}`);
-  }
-  parts.push("");
-  const sections = llmsTxtConfig.sections?.map((section) => ({
-    ...section,
-    links: section.links ? [...section.links] : void 0
-  })) ?? [];
-  if (sections[0]?.links) {
-    const sitemapRoutes = sitemapConfig?.sitemaps ? Object.values(sitemapConfig.sitemaps).map((s) => s.sitemapName) : ["sitemap.xml"];
-    for (const name of sitemapRoutes) {
-      sections[0].links.push({
-        title: name,
-        href: resolveUrl(`/${name}`),
-        description: "XML sitemap for search engines and crawlers."
-      });
+  const i18n = aiReadyConfig.i18n;
+  const i18nRuntime = i18n ? { _tag: "enabled", config: i18n, ...await import("./llms-txt-i18n.js") } : { _tag: "disabled" };
+  const i18nContext = { host: getRequestHost(event, { xForwardedHost: true }) };
+  const parts = [`# ${(siteConfig.name || canonicalSiteUrl || "Site").replace(/\s+/g, " ").trim()}`];
+  if (siteConfig.description)
+    parts.push("", `> ${siteConfig.description.replace(/\s+/g, " ").trim()}`);
+  if (canonicalSiteUrl)
+    parts.push("", `Canonical Origin: ${canonicalSiteUrl}`);
+  const sections = config.sections?.map((section) => ({ ...section, links: section.links ? [...section.links] : void 0 })) ?? [];
+  const resources = sections.find((section) => section.title === "LLM Resources" && !section.sitemap);
+  if (resources) {
+    resources.links ||= [];
+    for (const sitemap of getSitemapsFromConfig(event).filter((sitemap2) => config.sitemaps === void 0 || config.sitemaps.includes(sitemap2.name))) {
+      resources.links.push({ title: sitemap.route.split("/").pop() || `${sitemap.name}.xml`, href: resolveUrl(toLogicalRoute(sitemap.route, baseURL)), description: "XML sitemap for search engines and crawlers." });
     }
-    sections[0].links.push({
-      title: "robots.txt",
-      href: resolveUrl("/robots.txt"),
-      description: "Crawler rules and permissions."
-    });
+    if (!getSitemapsFromConfig(event).length && (config.sitemaps === void 0 || config.sitemaps.includes("sitemap")))
+      resources.links.push({ title: "sitemap.xml", href: resolveUrl("/sitemap.xml"), description: "XML sitemap for search engines and crawlers." });
+    resources.links.push({ title: "robots.txt", href: resolveUrl("/robots.txt"), description: "Crawler rules and permissions." });
   }
-  const normalizedContent = normalizeLlmsTxtConfig({ ...llmsTxtConfig, sections });
-  if (normalizedContent) {
-    parts.push(normalizedContent);
-    parts.push("");
+  if (config.pages === false && !sections.some((section) => section.sitemap))
+    return Object.fromEntries(createLlmsTxtFiles({ header: parts.join("\n"), config, sections, pages: [], sitemapPages: /* @__PURE__ */ new Map(), resolveUrl }));
+  const groups = await fetchSitemapUrlGroups(event, config.sitemaps);
+  const allowedOrigin = canonicalSiteUrl ? new URL(canonicalSiteUrl).origin : void 0;
+  const requestOrigin = getRequestURL(event, { xForwardedHost: true, xForwardedProto: true }).origin;
+  const sitemapPaths = /* @__PURE__ */ new Map();
+  for (const [name, urls] of groups) {
+    const paths = /* @__PURE__ */ new Set();
+    for (const entry of urls) {
+      const url = URL.canParse(entry.loc, canonicalSiteUrl || "http://localhost") ? new URL(entry.loc, canonicalSiteUrl || "http://localhost") : void 0;
+      if (!url || url.search || url.hash || allowedOrigin && url.origin !== allowedOrigin && url.origin !== requestOrigin)
+        continue;
+      const path = toLogicalRoute(url.pathname, baseURL);
+      paths.add(path);
+    }
+    sitemapPaths.set(name, paths);
   }
-  const urlsPromise = fetchSitemapUrls(event);
-  let pages = [];
-  let errorPages = [];
-  try {
-    ;
-    [pages, errorPages] = await Promise.all([
-      queryPages(event),
-      queryPages(event, { where: { hasError: true } })
-    ]);
-  } catch (err) {
-    logger.warn(
-      `[ai-ready] Database unavailable for llms.txt, falling back to sitemap-only pages: ${err instanceof Error ? err.message : String(err)}`
-    );
+  const admitted = new Set([...sitemapPaths.values()].flatMap((paths) => [...paths]));
+  let stored = [];
+  if (aiReadyConfig.database?._tag !== "Disabled") {
+    const read = config.pages === "all" ? Promise.all([queryPages(event), queryPages(event, { where: { hasError: true } })]).then((results) => results.flat()) : queryPageMetadata(event, [...admitted].flatMap((path) => [path, toDeployedRoute(path, baseURL)]));
+    stored = await read.catch((error) => {
+      logger.warn(`[ai-ready] Database unavailable for llms.txt. Using sitemap metadata: ${error instanceof Error ? error.message : String(error)}`);
+      return [];
+    });
   }
-  const urls = await urlsPromise;
-  const sitemapPaths = urls.map((url) => toLogicalRoute(url.loc, baseURL));
-  const sitemapPathSet = new Set(sitemapPaths);
-  const seenPaths = /* @__PURE__ */ new Set();
-  const errorSet = new Set(errorPages.map((p) => normalizePersistedRoute(p.route, sitemapPathSet, baseURL)));
-  const prerendered = [];
-  for (const page of pages) {
-    const pathname = normalizePersistedRoute(page.route, sitemapPathSet, baseURL);
-    if (seenPaths.has(pathname))
+  const errorPaths = new Set(stored.filter((page) => page.isError).map((page) => normalizePersistedRoute(page.route, admitted, baseURL)));
+  const metadata = new Map(stored.map((page) => [normalizePersistedRoute(page.route, admitted, baseURL), page]));
+  const availability = config.markdownLinks ? await findMarkdownLinkAvailability() : void 0;
+  const href = (path) => {
+    const markdownPath = toMarkdownPath(path);
+    if (availability && (availability.paths.has(decodePath(toDeployedRoute(markdownPath, baseURL))) || availability.runtimeMarkdownAvailable && hasMarkdownTwin(path)))
+      return resolveUrl(markdownPath);
+    return resolvePageUrl(path);
+  };
+  const pageMap = /* @__PURE__ */ new Map();
+  const candidates = config.pages === "all" ? /* @__PURE__ */ new Set([...admitted, ...metadata.keys()]) : admitted;
+  for (const pathname of [...candidates].sort()) {
+    if (errorPaths.has(pathname))
       continue;
-    seenPaths.add(pathname);
-    prerendered.push({ pathname, title: page.title, description: page.description, locale: page.locale });
+    const page = metadata.get(pathname);
+    const locale = page?.locale || (i18nRuntime._tag === "enabled" ? i18nRuntime.resolveLocaleFromRoute(pathname, i18nRuntime.config, i18nContext).locale : void 0);
+    pageMap.set(pathname, { pathname, href: href(pathname), title: page?.title, description: page?.description, locale });
   }
-  const devModeHint = import.meta.dev && prerendered.length === 0 ? " (dev mode - run `nuxi generate` for page titles)" : "";
-  const other = [];
-  for (const pathname of sitemapPaths) {
-    if (!seenPaths.has(pathname) && !errorSet.has(pathname)) {
-      const locale = i18nRuntime._tag === "enabled" ? i18nRuntime.resolveLocaleFromRoute(pathname, i18nRuntime.config, i18nContext).locale : void 0;
-      other.push({ pathname, locale });
-      seenPaths.add(pathname);
-    }
-  }
-  let resolvePageHref = resolvePath;
-  if (llmsTxtConfig.markdownLinks) {
-    const markdownLinkAvailability = await findMarkdownLinkAvailability();
-    resolvePageHref = (pathname) => {
-      const deployedPathname = resolvePath(pathname);
-      const markdownPath = resolvePath(toMarkdownPath(pathname));
-      if (markdownLinkAvailability.paths.has(decodePath(markdownPath)) || markdownLinkAvailability.runtimeMarkdownAvailable && hasMarkdownTwin(pathname)) {
-        return markdownPath;
-      }
-      return deployedPathname;
-    };
-  }
-  const resolvePagePath = resolvePageHref;
-  resolvePageHref = (pathname) => absoluteSiteUrl(resolvePagePath(pathname), canonicalSiteUrl);
-  for (const page of [...prerendered, ...other])
-    page.href = resolvePageHref(page.pathname);
+  let rootContent;
   if (i18nRuntime._tag === "enabled") {
-    const pageCounts = /* @__PURE__ */ new Map();
-    for (const locale of i18nRuntime.config.locales) pageCounts.set(locale.code, 0);
-    for (const p of [...prerendered, ...other]) {
-      const code = p.locale || i18nRuntime.resolveLocaleFromRoute(p.pathname, i18nRuntime.config, i18nContext).locale;
-      pageCounts.set(code, (pageCounts.get(code) ?? 0) + 1);
+    const counts = /* @__PURE__ */ new Map();
+    for (const page of pageMap.values())
+      counts.set(page.locale, (counts.get(page.locale) || 0) + 1);
+    rootContent = i18nRuntime.formatAvailableLanguagesSection(i18nRuntime.config, counts, href, i18nContext).join("\n");
+    for (const [path, page] of pageMap) {
+      if (page.locale !== i18nRuntime.config.defaultLocale)
+        pageMap.delete(path);
     }
-    parts.push(...i18nRuntime.formatAvailableLanguagesSection(i18nRuntime.config, pageCounts, resolvePageHref, i18nContext));
-    parts.push("");
   }
-  const isDefaultLocale = (item) => {
-    if (i18nRuntime._tag === "disabled")
-      return true;
-    const code = item.locale || i18nRuntime.resolveLocaleFromRoute(item.pathname, i18nRuntime.config, i18nContext).locale;
-    return code === i18nRuntime.config.defaultLocale;
-  };
-  const filteredPrerendered = i18nRuntime._tag === "enabled" ? prerendered.filter(isDefaultLocale) : prerendered;
-  const filteredOther = i18nRuntime._tag === "enabled" ? other.filter(isDefaultLocale) : other;
-  const sortedPrerendered = sortPagesByPath(filteredPrerendered);
-  const sortedOther = sortPagesByPath(filteredOther);
-  if (sortedPrerendered.length > 0 && sortedOther.length > 0) {
-    parts.push(`## Prerendered Pages${devModeHint}
-`);
-    parts.push(...formatPagesWithGroups(sortedPrerendered));
-    parts.push("");
-    parts.push("## Other Pages\n");
-    parts.push(...formatPagesWithGroups(sortedOther));
-    parts.push("");
-  } else if (sortedPrerendered.length > 0) {
-    parts.push(`## Pages${devModeHint}
-`);
-    parts.push(...formatPagesWithGroups(sortedPrerendered));
-    parts.push("");
-  } else if (sortedOther.length > 0) {
-    parts.push(`## Pages${devModeHint}
-`);
-    parts.push(...formatPagesWithGroups(sortedOther));
-    parts.push("");
-  }
-  return parts.join("\n");
+  const sitemapPages = new Map([...sitemapPaths].map(([name, paths]) => [name, [...paths].flatMap((path) => pageMap.has(path) ? [pageMap.get(path)] : [])]));
+  return Object.fromEntries(createLlmsTxtFiles({ header: parts.join("\n"), config, sections, rootContent, pages: config.pages === false ? [] : [...pageMap.values()], sitemapPages, resolveUrl }));
+}
+export async function buildLlmsTxt(event) {
+  const files = await buildLlmsTxtFiles(event);
+  const path = toLogicalRoute(event.path.split("?")[0], useRuntimeConfig(event).app.baseURL);
+  const content = files[path];
+  if (content === void 0)
+    throw createError({ statusCode: 404, statusMessage: "llms.txt file not found" });
+  return content;
 }

package/dist/runtime/markdown-text.d.ts

@@ -0,0 +1,2 @@
+/** Keep plain metadata literal when Markdown allows inline HTML. */
+export declare function escapeMarkdownHtml(value: string): string;

package/dist/runtime/markdown-text.js

@@ -0,0 +1,3 @@
+export function escapeMarkdownHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}