@publish.os/nextjs 0.0.1-alpha.81 → 0.0.1-alpha.91

package/dist/kernel/routes/agent/markdown.js

@@ -34,12 +34,196 @@ function createCachedTextResponse(options) {
   });
 }
 
+// src/route-not-found.ts
+var MAX_PATH_LENGTH = 2048, UNSAFE_PATH_CHARACTERS = /[\p{Cc}\p{Cs}\u200b-\u200f\u2028-\u202f\u2060-\u206f\ufeff]/u, INTERNAL_PATHS = ["/__publishos", "/_next", "/_not-found", "/publishos"], DEFAULT_MARKDOWN = serializeNotFoundMarkdown({
+  recommendations: [],
+  indexes: []
+});
+function normalizePublicPath(pathname) {
+  let path = pathname.split(/[?#]/u, 1)[0];
+  if (!path?.startsWith("/") || path.startsWith("//") || path.length > MAX_PATH_LENGTH || UNSAFE_PATH_CHARACTERS.test(path))
+    return;
+  let segments = [];
+  for (let segment of path.split("/")) {
+    if (!segment) continue;
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      return;
+    }
+    if (decoded === "." || decoded === ".." || /[/\\]/u.test(decoded) || /%[\da-f]{2}/iu.test(decoded) || UNSAFE_PATH_CHARACTERS.test(decoded))
+      return;
+    segments.push(decoded);
+  }
+  return `/${segments.join("/")}`;
+}
+function containsPath({ parent, path }) {
+  return parent === "/" || path === parent || path.startsWith(`${parent}/`);
+}
+function missingPagePath(pathname) {
+  let normalized = normalizePublicPath(pathname);
+  if (!normalized) return;
+  let path = normalized.endsWith(".md") ? normalized.slice(0, -3) || "/" : normalized;
+  return INTERNAL_PATHS.some((parent) => containsPath({ parent, path })) ? void 0 : path;
+}
+function resolveNotFoundScope({
+  scopes,
+  pathname
+}) {
+  let path = missingPagePath(pathname);
+  if (!path) return;
+  let matched, matchedLength = -1;
+  for (let scope of scopes) {
+    let scopePath = normalizePublicPath(scope.path);
+    !scopePath || !containsPath({ parent: scopePath, path }) || (scopePath.length > matchedLength || scopePath.length === matchedLength && scope.group && !matched?.group) && (matched = scope, matchedLength = scopePath.length);
+  }
+  return matched;
+}
+function trustedHostname(origin) {
+  if (origin)
+    try {
+      let url = new URL(origin);
+      return !["http:", "https:"].includes(url.protocol) || url.username || url.password ? void 0 : url.host.replace(/`/gu, "%60");
+    } catch {
+      return;
+    }
+}
+function requestExplanation({
+  pathname,
+  origin
+}) {
+  let path = pathname.split("/").map(encodeURIComponent).join("/"), hostname = trustedHostname(origin);
+  return `No page exists at \`${path}\`${hostname ? ` on ${hostname}` : ""}.`;
+}
+function indexKind(link) {
+  if (link.kind) return link.kind;
+  switch (link.title) {
+    case "Sitemap":
+      return "sitemap";
+    case "Markdown sitemap":
+      return "sitemap-md";
+    case "llms.txt":
+    case "LLMS index":
+      return "llms";
+    case "llms-full.txt":
+      return "llms-full";
+    default:
+      return;
+  }
+}
+function publicRecoveryHref(href) {
+  if (href.includes("\\") || UNSAFE_PATH_CHARACTERS.test(href))
+    return;
+  let relative = href.startsWith("/") && !href.startsWith("//");
+  try {
+    let url = new URL(
+      href,
+      relative ? "https://publishos.invalid" : void 0
+    );
+    return !["http:", "https:"].includes(url.protocol) || url.username || url.password ? void 0 : relative ? `${url.pathname}${url.search}${url.hash}` : url.href;
+  } catch {
+    return;
+  }
+}
+function markdownText(value) {
+  return value.replace(/\s+/gu, " ").replace(/[\p{Cc}\p{Cs}]/gu, "").trim().replace(/[\\`*_[\]{}<>|~]/gu, "\\$&");
+}
+function markdownLink(link) {
+  let title = markdownText(link.title), href = publicRecoveryHref(link.href)?.replace(
+    /[()`<>]/gu,
+    (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`
+  );
+  if (!title || !href) return;
+  let description = link.description ? markdownText(link.description) : void 0;
+  return `- [${title}](${href})${description ? `: ${description}` : ""}`;
+}
+function serializeNotFoundMarkdown({
+  recommendations,
+  indexes
+}) {
+  let sections = [
+    { title: "Recommendations", links: recommendations },
+    { title: "For crawlers and agents", links: indexes }
+  ], lines = [
+    "# 404 \u2014 Not Found",
+    "",
+    "This page does not exist. Please check the URL and try again.",
+    ""
+  ];
+  for (let section of sections) {
+    let links = section.links.map(markdownLink).filter((link) => link !== void 0);
+    links.length && lines.push(`## ${section.title}`, "", ...links, "");
+  }
+  return lines.join(`
+`);
+}
+function discoveryHeaders(scope) {
+  let headers = new Headers(), links = [];
+  for (let link of scope?.indexes ?? []) {
+    let kind = indexKind(link), href = /[\s<>"\\]/u.test(link.href) ? void 0 : publicRecoveryHref(link.href);
+    if (!(!kind || !href))
+      switch (kind) {
+        case "llms":
+          if (scope?.describedBy !== void 0) break;
+          links.push(`<${href}>; rel="describedby"; type="text/plain"`), headers.set("x-publishos-llms", href);
+          break;
+        case "llms-full":
+          links.push(
+            `<${href}>; rel="related"; type="text/plain"; title="Full content"`
+          );
+          break;
+        case "sitemap":
+        case "sitemap-md":
+          links.push(
+            `<${href}>; rel="sitemap"; type="${kind === "sitemap-md" ? "text/markdown" : "application/xml"}"`
+          ), headers.set("x-publishos-sitemap", href);
+          break;
+      }
+  }
+  if (scope?.describedBy !== void 0) {
+    let href = /[\s<>"\\]/u.test(scope.describedBy) ? void 0 : publicRecoveryHref(scope.describedBy);
+    href && (links.push(`<${href}>; rel="describedby"; type="text/plain"`), headers.set("x-publishos-llms", href));
+  }
+  return links.length && headers.set("link", links.join(", ")), headers;
+}
+function createNotFoundTextResponse({
+  scope,
+  pathname,
+  method,
+  contentType = "text/markdown; charset=utf-8",
+  vary = !1
+}) {
+  let path = pathname === void 0 ? void 0 : missingPagePath(pathname), resolvedScope = scope && (pathname === void 0 || resolveNotFoundScope({ scopes: [scope], pathname })) ? scope : void 0, body = resolvedScope?.markdown ?? DEFAULT_MARKDOWN;
+  if (resolvedScope && path) {
+    let explanation = requestExplanation({
+      pathname: path,
+      origin: scope?.origin
+    }), headingEnd = body.indexOf(`
+
+`);
+    body = headingEnd === -1 ? `${body}
+
+${explanation}
+` : `${body.slice(0, headingEnd)}
+
+${explanation}
+
+${body.slice(headingEnd + 2)}`;
+  }
+  let headers = discoveryHeaders(resolvedScope);
+  return vary && headers.set("vary", "Accept, User-Agent"), createCachedTextResponse({
+    body,
+    cachePolicy: "short",
+    contentType,
+    headers,
+    method,
+    noindex: !0,
+    status: 404
+  });
+}
+
 // src/route-agent-markdown.ts
-var DEFAULT_DISCOVERY_LINKS = {
-  home: "/",
-  llms: "/llms.txt",
-  sitemap: "/sitemap.md"
-};
 function debugMarkdownResponse(details) {
   log.debug("[agent-route]", "md-response", details);
 }
@@ -62,56 +246,28 @@ function markdownHeaders(artifact) {
     contentType: "text/markdown; charset=utf-8"
   };
 }
-function markdown404Body(discoveryLinks) {
-  return [
-    "# Not found",
-    "",
-    ...[
-      discoveryLinks.home ? `> Home: ${discoveryLinks.home}` : void 0,
-      discoveryLinks.sitemap ? `> Sitemap: ${discoveryLinks.sitemap}` : void 0,
-      discoveryLinks.llms ? `> LLMS index: ${discoveryLinks.llms}` : void 0
-    ].filter((line) => !!line),
-    "",
-    "The requested Markdown page was not found.",
-    ""
-  ].join(`
-`);
-}
-function notFoundResponse(method, discoveryLinks, artifactPath, reason) {
+function notFoundResponse(method, scopes, artifactPath, reason) {
   return debugMarkdownResponse({
     artifactPath,
     method,
     reason,
     status: 404
-  }), createCachedTextResponse({
-    body: markdown404Body(discoveryLinks),
-    cachePolicy: "short",
-    contentType: "text/markdown; charset=utf-8",
-    method,
-    noindex: !0,
-    status: 404
+  }), createNotFoundTextResponse({
+    scope: artifactPath ? resolveNotFoundScope({ scopes, pathname: artifactPath }) : void 0,
+    pathname: artifactPath,
+    method
   });
 }
-async function markdownResponse(artifacts, discoveryLinks, method, context) {
+async function markdownResponse(artifacts, scopes, method, context) {
   let params = await Promise.resolve(context.params), artifactPath = normalizeArtifactPath(params?.path);
   if (!artifactPath)
-    return notFoundResponse(method, discoveryLinks, void 0, "invalid-path");
+    return notFoundResponse(method, scopes, void 0, "invalid-path");
   let artifactKey = findArtifactKey(artifacts.index, artifactPath);
   if (!artifactKey)
-    return notFoundResponse(
-      method,
-      discoveryLinks,
-      artifactPath,
-      "missing-index"
-    );
+    return notFoundResponse(method, scopes, artifactPath, "missing-index");
   let artifact = await artifacts.loadArtifact(artifactKey);
   if (!artifact)
-    return notFoundResponse(
-      method,
-      discoveryLinks,
-      artifactPath,
-      "missing-shard"
-    );
+    return notFoundResponse(method, scopes, artifactPath, "missing-shard");
   let { contentType, headers } = markdownHeaders(artifact);
   return debugMarkdownResponse({
     artifactPath: artifact.markdownPath,
@@ -127,13 +283,28 @@ async function markdownResponse(artifacts, discoveryLinks, method, context) {
   });
 }
 function createMarkdownRouteHandlers(artifacts, options = {}) {
-  let discoveryLinks = {
-    ...DEFAULT_DISCOVERY_LINKS,
-    ...options.discoveryLinks
-  };
+  let links = options.discoveryLinks, recommendations = links?.home ? [{ title: "Go home", href: links.home }] : [], indexes = [
+    ...links?.sitemap ? [
+      {
+        title: "Markdown sitemap",
+        href: links.sitemap,
+        kind: "sitemap-md"
+      }
+    ] : [],
+    ...links?.llms ? [{ title: "llms.txt", href: links.llms, kind: "llms" }] : []
+  ], scopes = options.notFoundScopes ?? (links ? [
+    {
+      id: "root",
+      path: "/",
+      htmlPath: "",
+      recommendations,
+      indexes,
+      markdown: serializeNotFoundMarkdown({ recommendations, indexes })
+    }
+  ] : []);
   return {
-    GET: (_request, context) => markdownResponse(artifacts, discoveryLinks, "GET", context),
-    HEAD: (_request, context) => markdownResponse(artifacts, discoveryLinks, "HEAD", context),
+    GET: (_request, context) => markdownResponse(artifacts, scopes, "GET", context),
+    HEAD: (_request, context) => markdownResponse(artifacts, scopes, "HEAD", context),
     generateStaticParams: () => Object.keys(artifacts.index).map((artifactPath) => ({
       path: artifactPath.replace(/^\//, "").replace(/\.md$/, "").split("/")
     }))

package/dist/kernel/routes/layouts/group.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
 import { ReactElement, ReactNode } from 'react';
-import { M as ManifestLike, L as LayoutProps } from '../../../types-CIwwieNw.js';
+import { M as ManifestLike, L as LayoutProps } from '../../../types-J2w_puPF.js';
 
 type LayoutComponent = (props: LayoutProps) => ReactElement | Promise<ReactElement>;
 type GroupLayoutConfig = {

package/dist/kernel/routes/layouts/group.js

@@ -21,8 +21,8 @@ var isDev = process.env.NODE_ENV !== "production", isDebugEnabled = process.env.
 };
 
 // src/route-layout-group.tsx
-import { jsx } from "react/jsx-runtime";
-var manifests = /* @__PURE__ */ new Map(), layoutChains = /* @__PURE__ */ new Map();
+import { jsx } from "@publish.os/nextjs/jsx-runtime";
+var manifests = /* @__PURE__ */ new Map();
 async function CachedGroupLayoutData({
   routeGroup,
   layoutGroup
@@ -39,12 +39,10 @@ function createGroupLayout({
   manifest,
   layouts
 }) {
-  return manifests.set(group, manifest), layoutChains.set(group, layouts), async function({ children }) {
-    log.debug("[render]", `${group}/layout`);
-    let chain = layoutChains.get(group);
-    chain?.length || notFound();
+  return manifests.set(group, manifest), async function({ children }) {
+    log.debug("[render]", `${group}/layout`), layouts.length || notFound();
     let resolvedLayouts = await Promise.all(
-      chain.map(async (item) => ({
+      layouts.map(async (item) => ({
         item,
         props: await CachedGroupLayoutData({
           layoutGroup: item.group,

package/dist/kernel/routes/metadata/feed.d.ts

@@ -1,4 +1,4 @@
-import { P as PageStatus, M as ManifestLike } from '../../../types-CIwwieNw.js';
+import { P as PageStatus, M as ManifestLike } from '../../../types-J2w_puPF.js';
 
 type FeedScope = "site" | "group" | "self";
 type FeedRouteOptions = {

package/dist/kernel/routes/metadata/feed.js

@@ -3,8 +3,8 @@ import { tags } from "@publish.os/nextjs/cache/tags";
 import { cacheLife, cacheTag } from "next/cache";
 
 // src/lib/runtime/metadata/canonical-url.ts
-function canonicalUrl(manifest, path) {
-  let origin = manifest.site.url?.replace(/\/+$/, "");
+function canonicalUrl(manifest, path, group) {
+  let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
   if (!origin) return path;
   try {
     return new URL(path, `${origin}/`).toString();
@@ -13,6 +13,90 @@ function canonicalUrl(manifest, path) {
   }
 }
 
+// src/lib/runtime/metadata/feed-serialization.ts
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function latestDate(pages) {
+  let timestamp = Math.max(
+    0,
+    ...pages.map((page) => {
+      let date = page.publishedAt ?? page.updatedAt;
+      if (!date) return -1 / 0;
+      let parsed = Date.parse(date);
+      return Number.isNaN(parsed) ? -1 / 0 : parsed;
+    })
+  );
+  return new Date(timestamp).toISOString();
+}
+function serializeRssFeed(input) {
+  let description = input.description ?? input.title, items = input.pages.map((page) => {
+    let publishedAt = page.publishedAt, pubDate = publishedAt ? `
+      <pubDate>${xmlEscape(new Date(publishedAt).toUTCString())}</pubDate>` : "", itemDescription = page.description ? `
+      <description>${xmlEscape(page.description)}</description>` : "";
+    return `    <item>
+      <title>${xmlEscape(page.title)}</title>
+      <link>${xmlEscape(page.url)}</link>
+      <guid>${xmlEscape(page.url)}</guid>${pubDate}${itemDescription}
+    </item>`;
+  }).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0">
+  <channel>
+    <title>${xmlEscape(input.title)}</title>
+    <link>${xmlEscape(input.homeUrl)}</link>
+    <description>${xmlEscape(description)}</description>
+${items}
+  </channel>
+</rss>
+`;
+}
+function serializeAtomFeed(input) {
+  let entries = input.pages.map((page) => {
+    let date = page.publishedAt ?? page.updatedAt, updated = date ? new Date(date).toISOString() : latestDate([]), summary = page.description ? `
+    <summary>${xmlEscape(page.description)}</summary>` : "";
+    return `  <entry>
+    <title>${xmlEscape(page.title)}</title>
+    <id>${xmlEscape(page.url)}</id>
+    <link href="${xmlEscape(page.url)}" />
+    <updated>${xmlEscape(updated)}</updated>${summary}
+  </entry>`;
+  }).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${xmlEscape(input.title)}</title>
+  <id>${xmlEscape(input.homeUrl)}</id>
+  <updated>${xmlEscape(latestDate(input.pages))}</updated>
+${entries}
+</feed>
+`;
+}
+function serializeJsonFeed(input) {
+  return `${JSON.stringify(
+    {
+      version: "https://jsonfeed.org/version/1.1",
+      title: input.title,
+      description: input.description,
+      home_page_url: input.homeUrl,
+      items: input.pages.map((page) => ({
+        id: page.url,
+        url: page.url,
+        title: page.title,
+        summary: page.description,
+        content_text: page.body,
+        date_published: page.publishedAt,
+        date_modified: page.updatedAt,
+        tags: page.tags
+      }))
+    },
+    null,
+    2
+  )}
+`;
+}
+
 // src/lib/runtime/response/cached-text-response.ts
 var CACHE_CONTROL = "public, max-age=300, s-maxage=3600, stale-while-revalidate=3600, must-revalidate", CDN_CACHE_CONTROL = "public, max-age=3600, stale-while-revalidate=3600, must-revalidate", SHORT_CACHE_CONTROL = "public, max-age=60, s-maxage=600, stale-while-revalidate=300, must-revalidate", SHORT_CDN_CACHE_CONTROL = "public, max-age=300, stale-while-revalidate=3600";
 function cacheControl(policy) {
@@ -34,11 +118,8 @@ function createCachedTextResponse(options) {
 }
 
 // src/route-metadata-feed.ts
-function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
 function pageTimestamp(page) {
-  let value = pageDate(page);
+  let value = validDate(page.publishedAt) ?? validDate(page.updatedAt);
   return value ? Date.parse(value) : -1 / 0;
 }
 function validDate(value) {
@@ -51,98 +132,47 @@ function feedPages(manifest, options) {
   let statuses = options.status ?? ["published"], pages = manifest.pages.filter((page) => statuses.includes(page.status)).filter((page) => pageInScope(page, options)).sort((a, b) => pageTimestamp(b) - pageTimestamp(a));
   return options.limit ? pages.slice(0, options.limit) : pages;
 }
+function feedInput(manifest, options = {}) {
+  let serializedPages = feedPages(manifest, options).map((page) => ({
+    url: canonicalUrl(manifest, page.path, page.group),
+    title: page.title,
+    publishedAt: validDate(page.publishedAt),
+    updatedAt: validDate(page.updatedAt),
+    description: page.description,
+    body: page.body,
+    tags: page.tags
+  })), group = options.group, homePath = group ? manifest.groups[group]?.path ?? "/" : "/";
+  return {
+    // Public route factories use the site name; generated group feeds use the group title.
+    title: manifest.site.name,
+    description: manifest.site.description,
+    homeUrl: canonicalUrl(manifest, homePath, group),
+    pages: serializedPages
+  };
+}
 async function rssXml(manifest, options = {}) {
   "use cache";
-  cacheLife("page"), cacheTag(
+  return cacheLife("page"), cacheTag(
     tags.site(),
     tags.feed("rss", options.group ?? options.scope ?? "site"),
     tags.manifest(manifest.contentHash)
-  );
-  let title = manifest.site.name, description = manifest.site.description ?? title, pages = feedPages(manifest, options), homeUrl = canonicalUrl(manifest, "/"), items = pages.map((page) => {
-    let pageUrl = canonicalUrl(manifest, page.path), publishedAt = validDate(page.publishedAt), pubDate = publishedAt ? `
-      <pubDate>${xmlEscape(new Date(publishedAt).toUTCString())}</pubDate>` : "", description2 = page.description ? `
-      <description>${xmlEscape(page.description)}</description>` : "";
-    return `    <item>
-      <title>${xmlEscape(page.title)}</title>
-      <link>${xmlEscape(pageUrl)}</link>
-      <guid>${xmlEscape(pageUrl)}</guid>${pubDate}${description2}
-    </item>`;
-  }).join(`
-`);
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<rss version="2.0">
-  <channel>
-    <title>${xmlEscape(title)}</title>
-    <link>${xmlEscape(homeUrl)}</link>
-    <description>${xmlEscape(description)}</description>
-${items}
-  </channel>
-</rss>
-`;
-}
-function pageDate(page) {
-  return validDate(page.publishedAt) ?? validDate(page.updatedAt);
-}
-function latestFeedDate(pages) {
-  let timestamp = Math.max(0, ...pages.map((page) => pageTimestamp(page)));
-  return new Date(timestamp).toISOString();
+  ), serializeRssFeed(feedInput(manifest, options));
 }
 async function atomXml(manifest, options = {}) {
   "use cache";
-  cacheLife("page"), cacheTag(
+  return cacheLife("page"), cacheTag(
     tags.site(),
     tags.feed("atom", options.group ?? options.scope ?? "site"),
     tags.manifest(manifest.contentHash)
-  );
-  let title = manifest.site.name, pages = feedPages(manifest, options), homeUrl = canonicalUrl(manifest, "/"), entries = pages.map((page) => {
-    let date = pageDate(page), updated = date ? new Date(date).toISOString() : latestFeedDate([]), pageUrl = canonicalUrl(manifest, page.path), summary = page.description ? `
-    <summary>${xmlEscape(page.description)}</summary>` : "";
-    return `  <entry>
-    <title>${xmlEscape(page.title)}</title>
-    <id>${xmlEscape(pageUrl)}</id>
-    <link href="${xmlEscape(pageUrl)}" />
-    <updated>${xmlEscape(updated)}</updated>${summary}
-  </entry>`;
-  }).join(`
-`);
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<feed xmlns="http://www.w3.org/2005/Atom">
-  <title>${xmlEscape(title)}</title>
-  <id>${xmlEscape(homeUrl)}</id>
-  <updated>${xmlEscape(latestFeedDate(pages))}</updated>
-${entries}
-</feed>
-`;
+  ), serializeAtomFeed(feedInput(manifest, options));
 }
 async function jsonFeed(manifest, options = {}) {
   "use cache";
-  cacheLife("page"), cacheTag(
+  return cacheLife("page"), cacheTag(
     tags.site(),
     tags.feed("json", options.group ?? options.scope ?? "site"),
     tags.manifest(manifest.contentHash)
-  );
-  let pages = feedPages(manifest, options);
-  return `${JSON.stringify(
-    {
-      version: "https://jsonfeed.org/version/1.1",
-      title: manifest.site.name,
-      description: manifest.site.description,
-      home_page_url: canonicalUrl(manifest, "/"),
-      items: pages.map((page) => ({
-        id: canonicalUrl(manifest, page.path),
-        url: canonicalUrl(manifest, page.path),
-        title: page.title,
-        summary: page.description,
-        content_text: page.body,
-        date_published: validDate(page.publishedAt),
-        date_modified: validDate(page.updatedAt),
-        tags: page.tags
-      }))
-    },
-    null,
-    2
-  )}
-`;
+  ), serializeJsonFeed(feedInput(manifest, options));
 }
 function createRssFeedRoute(manifest, options = {}) {
   return async function() {

package/dist/kernel/routes/metadata/llms.d.ts

@@ -1,5 +1,6 @@
-import { MarkdownRouteArtifacts } from '../agent/markdown.js';
-import { M as ManifestLike } from '../../../types-CIwwieNw.js';
+import { MarkdownRouteArtifacts, MarkdownRouteArtifactManifest } from '../agent/markdown.js';
+import { M as ManifestLike } from '../../../types-J2w_puPF.js';
+import '../not-found.js';
 
 type LlmsRouteOptions = {
     scope?: "site" | "group" | "self";
@@ -9,15 +10,23 @@ type LlmsRouteOptions = {
     links?: Array<{
         title: string;
         path: string;
+        group?: string;
+    }>;
+    otherGroupLinks?: Array<{
+        title: string;
+        path: string;
+        group?: string;
     }>;
 };
 type LlmsFullRouteOptions = {
     maxBytes?: number;
+    indexPath?: string | false;
+    sitemapPath?: string | false;
 };
 type PrecomputedLlmsTxtOutput = {
     body: string;
 };
-declare function createLlmsTxtRoute(manifest: ManifestLike, options?: LlmsRouteOptions): () => Promise<Response>;
+declare function createLlmsTxtRoute(manifest: ManifestLike, options?: LlmsRouteOptions, artifactManifest?: MarkdownRouteArtifactManifest): () => Promise<Response>;
 declare function createPrecomputedLlmsTxtRoute(output: PrecomputedLlmsTxtOutput): () => Response;
 declare function llmsFullTxtResponse(manifest: ManifestLike, artifacts: MarkdownRouteArtifacts, options?: LlmsFullRouteOptions): Promise<Response>;
 declare function createLlmsFullTxtRoute(manifest: ManifestLike, artifacts: MarkdownRouteArtifacts, options?: LlmsFullRouteOptions): () => Promise<Response>;