@lexibase/rdx-next 4.2.0 → 5.0.1

package/bin/locale-routes.mjs

@@ -1,4 +1,4 @@
-import { lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { lstat, mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import path from 'node:path'
 
 const defaultFiles = [
@@ -14,6 +14,7 @@ const generated = [
   'app/(rdx-locales)/[locale]/not-found.tsx',
   'app/(rdx-locales)/[locale]/docs/[[...slug]]/page.tsx',
   'app/(rdx-locales)/[locale]/rdx-search/[source]/route.ts',
+  'app/(rdx-locales)/[locale]/docs/llms.txt/route.ts',
 ]
 
 /** Root layouts keep HTML language correct on the server, without middleware. */
@@ -34,6 +35,18 @@ export async function prepareLocaleRoutes(project, runtime, template) {
     }
     return current
   }
+  // An existing public index owns this URL. Keep it when upgrading a project.
+  const publicIndex = path.join(project.rootDir, 'public', 'docs', 'llms.txt')
+  const hasPublicIndex = await stat(publicIndex).then(
+    (entry) => entry.isFile(),
+    (error) => {
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return false
+      throw error
+    }
+  )
+  if (hasPublicIndex)
+    await rm(await safe('app/docs/llms.txt/route.ts'), { force: true })
+
   const marker = await safe('.rdx-localization.json')
   let owned = false
   try {
@@ -130,6 +143,23 @@ export async function generateStaticParams() {
   return project.localization!.locales.flatMap(locale => getSearchSources(getLocalizedProject(project, locale.path)).map(source => ({ locale: locale.path, ...source })))
 }
 export async function GET(_request: Request, { params }: { params: Promise<{ locale: string, source: string }> }) { const { locale, source } = await params; return getSearchResponse(getLocalizedProject(await getProject(), locale), source) }
+`
+  )
+  await emit(
+    'app/(rdx-locales)/[locale]/docs/llms.txt/route.ts',
+    `import { getLlmIndexResponse, getLocalizedProject } from '${provider}'
+import { getProject } from '../../../../../rdx-project'
+export const dynamic = 'force-static'
+export const dynamicParams = false
+export async function generateStaticParams() {
+  return (await getProject()).localization!.locales.map(locale => ({ locale: locale.path }))
+}
+export async function GET(_request: Request, { params }: { params: Promise<{ locale: string }> }) {
+  const project = await getProject()
+  const { locale } = await params
+  if (!project.localization?.locales.some(entry => entry.path === locale)) return new Response(null, { status: 404 })
+  return getLlmIndexResponse(getLocalizedProject(project, locale))
+}
 `
   )
   await writeFile(marker, JSON.stringify({ version: 1 }) + '\n')

package/config.mjs

@@ -6,6 +6,7 @@ import {
   createRdxProject,
   resolveProjectPath,
   getContentSources,
+  snapshotDatesFilename,
 } from '@lexibase/rdx-core/config'
 import { createJiti } from 'jiti'
 
@@ -49,7 +50,9 @@ async function contentFiles(directory) {
       const filename = path.join(directory, entry.name)
       if (entry.isDirectory()) return contentFiles(filename)
       return entry.isFile() &&
-        (/\.mdx?$/.test(entry.name) || entry.name === '_category.json')
+        (/\.mdx?$/.test(entry.name) ||
+          entry.name === '_category.json' ||
+          entry.name === snapshotDatesFilename)
         ? [filename]
         : []
     })

package/dist/runtime/index.d.ts

@@ -21,6 +21,17 @@ declare function getRdxSitemap(project: RdxProject, { documentPath, }?: {
     documentPath?: (source: RdxContentSource, page: RdxDocPage) => string;
 }): MetadataRoute.Sitemap;
 
+type DocumentPath = (source: RdxContentSource, page: Pick<RdxDocPage, 'slug' | 'sourcePath'>) => string;
+declare function getMarkdownHref(htmlPath: string): string;
+declare function getLlmIndexResponse(project: RdxProject, documentPath?: DocumentPath): Response;
+declare function getMarkdownPaths(project: RdxProject, documentPath?: DocumentPath): {
+    path: string[];
+}[];
+declare function parseMarkdownPath(path: string[]): string[] | undefined;
+declare function getMarkdownResponse(project: RdxProject, path: string[]): Response;
+declare function markdownNotFound(): Response;
+declare function getDocumentMarkdownResponse(project: RdxProject, source: RdxContentSource | undefined, slug: string, documentPath?: DocumentPath): Response;
+
 /** Read metadata from the same content source and index used by the page. */
 declare function getDocumentMetadata({ project, slug, }: {
     project: RdxProject;
@@ -47,4 +58,4 @@ declare function DocsPage({ slug, project, }: {
     project: RdxProject;
 }): Promise<react.JSX.Element>;
 
-export { DocsPage, HomePage, NotFoundPage, RdxLayout, getDocumentMetadata, getPageMetadata, getRdxMetadata, getRdxRobots, getRdxSitemap, getSearchResponse, getSearchSources, getSourceRobots };
+export { DocsPage, HomePage, NotFoundPage, RdxLayout, getDocumentMarkdownResponse, getDocumentMetadata, getLlmIndexResponse, getMarkdownHref, getMarkdownPaths, getMarkdownResponse, getPageMetadata, getRdxMetadata, getRdxRobots, getRdxSitemap, getSearchResponse, getSearchSources, getSourceRobots, markdownNotFound, parseMarkdownPath };

package/dist/runtime/index.js

@@ -1,14 +1,15 @@
 // src/runtime/index.tsx
 import {
-  getDocument as getDocument3,
+  getDocument as getDocument4,
   getDocsPaths,
-  getSourceOptions as getSourceOptions4,
+  getSourceOptions as getSourceOptions5,
   resolveDocsRoute as resolveDocsRoute2,
-  getLocalizedProject as getLocalizedProject2,
-  getDocsHref as getDocsHref3,
+  getLocalizedProject as getLocalizedProject3,
+  getDocsHref as getDocsHref4,
   getLanguageLinks,
-  isFallbackPage as isFallbackPage3
+  isFallbackPage as isFallbackPage4
 } from "@lexibase/rdx-core";
+import { getEditPageHref } from "@lexibase/rdx-core/config";
 import { Button } from "@lexibase/rdx-ui/components/button";
 import { Callout } from "@lexibase/rdx-ui/components/callout";
 import { LanguageDropdown } from "@lexibase/rdx-ui/components/language-dropdown";
@@ -19,6 +20,8 @@ import { DocsSearch } from "@lexibase/rdx-ui/components/docs-search";
 import { Home } from "@lexibase/rdx-ui/components/home";
 import { SkipLink } from "@lexibase/rdx-ui/components/skip-link";
 import { FooterCredit } from "@lexibase/rdx-ui/components/footer-credit";
+import { EditPageLink } from "@lexibase/rdx-ui/components/edit-page-link";
+import { CopyPage } from "@lexibase/rdx-ui/components/copy-page";
 import { BrandLogo } from "@lexibase/rdx-ui/components/brand-logo";
 import { getMdxComponents } from "@lexibase/rdx-ui/components/mdx-components";
 import { getMessages, formatMessage } from "@lexibase/rdx-ui/lib/i18n";
@@ -61,19 +64,170 @@ function compileDocumentation(source, components, links) {
   });
 }
 
+// src/runtime/markdown.ts
+import {
+  getContentSources,
+  getDocsHref,
+  getDocsIndex,
+  getDocument,
+  getLocalizedProject,
+  getSourceOptions,
+  isFallbackPage
+} from "@lexibase/rdx-core";
+import { exportMarkdownBody } from "@lexibase/rdx-core/mdx";
+import {
+  createDocumentDateReader,
+  getSnapshotDocumentDate
+} from "@lexibase/rdx-core/config";
+function publicUrl(project, path) {
+  const base = project.config.metadata.metadataBase;
+  return base ? new URL(path, base).href : path;
+}
+function indexPath(project) {
+  return `${project.locale ? `/${project.locale.path}` : ""}/docs/llms.txt`;
+}
+function defaultLocale(project) {
+  const locale = project.localization?.locales.find(
+    (entry) => entry.code === project.localization.defaultLocale
+  );
+  return !project.locale && locale ? getLocalizedProject(project, locale.path) : project;
+}
+function text(value) {
+  return value.replace(/\s+/g, " ").trim().replace(/[\\`*_[\]<>]/g, "\\$&");
+}
+function getMarkdownHref(htmlPath) {
+  return `/rdx-markdown${htmlPath}.md`;
+}
+function response(body, type, status = 200) {
+  return new Response(body, {
+    status,
+    headers: {
+      "Content-Type": `${type}; charset=utf-8`,
+      "X-Robots-Tag": "noindex, follow"
+    }
+  });
+}
+function getLlmIndexResponse(project, documentPath) {
+  project = defaultLocale(project);
+  const source = project.sources.find(
+    (entry) => entry.id !== "current" && entry.redirectTo === void 0 && entry.badge !== "Archived"
+  ) ?? project.sources[0];
+  const { metadata, description } = project.config;
+  const lines = [`# ${text(metadata.applicationName)} Documentation`, ""];
+  if (description) lines.push(`> ${text(description)}`, "");
+  if (source) {
+    for (const category of getDocsIndex(getSourceOptions(project, source))) {
+      const pages = category.pages.filter(
+        (page) => !isFallbackPage(project, source, page.sourcePath)
+      );
+      if (!pages.length) continue;
+      lines.push(`## ${text(category.title)}`, "");
+      for (const page of pages) {
+        const href = documentPath?.(source, page) ?? getDocsHref(project, source, page.slug);
+        lines.push(
+          `- [${text(page.title)}](<${publicUrl(project, getMarkdownHref(href))}>)${page.description ? `: ${text(page.description)}` : ""}`
+        );
+      }
+      lines.push("");
+    }
+  }
+  return response(lines.join("\n"), "text/plain");
+}
+function getMarkdownPaths(project, documentPath) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const source of getContentSources(project)) {
+    if (source.redirectTo !== void 0) continue;
+    for (const category of getDocsIndex(getSourceOptions(project, source))) {
+      for (const page of category.pages) {
+        if (isFallbackPage(project, source, page.sourcePath)) continue;
+        const href = documentPath?.(source, page) ?? getDocsHref(project, source, page.slug);
+        paths.add(`${href.slice(1)}.md`);
+      }
+    }
+  }
+  return [...paths].map((path) => ({
+    path: path.split("/").map(decodeURIComponent)
+  }));
+}
+function parseMarkdownPath(path) {
+  const last = path.at(-1);
+  return last?.endsWith(".md") && last.length > 3 ? [...path.slice(0, -1), last.slice(0, -3)] : void 0;
+}
+function getMarkdownResponse(project, path) {
+  const segments = parseMarkdownPath(path);
+  if (!segments) return markdownNotFound();
+  if (project.localization) {
+    const locale = segments.shift();
+    if (!project.localization.locales.some((entry) => entry.path === locale))
+      return markdownNotFound();
+    project = getLocalizedProject(project, locale);
+  }
+  if (segments.shift() !== "docs" || !segments.length) return markdownNotFound();
+  const edition = project.sources.find(
+    (source) => source.routePrefix && source.routePrefix === segments[0]
+  );
+  if (edition) segments.shift();
+  return getDocumentMarkdownResponse(
+    project,
+    edition ?? project.sources[0],
+    segments.join("/")
+  );
+}
+function markdownNotFound() {
+  return response(null, "text/markdown", 404);
+}
+function getDocumentMarkdownResponse(project, source, slug, documentPath) {
+  if (!source || !slug || source.redirectTo !== void 0)
+    return markdownNotFound();
+  const options = getSourceOptions(project, source);
+  const document = getDocument(slug, options);
+  if (!document || isFallbackPage(project, source, document.sourcePath))
+    return markdownNotFound();
+  const pages = getDocsIndex(options).flatMap((category) => category.pages);
+  const bySlug = new Map(pages.map((page2) => [page2.slug, page2]));
+  const href = (page2) => publicUrl(
+    project,
+    documentPath?.(source, page2) ?? getDocsHref(project, source, page2.slug)
+  );
+  const page = bySlug.get(document.slug);
+  const lastUpdated = source.version ? getSnapshotDocumentDate(options.docsDir, document.sourcePath) : createDocumentDateReader(project.rootDir)(document.sourcePath);
+  const frontmatter = {
+    title: page.title,
+    ...page.description ? { description: page.description } : {},
+    url: href(document),
+    docs_index: publicUrl(project, indexPath(project)),
+    ...lastUpdated ? { lastUpdated } : {}
+  };
+  const fields = Object.entries(frontmatter).map(
+    ([key, value]) => `${key}: ${JSON.stringify(value)}`
+  );
+  const body = exportMarkdownBody(document.content, {
+    sourceRoot: options.docsDir,
+    sourcePath: document.sourcePath,
+    virtualPaths: !!options.fallbackDocsDir,
+    documents: pages,
+    documentHref: (slug2) => href(bySlug.get(slug2))
+  });
+  return response(`---
+${fields.join("\n")}
+---
+
+${body}`, "text/markdown");
+}
+
 // src/runtime/index.tsx
 import {
   createRdxProject,
   getProjectDocsPaths,
-  getLocalizedProject as getLocalizedProject3
+  getLocalizedProject as getLocalizedProject4
 } from "@lexibase/rdx-core";
 
 // src/runtime/search.ts
 import {
-  getDocsIndex,
-  getDocument,
-  getSourceOptions,
-  getDocsHref
+  getDocsIndex as getDocsIndex2,
+  getDocument as getDocument2,
+  getSourceOptions as getSourceOptions2,
+  getDocsHref as getDocsHref2
 } from "@lexibase/rdx-core";
 import { buildSearchIndex } from "@lexibase/rdx-core/search";
 function getSearchSources(project) {
@@ -89,16 +243,16 @@ function getSearchResponse(project, key) {
   if (!source) return new Response(null, { status: 404, headers });
   if (source.fallbackOnly)
     return Response.json(buildSearchIndex([]), { headers });
-  const { docsDir } = getSourceOptions(project, source);
+  const { docsDir } = getSourceOptions2(project, source);
   const options = { docsDir };
-  const documents = getDocsIndex(options).flatMap(
+  const documents = getDocsIndex2(options).flatMap(
     (category) => category.pages.map((page) => ({
       title: page.title,
       description: page.description,
       category: category.title,
-      href: getDocsHref(project, source, page.slug),
+      href: getDocsHref2(project, source, page.slug),
       sourcePath: page.sourcePath,
-      content: getDocument(page.slug, options)?.content ?? ""
+      content: getDocument2(page.slug, options)?.content ?? ""
     }))
   );
   return Response.json(buildSearchIndex(documents), { headers });
@@ -106,10 +260,10 @@ function getSearchResponse(project, key) {
 
 // src/runtime/indexing.ts
 import {
-  getDocsIndex as getDocsIndex2,
-  getSourceOptions as getSourceOptions2,
-  getContentSources,
-  isFallbackPage
+  getDocsIndex as getDocsIndex3,
+  getSourceOptions as getSourceOptions3,
+  getContentSources as getContentSources2,
+  isFallbackPage as isFallbackPage2
 } from "@lexibase/rdx-core";
 function getSourceRobots(project, source) {
   const published = project.sources.some(
@@ -138,11 +292,11 @@ function getRdxSitemap(project, {
   if (!base) return [];
   const urls = /* @__PURE__ */ new Set();
   if (project.config.homepage?.enabled) urls.add(new URL("/", base).href);
-  for (const source of getContentSources(project)) {
+  for (const source of getContentSources2(project)) {
     if (!getSourceRobots(project, source).index) continue;
-    for (const category of getDocsIndex2(getSourceOptions2(project, source))) {
+    for (const category of getDocsIndex3(getSourceOptions3(project, source))) {
       for (const page of category.pages) {
-        if (isFallbackPage(project, source, page.sourcePath)) continue;
+        if (isFallbackPage2(project, source, page.sourcePath)) continue;
         urls.add(new URL(documentPath(source, page), base).href);
       }
     }
@@ -153,11 +307,11 @@ function getRdxSitemap(project, {
 // src/runtime/metadata.ts
 import {
   resolveDocsRoute,
-  getLocalizedProject,
-  getDocsHref as getDocsHref2,
-  isFallbackPage as isFallbackPage2,
-  getDocument as getDocument2,
-  getSourceOptions as getSourceOptions3
+  getLocalizedProject as getLocalizedProject2,
+  getDocsHref as getDocsHref3,
+  isFallbackPage as isFallbackPage3,
+  getDocument as getDocument3,
+  getSourceOptions as getSourceOptions4
 } from "@lexibase/rdx-core";
 import { notFound } from "next/navigation";
 function getDocumentMetadata({
@@ -172,24 +326,24 @@ function getDocumentMetadata({
   if (!route.slug) return { robots: { index: false, follow: true } };
   if (!route.document) notFound();
   const page = route.categories.flatMap((category) => category.pages).find((page2) => page2.slug === route.slug);
-  const fallback = isFallbackPage2(project, route.source, page.sourcePath);
+  const fallback = isFallbackPage3(project, route.source, page.sourcePath);
   const primary = project.localization?.locales.find(
     (locale) => locale.code === project.localization.defaultLocale
   );
-  const canonicalProject = fallback ? getLocalizedProject(project, primary.path) : project;
+  const canonicalProject = fallback ? getLocalizedProject2(project, primary.path) : project;
   const base = project.config.metadata.metadataBase;
   const languages = project.localization && base ? Object.fromEntries(
     project.localization.locales.flatMap((locale) => {
-      const view = getLocalizedProject(project, locale.path);
+      const view = getLocalizedProject2(project, locale.path);
       const source = view.sources.find(
         (entry) => entry.id === route.source.id
       );
-      return !source.fallbackOnly && getDocument2(page.slug, {
-        docsDir: getSourceOptions3(view, source).docsDir
+      return !source.fallbackOnly && getDocument3(page.slug, {
+        docsDir: getSourceOptions4(view, source).docsDir
       }) ? [
         [
           locale.code,
-          new URL(getDocsHref2(view, source, page.slug), base).href
+          new URL(getDocsHref3(view, source, page.slug), base).href
         ]
       ] : [];
     })
@@ -200,7 +354,7 @@ function getDocumentMetadata({
     ...project.localization && base ? {
       alternates: {
         canonical: new URL(
-          getDocsHref2(
+          getDocsHref3(
             canonicalProject,
             canonicalProject.sources.find(
               (entry) => entry.id === route.source.id
@@ -280,13 +434,13 @@ function RdxHeader({
   const messages = getMessages(config.lang);
   const { source, slug: currentSlug } = resolveDocsRoute2(project, slug);
   const options = project.sources.filter((edition) => edition.redirectTo === void 0).map((edition) => {
-    const docs = getSourceOptions4(project, edition);
-    const destination = currentSlug && getDocument3(currentSlug, docs) ? currentSlug : getDocsPaths(docs)[0];
+    const docs = getSourceOptions5(project, edition);
+    const destination = currentSlug && getDocument4(currentSlug, docs) ? currentSlug : getDocsPaths(docs)[0];
     return {
       id: edition.id,
       label: edition.id === "current" ? messages.current : formatMessage(messages.version, { version: edition.label }),
       kind: edition.id === "current" ? "live" : edition.badge === "Archived" ? "archived" : "version",
-      href: getDocsHref3(project, edition, destination)
+      href: getDocsHref4(project, edition, destination)
     };
   });
   return /* @__PURE__ */ jsx(
@@ -303,8 +457,8 @@ function RdxHeader({
       ) : void 0,
       siteTitle: config.metadata.applicationName,
       logo: /* @__PURE__ */ jsx(BrandLogo, { source: config.navbar?.logo, className: "size-5" }),
-      homeHref: config.homepage?.enabled ? "/" : getDocsHref3(project),
-      docsHref: getDocsHref3(project, source),
+      homeHref: config.homepage?.enabled ? "/" : getDocsHref4(project),
+      docsHref: getDocsHref4(project, source),
       languageMenu: project.localization ? /* @__PURE__ */ jsx(
         LanguageDropdown,
         {
@@ -322,7 +476,7 @@ function RdxHeader({
 }
 function HomePage({ project }) {
   const { config } = project;
-  if (!config.homepage?.enabled) redirect(getDocsHref3(project));
+  if (!config.homepage?.enabled) redirect(getDocsHref4(project));
   const homepage = config.homepage;
   const CustomHome = homepage.component;
   return /* @__PURE__ */ jsxs(Fragment, { children: [
@@ -381,7 +535,7 @@ async function DocsPage({
   project
 }) {
   if (project.localization && !project.locale)
-    permanentRedirect(getDocsHref3(project, project.sources[0], slug?.join("/")));
+    permanentRedirect(getDocsHref4(project, project.sources[0], slug?.join("/")));
   const messages = getMessages(project.config.lang);
   const {
     source,
@@ -391,7 +545,7 @@ async function DocsPage({
   } = resolveDocsRoute2(project, slug);
   if (source.redirectTo !== void 0)
     permanentRedirect(
-      getDocsHref3(
+      getDocsHref4(
         project,
         project.sources.find(
           (entry) => entry.routePrefix === source.redirectTo
@@ -408,15 +562,16 @@ async function DocsPage({
       ] })
     ] });
   if (!document) notFound2();
-  const fallback = isFallbackPage3(project, source, document.sourcePath);
+  const fallback = isFallbackPage4(project, source, document.sourcePath);
+  const editHref = fallback ? void 0 : getEditPageHref(project, source, document.sourcePath);
   const primaryLocale = (source.localization ?? project.localization)?.locales.find(
     (locale) => locale.code === project.localization.defaultLocale
   );
-  const originalProject = fallback && primaryLocale ? getLocalizedProject2(project, primaryLocale.path) : project;
+  const originalProject = fallback && primaryLocale ? getLocalizedProject3(project, primaryLocale.path) : project;
   const contentSource = originalProject.sources.find(
     (entry) => entry.id === source.id
   );
-  const contentOptions = getSourceOptions4(originalProject, contentSource);
+  const contentOptions = getSourceOptions5(originalProject, contentSource);
   const contentCategories = fallback ? resolveDocsRoute2(originalProject, slug).categories : categories;
   const contentLanguage = fallback ? primaryLocale.code : project.config.lang;
   const { content } = await compileDocumentation(
@@ -431,18 +586,20 @@ async function DocsPage({
       documents: contentCategories.flatMap((category2) => category2.pages)
     }
   );
-  const title = typeof document.frontmatter.title === "string" ? document.frontmatter.title : currentSlug;
   const description = typeof document.frontmatter.description === "string" ? document.frontmatter.description : null;
-  const hrefFor = (pageSlug) => getDocsHref3(project, source, pageSlug);
+  const hrefFor = (pageSlug) => getDocsHref4(project, source, pageSlug);
+  const markdownHref = fallback ? void 0 : getMarkdownHref(hrefFor(currentSlug));
   const sidebarCategories = categories.map((category2) => ({
     title: category2.title,
     links: category2.pages.map((page) => ({
-      label: page.title,
+      label: page.navTitle ?? page.title,
+      highlighting: page.highlighting,
       href: hrefFor(page.slug)
     }))
   }));
   const pages = categories.flatMap((category2) => category2.pages);
   const index = pages.findIndex((page) => page.slug === currentSlug);
+  const title = pages[index]?.title ?? currentSlug;
   const previous = pages[index - 1];
   const next = pages[index + 1];
   const category = categories.find(
@@ -500,7 +657,7 @@ async function DocsPage({
                                       Button,
                                       {
                                         variant: "link",
-                                        href: getDocsHref3(
+                                        href: getDocsHref4(
                                           originalProject,
                                           contentSource,
                                           currentSlug
@@ -534,14 +691,18 @@ async function DocsPage({
                             /* @__PURE__ */ jsxs("header", { className: "mb-6", children: [
                               source.badge && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground mb-4", children: source.badge === "Archived" ? messages.archivedVersion : source.badge }),
                               /* @__PURE__ */ jsx("span", { className: "text-xs text-zinc-600 font-semibold uppercase block -mb-0.5", children: category?.title }),
-                              /* @__PURE__ */ jsx("h1", { className: "text-4xl uppercase font-bold mb-2", children: title }),
-                              description && /* @__PURE__ */ jsx("p", { className: "text-sm text-ring max-w-[726px]", children: description })
+                              /* @__PURE__ */ jsxs("div", { className: "mb-2 flex flex-wrap items-start gap-x-4 gap-y-2", children: [
+                                /* @__PURE__ */ jsx("h1", { className: "min-w-0 max-w-full break-words text-4xl font-bold uppercase", children: title }),
+                                markdownHref && /* @__PURE__ */ jsx(CopyPage, { href: markdownHref }, markdownHref)
+                              ] }),
+                              description && /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground max-w-[726px]", children: description })
                             ] }),
                             /* @__PURE__ */ jsx("div", { className: "h-full w-full flex-1 max-w-[960px]", children: content })
                           ]
                         }
                       ),
                       /* @__PURE__ */ jsxs("footer", { className: "flex flex-col", children: [
+                        editHref && /* @__PURE__ */ jsx(EditPageLink, { href: editHref, lang: project.config.lang }),
                         /* @__PURE__ */ jsxs("section", { className: "flex items-center justify-between", children: [
                           previous ? /* @__PURE__ */ jsx(
                             Button,
@@ -590,8 +751,13 @@ export {
   NotFoundPage,
   RdxLayout,
   createRdxProject,
+  getDocumentMarkdownResponse,
   getDocumentMetadata,
-  getLocalizedProject3 as getLocalizedProject,
+  getLlmIndexResponse,
+  getLocalizedProject4 as getLocalizedProject,
+  getMarkdownHref,
+  getMarkdownPaths,
+  getMarkdownResponse,
   getPageMetadata,
   getProjectDocsPaths,
   getRdxMetadata,
@@ -599,5 +765,7 @@ export {
   getRdxSitemap,
   getSearchResponse,
   getSearchSources,
-  getSourceRobots
+  getSourceRobots,
+  markdownNotFound,
+  parseMarkdownPath
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lexibase/rdx-next",
-  "version": "4.2.0",
+  "version": "5.0.1",
   "description": "The Next.js runtime for RDX documentation projects.",
   "license": "MIT",
   "type": "module",
@@ -52,11 +52,11 @@
     "next-mdx-remote": "^6.0.0",
     "remark-gfm": "^4",
     "typescript": "6.0.3",
-    "@lexibase/rdx-types": "2.2.0",
-    "@lexibase/rdx-core": "2.2.0"
+    "@lexibase/rdx-core": "3.0.1",
+    "@lexibase/rdx-types": "2.3.0"
   },
   "peerDependencies": {
-    "@lexibase/rdx-ui": "^3.4.0",
+    "@lexibase/rdx-ui": "^3.5.0",
     "next": "^16.4.2",
     "react": "^19.3.1",
     "react-dom": "^19.3.1"
@@ -81,9 +81,9 @@
     "next": "^16.4.2",
     "react": "19.3.1",
     "react-dom": "19.3.1",
-    "@rdx/typescript-config": "1.0.0",
+    "@lexibase/rdx-ui": "3.5.1",
     "@rdx/eslint-config": "1.0.0",
-    "@lexibase/rdx-ui": "3.4.0"
+    "@rdx/typescript-config": "1.0.0"
   },
   "scripts": {
     "dev": "tsup src/index.ts src/runtime/index.tsx --format esm --dts --watch --external @lexibase/rdx-core --external @lexibase/rdx-types --external @lexibase/rdx-ui --external next --external react --external react-dom --external next-mdx-remote",

package/templates/runtime/app/docs/llms.txt/route.ts

@@ -0,0 +1,8 @@
+import { getLlmIndexResponse } from '@lexibase/rdx-next/runtime'
+import { getProject } from '../../../rdx-project'
+
+export const dynamic = 'force-static'
+
+export async function GET() {
+  return getLlmIndexResponse(await getProject())
+}

package/templates/runtime/app/rdx-markdown/[...path]/route.ts

@@ -0,0 +1,19 @@
+import {
+  getMarkdownPaths,
+  getMarkdownResponse,
+} from '@lexibase/rdx-next/runtime'
+import { getProject } from '../../../rdx-project'
+
+export const dynamic = 'force-static'
+export const dynamicParams = false
+
+export async function generateStaticParams() {
+  return getMarkdownPaths(await getProject())
+}
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  return getMarkdownResponse(await getProject(), (await params).path)
+}