@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.92

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

@@ -1,18 +1,3 @@
-// src/route-metadata-llms.ts
-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, group) {
-  let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
-  try {
-    return new URL(path, `${origin}/`).toString();
-  } catch {
-    return path;
-  }
-}
-
 // 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,53 +19,7 @@ function createCachedTextResponse(options) {
 }
 
 // src/route-metadata-llms.ts
-var DEFAULT_LLMS_FULL_MAX_BYTES = 1e6, TEXT_ENCODER = new TextEncoder();
-function byteLength(value) {
-  return TEXT_ENCODER.encode(value).byteLength;
-}
-function pageInScope(page, options) {
-  return options.scope === "site" || !options.group ? !0 : options.scope === "self" ? page.group === options.group : page.group === options.group || page.group.startsWith(`${options.group}/`);
-}
-function llmsSummary(manifest) {
-  return manifest.site.description ? `> ${manifest.site.description}` : `> Agent-readable index for ${manifest.site.name}.`;
-}
-async function llmsTxt(manifest, options = {}) {
-  "use cache";
-  cacheLife("page"), cacheTag(
-    tags.site(),
-    tags.llms(options.group ?? options.scope ?? "root"),
-    tags.manifest(manifest.contentHash)
-  );
-  let pages = manifest.pages.filter((page) => page.status === "published").filter((page) => pageInScope(page, options)), lines = (options.limit ? pages.slice(0, options.limit) : pages).map((page) => {
-    let description = options.includeDescriptions && page.description ? ` - ${page.description}` : "";
-    return `- [${page.title}](${canonicalUrl(manifest, page.path, page.group)})${description}`;
-  }), linkLines = (options.links ?? []).map(
-    (link) => `- [${link.title}](${canonicalUrl(manifest, link.path, link.group)})`
-  ), linkSection = linkLines.length ? `
-
-## Group LLM indexes
-
-${linkLines.join(`
-`)}` : "";
-  return `# ${manifest.site.name}
-
-${llmsSummary(manifest)}
-
-## Pages
-
-${lines.join(`
-`)}${linkSection}
-`;
-}
-function createLlmsTxtRoute(manifest, options = {}) {
-  return async function() {
-    return createCachedTextResponse({
-      body: await llmsTxt(manifest, options),
-      contentType: "text/plain; charset=utf-8"
-    });
-  };
-}
-function createPrecomputedLlmsTxtRoute(output) {
+function createLlmsTxtRoute(output) {
   return function() {
     return createCachedTextResponse({
       body: output.body,
@@ -88,46 +27,6 @@ function createPrecomputedLlmsTxtRoute(output) {
     });
   };
 }
-async function llmsFullTxt(manifest, artifacts, options = {}) {
-  let maxBytes = options.maxBytes ?? DEFAULT_LLMS_FULL_MAX_BYTES, header = `# ${manifest.site.name} Full Content
-
-> LLMS index: ${canonicalUrl(manifest, "/llms.txt")}
-> Sitemap: ${canonicalUrl(manifest, "/sitemap.md")}
-
-`, sections = [], totalBytes = byteLength(header), included = 0, truncated = !1;
-  for (let artifact of Object.values(artifacts).sort(
-    (a, b) => a.markdownPath.localeCompare(b.markdownPath)
-  )) {
-    let section = `---
-
-${artifact.body.trim()}
-
-`, sectionBytes = byteLength(section);
-    if (totalBytes + sectionBytes > maxBytes) {
-      truncated = !0;
-      break;
-    }
-    sections.push(section), totalBytes += sectionBytes, included += 1;
-  }
-  let footer = truncated ? `
-> Truncated at ${included} of ${Object.keys(artifacts).length} Markdown pages to stay under ${maxBytes} bytes.
-` : "";
-  return `${header}${sections.join("")}${footer}`;
-}
-async function llmsFullTxtResponse(manifest, artifacts, options = {}) {
-  return createCachedTextResponse({
-    body: await llmsFullTxt(manifest, artifacts, options),
-    contentType: "text/plain; charset=utf-8"
-  });
-}
-function createLlmsFullTxtRoute(manifest, artifacts, options = {}) {
-  return async function() {
-    return llmsFullTxtResponse(manifest, artifacts, options);
-  };
-}
 export {
-  createLlmsFullTxtRoute,
-  createLlmsTxtRoute,
-  createPrecomputedLlmsTxtRoute,
-  llmsFullTxtResponse
+  createLlmsTxtRoute
 };

package/dist/kernel/routes/metadata/og-image.js

@@ -116,7 +116,7 @@ function getOgImageText(entry) {
 }
 
 // src/route-metadata-og-image.tsx
-import { jsx, jsxs } from "react/jsx-runtime";
+import { jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
 var ERROR_HEADERS = {
   "cache-control": "public, max-age=60, must-revalidate",
   "cdn-cache-control": "public, max-age=300",

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

@@ -1,5 +1,7 @@
-import { M as ManifestLike } from '../../../types-BzkZty3r.js';
-
-declare function createRobotsTxtRoute(manifest: ManifestLike): () => Promise<Response>;
+declare function createRobotsTxtRoute(defaultOutput: {
+    body: string;
+}, outputsByOrigin?: Record<string, {
+    body: string;
+}>): (request: Request) => Response;
 
 export { createRobotsTxtRoute };

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

@@ -1,18 +1,3 @@
-// src/route-metadata-robots.ts
-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, group) {
-  let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
-  try {
-    return new URL(path, `${origin}/`).toString();
-  } catch {
-    return path;
-  }
-}
-
 // 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,17 +19,11 @@ function createCachedTextResponse(options) {
 }
 
 // src/route-metadata-robots.ts
-async function robotsTxt(manifest) {
-  "use cache";
-  return cacheLife("page"), cacheTag(tags.site(), tags.robots(), tags.manifest(manifest.contentHash)), `User-agent: *
-Allow: /
-Sitemap: ${canonicalUrl(manifest, "/sitemap.xml")}
-`;
-}
-function createRobotsTxtRoute(manifest) {
-  return async function() {
+function createRobotsTxtRoute(defaultOutput, outputsByOrigin = {}) {
+  return function(request) {
+    let output = outputsByOrigin[new URL(request.url).origin] ?? defaultOutput;
     return createCachedTextResponse({
-      body: await robotsTxt(manifest),
+      body: output.body,
       contentType: "text/plain; charset=utf-8"
     });
   };

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

@@ -1,10 +1,43 @@
 import { MarkdownRouteArtifactManifest } from '../agent/markdown.js';
-import { M as ManifestLike } from '../../../types-BzkZty3r.js';
+import { M as ManifestLike } from '../../../types-BbqmOzLC.js';
+import '../not-found.js';
 
+type SitemapReference = {
+    path: string;
+    group?: string;
+};
 type SitemapRouteOptions = {
     group?: string;
+    path?: string;
+    includeUrls?: SitemapReference[];
+    sitemaps?: SitemapReference[];
+    exclude?: SitemapReference[];
+};
+type SitemapMarkdownRouteOptions = {
+    group?: string;
+    path?: string;
+    scope?: "site" | "group" | "self";
+    excludeGroups?: string[];
+    includeUrls?: Array<{
+        path?: string;
+        group?: string;
+        url?: string;
+    }>;
+    groupSitemaps?: Array<SitemapReference & {
+        title: string;
+    }>;
+    parts?: Array<SitemapReference & {
+        title: string;
+    }>;
+    links?: Array<SitemapReference & {
+        title: string;
+    }>;
+    otherGroupLinks?: Array<SitemapReference & {
+        title: string;
+    }>;
+    markdownAlternates?: boolean;
 };
 declare function createSitemapXmlRoute(manifest: ManifestLike, options?: SitemapRouteOptions): () => Promise<Response>;
-declare function createSitemapMarkdownRoute(manifest: ManifestLike, artifactManifest: MarkdownRouteArtifactManifest): () => Promise<Response>;
+declare function createSitemapMarkdownRoute(manifest: ManifestLike, artifactManifest: MarkdownRouteArtifactManifest, options?: SitemapMarkdownRouteOptions): () => Promise<Response>;
 
-export { type SitemapRouteOptions, createSitemapMarkdownRoute, createSitemapXmlRoute };
+export { type SitemapMarkdownRouteOptions, type SitemapRouteOptions, createSitemapMarkdownRoute, createSitemapXmlRoute };

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

@@ -5,7 +5,8 @@ import { cacheLife, cacheTag } from "next/cache";
 // src/lib/runtime/metadata/canonical-url.ts
 function canonicalUrl(manifest, path, group) {
   let origin = (group && manifest.groups[group]?.origin) ?? manifest.site.origin;
-  if (!origin) return path;
+  if (!origin)
+    return /^[a-z][a-z\d+.-]*:/i.test(path) ? path : new URL(path, "https://publish.invalid").pathname;
   try {
     return new URL(path, `${origin}/`).toString();
   } catch {
@@ -13,6 +14,111 @@ function canonicalUrl(manifest, path, group) {
   }
 }
 
+// src/lib/runtime/metadata/discovery-content.ts
+function discoveryOrigin(manifest, group) {
+  return (group ? manifest.groups[group]?.origin : void 0) ?? manifest.site.origin;
+}
+function navigationDiscoverySections({
+  manifest,
+  group,
+  scope,
+  limit,
+  excludeGroups = [],
+  markdownPaths
+}) {
+  let origin = discoveryOrigin(manifest, group), targetGroup = group ? manifest.groups[group] : void 0, mountedGroup = Object.values(manifest.groups).find(
+    (candidate) => candidate.key !== "__root" && candidate.path === "/" && discoveryOrigin(manifest, candidate.key) === origin
+  ), rootGroups = targetGroup && scope !== "site" ? [manifest.groups[targetGroup.navigation.rootGroup]] : Object.values(manifest.groups).filter(
+    (candidate) => candidate.key === candidate.navigation.rootGroup && (candidate.key !== "__root" || !mountedGroup) && discoveryOrigin(manifest, candidate.key) === origin
+  ), sections = [], pageKeys = /* @__PURE__ */ new Set(), pageCount = 0, inScope = (entryGroup) => discoveryOrigin(manifest, entryGroup) !== origin || excludeGroups.some(
+    (excluded) => entryGroup === excluded || entryGroup.startsWith(`${excluded}/`)
+  ) ? !1 : !targetGroup || scope === "site" ? !0 : entryGroup === targetGroup.key || scope !== "self" && entryGroup.startsWith(`${targetGroup.key}/`), append = (title, entry) => {
+    let previous = sections.at(-1);
+    previous?.title === title ? previous.entries.push(entry) : sections.push({ title, entries: [entry] });
+  }, visit = (nodes, groupKey, headings) => {
+    for (let node of nodes)
+      if (node.type === "page") {
+        let page = node.page, key = `${page.group}/${page.fileID}`;
+        if (page.frontmatter.status !== "published" || !inScope(page.group) || pageKeys.has(key) || limit !== void 0 && limit > 0 && pageCount >= limit)
+          continue;
+        pageKeys.add(key), pageCount += 1, append(headings.join(" > "), {
+          type: "page",
+          title: node.label || page.frontmatter.title,
+          url: canonicalUrl(
+            manifest,
+            markdownPaths?.get(page.path) ?? page.path,
+            page.group
+          ),
+          path: page.path,
+          group: page.group,
+          ...page.frontmatter.description ? { description: page.frontmatter.description } : {}
+        }), node.children && visit(node.children, page.group, headings);
+      } else node.type === "group" ? (inScope(node.groupKey) && append(headings.join(" > "), {
+        type: "link",
+        title: node.label,
+        url: canonicalUrl(manifest, node.route, node.groupKey),
+        group: node.groupKey
+      }), visit(node.children, node.groupKey, [...headings, node.label])) : node.type === "link" ? inScope(groupKey) && append(headings.join(" > "), {
+        type: "link",
+        title: node.label,
+        url: canonicalUrl(manifest, node.href, groupKey),
+        group: groupKey
+      }) : node.type === "section" || node.type === "folder" ? visit(node.children, groupKey, [...headings, node.label]) : node.type === "view" && visit(node.items, groupKey, headings);
+  };
+  for (let root of rootGroups)
+    !root || discoveryOrigin(manifest, root.key) !== origin || (!targetGroup || scope === "site" ? append(root.title, {
+      type: "link",
+      title: root.title,
+      url: canonicalUrl(manifest, root.path, root.key),
+      group: root.key
+    }) : root.key === targetGroup.key && append(root.title, {
+      type: "link",
+      title: root.title,
+      url: canonicalUrl(manifest, root.path, root.key),
+      group: root.key
+    }), visit(root.navigation.items, root.key, [root.title]));
+  return sections;
+}
+
+// src/lib/runtime/metadata/llms-serialization.ts
+function inlineText(value) {
+  return value.replace(/[\r\n]+/g, " ").replace(/([\\`*_[\]<>])/g, "\\$1");
+}
+function markdownLink(link) {
+  let url = link.url.replace(
+    /[\s()<>]/g,
+    (value) => value === "(" ? "%28" : value === ")" ? "%29" : encodeURIComponent(value)
+  );
+  return `[${inlineText(link.title)}](${url})`;
+}
+function serializeLlmsIndex(input) {
+  let body = (input.sections ?? []).map((section) => {
+    let lines = section.entries.map((entry) => {
+      let description = input.includeDescriptions && entry.description ? `: ${inlineText(entry.description)}` : "", alternate = entry.alternate ? ` (${markdownLink(entry.alternate)})` : "";
+      return `- ${markdownLink(entry)}${alternate}${description}`;
+    });
+    return `## ${inlineText(section.title)}
+
+${lines.join(`
+`)}`;
+  }).join(`
+
+`), otherGroupLines = (input.otherGroupLinks ?? []).map(
+    (link) => `- ${markdownLink(link)}`
+  ), otherGroupSection = otherGroupLines.length ? `
+
+## Other content groups
+
+${otherGroupLines.join(`
+`)}` : "";
+  return `# ${inlineText(input.title)}
+
+> ${inlineText(input.summary)}
+
+${body}${otherGroupSection}
+`;
+}
+
 // 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) {
@@ -35,44 +141,94 @@ function createCachedTextResponse(options) {
 
 // src/route-metadata-sitemap.ts
 var ROOT_CONTENT_GROUP_KEY = "__root";
+function assertSitemapSize(options) {
+  let bytes = new TextEncoder().encode(options.body).byteLength;
+  if (options.entryCount > 5e4 || bytes > 52428800)
+    throw new RangeError(
+      `Generated sitemap "${options.path}" exceeds ${5e4} entries or ${52428800} UTF-8 bytes. Split or limit its content.`
+    );
+  return options.body;
+}
 function xmlEscape(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/'/g, "&apos;").replace(/"/g, "&quot;");
 }
-function groupOrigin(manifest, groupKey) {
-  return manifest.groups[groupKey]?.origin ?? manifest.site.origin;
+function sitemapDirectory(path) {
+  return path.slice(0, path.lastIndexOf("/") + 1) || "/";
 }
-function pathInScope(path, basePath) {
-  return basePath === "/" || path === basePath || path.startsWith(`${basePath}/`);
+function isWithinDirectory(path, directories) {
+  for (let end = path.indexOf("/"); end >= 0; end = path.indexOf("/", end + 1))
+    if (directories.has(path.slice(0, end + 1))) return !0;
+  return !1;
 }
 function rootMountedGroup(manifest, origin) {
   return Object.values(manifest.groups).find(
-    (group) => group.key !== ROOT_CONTENT_GROUP_KEY && group.path === "/" && groupOrigin(manifest, group.key) === origin
+    (group) => group.key !== ROOT_CONTENT_GROUP_KEY && group.path === "/" && discoveryOrigin(manifest, group.key) === origin
   );
 }
 async function sitemapXml(manifest, options) {
   "use cache";
   cacheLife("page"), cacheTag(tags.site(), tags.sitemap(), tags.manifest(manifest.contentHash));
-  let targetGroup = options.group ? manifest.groups[options.group] : void 0, basePath = targetGroup?.path ?? "/", origin = targetGroup ? groupOrigin(manifest, targetGroup.key) : manifest.site.origin, homeGroup = targetGroup ?? rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter(
-    (group) => groupOrigin(manifest, group.key) === origin && pathInScope(group.path, basePath)
+  let targetGroup = options.group ? manifest.groups[options.group] : void 0, directory = sitemapDirectory(
+    options.path ?? `${targetGroup?.path === "/" ? "" : targetGroup?.path ?? ""}/sitemap.xml`
+  ), origin = targetGroup ? discoveryOrigin(manifest, targetGroup.key) : manifest.site.origin, includedUrls = options.includeUrls ? new Set(
+    options.includeUrls.map(
+      ({ path, group }) => JSON.stringify([group ?? null, path])
+    )
+  ) : void 0, excludedDirectories = new Set(
+    (options.exclude ?? []).filter((sitemap) => discoveryOrigin(manifest, sitemap.group) === origin).map((sitemap) => sitemapDirectory(sitemap.path))
+  );
+  if (options.sitemaps) {
+    let urls2 = [
+      ...new Set(
+        options.sitemaps.filter(
+          (sitemap) => discoveryOrigin(manifest, sitemap.group) === origin
+        ).filter(
+          (sitemap) => sitemap.path.startsWith(directory) && sitemap.path !== options.path
+        ).map(
+          (sitemap) => canonicalUrl(manifest, sitemap.path, sitemap.group)
+        )
+      )
+    ], body2 = urls2.map((url) => `  <sitemap><loc>${xmlEscape(url)}</loc></sitemap>`).join(`
+`);
+    return assertSitemapSize({
+      path: options.path ?? "/sitemap.xml",
+      entryCount: urls2.length,
+      body: `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${body2}
+</sitemapindex>
+`
+    });
+  }
+  let homeGroup = targetGroup ?? rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter(
+    (group) => discoveryOrigin(manifest, group.key) === origin && (directory === "/" || group.path.startsWith(directory))
   ), urls = [
     {
       path: homeGroup?.path ?? "/",
       group: homeGroup?.key
     },
     ...groups.map((group) => ({ path: group.path, group: group.key })),
-    ...manifest.pages.filter((page) => page.status === "published").filter((page) => groupOrigin(manifest, page.group) === origin).filter((page) => pathInScope(page.path, basePath)).map((page) => ({ path: page.path, group: page.group }))
-  ];
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${[...new Map(
+    ...manifest.pages.filter(
+      (page) => page.frontmatter.status === "published" && page.frontmatter.metadata.robots?.index !== !1
+    ).filter((page) => discoveryOrigin(manifest, page.group) === origin).map((page) => ({ path: page.path, group: page.group }))
+  ].filter(
+    ({ path, group }) => (directory === "/" || path.startsWith(directory)) && (!includedUrls || includedUrls.has(JSON.stringify([group ?? null, path]))) && !isWithinDirectory(path, excludedDirectories)
+  ), uniqueUrls = new Map(
     urls.map(({ path, group }) => {
       let url = canonicalUrl(manifest, path, group);
       return [url, url];
     })
-  ).values()].map((url) => `  <url><loc>${xmlEscape(url)}</loc></url>`).join(`
-`)}
+  ), body = [...uniqueUrls.values()].map((url) => `  <url><loc>${xmlEscape(url)}</loc></url>`).join(`
+`);
+  return assertSitemapSize({
+    path: options.path ?? "/sitemap.xml",
+    entryCount: uniqueUrls.size,
+    body: `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${body}
 </urlset>
-`;
+`
+  });
 }
 function createSitemapXmlRoute(manifest, options = {}) {
   return async function() {
@@ -82,42 +238,114 @@ function createSitemapXmlRoute(manifest, options = {}) {
     });
   };
 }
-async function sitemapMarkdown(manifest, artifactManifest) {
-  let origin = manifest.site.origin, rootGroup = rootMountedGroup(manifest, origin), groups = Object.values(manifest.groups).filter((group) => group.key !== ROOT_CONTENT_GROUP_KEY).filter((group) => groupOrigin(manifest, group.key) === origin).sort((a, b) => a.path.localeCompare(b.path)).map(
-    (group) => `- [${group.title}](${canonicalUrl(manifest, group.path, group.key)})`
-  ), pages = manifest.pages.filter((page) => page.status === "published").filter((page) => groupOrigin(manifest, page.group) === origin).sort((a, b) => a.path.localeCompare(b.path)).map((page) => {
-    let markdownPath = artifactManifest.byHtmlPath[page.path], markdown = markdownPath ? ` ([Markdown](${canonicalUrl(manifest, markdownPath, page.group)}))` : "";
-    return `- [${page.title}](${canonicalUrl(manifest, page.path, page.group)})${markdown}`;
+async function sitemapMarkdown(manifest, artifactManifest, options) {
+  let origin = discoveryOrigin(manifest, options.group), targetGroup = options.group ? manifest.groups[options.group] : void 0, rootGroup = targetGroup?.key === ROOT_CONTENT_GROUP_KEY ? void 0 : targetGroup ?? rootMountedGroup(manifest, origin), markdownPaths = new Map(
+    options.markdownAlternates === !1 ? [] : Object.entries(artifactManifest.byHtmlPath)
+  ), linkedParts = options.parts ?? [], groupSitemaps = options.groupSitemaps ?? [], discoverySections = linkedParts.length ? [] : navigationDiscoverySections({
+    manifest,
+    ...options,
+    markdownPaths
+  }), selectors = options.includeUrls, remainingSelectors = /* @__PURE__ */ new Map(), selectorKeys = /* @__PURE__ */ new Map();
+  for (let [index, selector] of (selectors ?? []).entries()) {
+    let keys = /* @__PURE__ */ new Set();
+    selector.path !== void 0 && (keys.add(
+      `page:${JSON.stringify([selector.group ?? null, selector.path])}`
+    ), keys.add(
+      `url:${JSON.stringify([
+        selector.group ?? null,
+        canonicalUrl(manifest, selector.path, selector.group)
+      ])}`
+    )), selector.url !== void 0 && keys.add(`url:${JSON.stringify([selector.group ?? null, selector.url])}`), selectorKeys.set(index, [...keys]);
+    for (let key of keys) {
+      let candidates = remainingSelectors.get(key) ?? /* @__PURE__ */ new Set();
+      candidates.add(index), remainingSelectors.set(key, candidates);
+    }
+  }
+  let selectedSections = discoverySections.map((section) => ({
+    ...section,
+    entries: section.entries.filter((entry) => {
+      if (!selectors) return !0;
+      let key = entry.type === "page" ? `page:${JSON.stringify([entry.group ?? null, entry.path])}` : `url:${JSON.stringify([entry.group ?? null, entry.url])}`, selectorIndex = remainingSelectors.get(key)?.values().next().value;
+      if (selectorIndex === void 0) return !1;
+      for (let selectorKey of selectorKeys.get(selectorIndex) ?? []) {
+        let selectorCandidates = remainingSelectors.get(selectorKey);
+        selectorCandidates?.delete(selectorIndex), selectorCandidates?.size === 0 && remainingSelectors.delete(selectorKey);
+      }
+      return !0;
+    })
+  })).filter((section) => section.entries.length > 0), links = options.links ?? [
+    { title: "LLMS index", path: "/llms.txt" },
+    { title: "Full LLMS index", path: "/llms-full.txt" },
+    { title: "XML sitemap", path: "/sitemap.xml" }
+  ], body = serializeLlmsIndex({
+    title: `${rootGroup?.title ?? manifest.site.name} Sitemap`,
+    summary: "Browse the published pages and their available Markdown versions.",
+    sections: [
+      ...groupSitemaps.length ? [
+        {
+          title: "Content groups",
+          entries: groupSitemaps.map((sitemap) => ({
+            title: sitemap.title,
+            url: canonicalUrl(manifest, sitemap.path, sitemap.group)
+          }))
+        }
+      ] : [],
+      ...linkedParts.length ? [
+        {
+          title: "Parts",
+          entries: linkedParts.map((part) => ({
+            title: part.title,
+            url: canonicalUrl(manifest, part.path, part.group)
+          }))
+        }
+      ] : [],
+      ...links.length ? [
+        {
+          title: "Agent indexes",
+          entries: links.map((link) => ({
+            title: link.title,
+            url: canonicalUrl(manifest, link.path, link.group)
+          }))
+        }
+      ] : [],
+      ...selectedSections.map((section) => ({
+        title: section.title,
+        entries: section.entries.map((entry) => {
+          if (entry.type === "link") return entry;
+          let markdownPath = markdownPaths.get(entry.path);
+          return {
+            title: entry.title,
+            url: canonicalUrl(manifest, entry.path, entry.group),
+            ...markdownPath ? {
+              alternate: {
+                title: "Markdown",
+                url: canonicalUrl(manifest, markdownPath, entry.group)
+              }
+            } : {}
+          };
+        })
+      })),
+      ...options.otherGroupLinks?.length ? [
+        {
+          title: "Other content groups",
+          entries: options.otherGroupLinks.map((link) => ({
+            title: link.title,
+            url: canonicalUrl(manifest, link.path, link.group)
+          }))
+        }
+      ] : []
+    ]
+  });
+  return assertSitemapSize({
+    path: options.path ?? (options.group ? `${manifest.groups[options.group]?.path ?? ""}/sitemap.md` : "/sitemap.md"),
+    entryCount: (body.match(/\]\(/g) ?? []).length,
+    body
   });
-  return [
-    `# ${rootGroup?.title ?? manifest.site.name} Sitemap`,
-    "## Agent indexes",
-    `- [LLMS index](${canonicalUrl(manifest, "/llms.txt")})`,
-    `- [Full LLMS index](${canonicalUrl(manifest, "/llms-full.txt")})`,
-    `- [XML sitemap](${canonicalUrl(manifest, "/sitemap.xml")})`,
-    "## Sections",
-    groups.length ? groups.join(`
-`) : `- [${rootGroup?.title ?? "Home"}](${canonicalUrl(
-      manifest,
-      rootGroup?.path ?? "/",
-      rootGroup?.key
-    )})`,
-    "## Pages",
-    pages.length ? pages.join(`
-`) : `- [${rootGroup?.title ?? "Home"}](${canonicalUrl(
-      manifest,
-      rootGroup?.path ?? "/",
-      rootGroup?.key
-    )})`,
-    ""
-  ].join(`
-
-`);
 }
-function createSitemapMarkdownRoute(manifest, artifactManifest) {
+function createSitemapMarkdownRoute(manifest, artifactManifest, options = {}) {
   return async function() {
     return createCachedTextResponse({
-      body: await sitemapMarkdown(manifest, artifactManifest),
+      body: await sitemapMarkdown(manifest, artifactManifest, options),
       contentType: "text/markdown; charset=utf-8"
     });
   };

package/dist/kernel/routes/not-found.d.ts

@@ -0,0 +1,34 @@
+type NotFoundLink = {
+    title: string;
+    href: string;
+    description?: string;
+    kind?: "sitemap" | "sitemap-md" | "llms" | "llms-full";
+};
+type NotFoundScope = {
+    id: string;
+    path: string;
+    group?: string;
+    origin?: string;
+    describedBy?: string;
+    htmlPath: string;
+    recommendations: readonly NotFoundLink[];
+    indexes: readonly NotFoundLink[];
+    markdown: string;
+};
+declare function resolveNotFoundScope({ scopes, pathname, }: {
+    scopes: readonly NotFoundScope[];
+    pathname: string;
+}): NotFoundScope | undefined;
+declare function serializeNotFoundMarkdown({ recommendations, indexes, }: {
+    recommendations: readonly NotFoundLink[];
+    indexes: readonly NotFoundLink[];
+}): string;
+declare function createNotFoundTextResponse({ scope, pathname, method, contentType, vary, }: {
+    scope?: NotFoundScope;
+    pathname?: string;
+    method: string;
+    contentType?: "text/markdown; charset=utf-8" | "text/plain; charset=utf-8";
+    vary?: boolean;
+}): Response;
+
+export { type NotFoundLink, type NotFoundScope, createNotFoundTextResponse, resolveNotFoundScope, serializeNotFoundMarkdown };