blume 1.6.5 → 1.7.0

package/dist/cli/chunk-ynacq3ev.js

@@ -0,0 +1,1062 @@
+#!/usr/bin/env node
+import {
+  readExpandedEntryText,
+  rewriteRelativeImages
+} from "./chunk-v5mm027v.js";
+import {
+  API_CATALOG_PATH,
+  API_PAGES_PATH,
+  OPENAPI_PATH,
+  hasApiCatalog
+} from "./chunk-j6pxe0dt.js";
+import {
+  absoluteUrl,
+  siteRoot
+} from "./chunk-vxv4x1n8.js";
+import {
+  HTML_COMMENT,
+  contentIndexable,
+  frontmatter_default,
+  isOpenApiSource,
+  operationOf,
+  operationSignature,
+  parseHeadingMarkers,
+  specAddresses,
+  specOf
+} from "./chunk-s102bysw.js";
+import {
+  normalizeBasePath,
+  withBasePath
+} from "./chunk-27gtm2ym.js";
+
+// src/ai/markdown.ts
+import { readFile } from "node:fs/promises";
+
+// src/ai/component-markdown.ts
+import { markdownTable } from "markdown-table";
+import { mdxToMdast } from "satteri";
+
+// src/components/content/youtube.ts
+var BARE_ID = /^[\w-]{11}$/u;
+var URL_ID = /(?:youtu\.be\/|\/embed\/|\/shorts\/|\/live\/|[?&]v=)(?<id>[\w-]{11})/u;
+var parseYouTubeId = (input) => {
+  const value = input.trim();
+  if (!value) {
+    return null;
+  }
+  if (BARE_ID.test(value)) {
+    return value;
+  }
+  return URL_ID.exec(value)?.groups?.id ?? null;
+};
+
+// src/markdown/features.ts
+var MARKDOWN_FEATURES = {
+  subscript: true,
+  superscript: true
+};
+var MDX_FEATURES = {
+  ...MARKDOWN_FEATURES,
+  directive: true,
+  math: { singleDollarTextMath: false }
+};
+
+// src/ai/component-markdown.ts
+var isString = (value) => typeof value === "string";
+var isNumber = (value) => typeof value === "number";
+var evaluateExpression = (raw, frontmatter) => {
+  try {
+    const value = new Function("frontmatter", `"use strict"; return (${raw});`)(frontmatter);
+    return { ok: true, value };
+  } catch {
+    return { ok: false, value: undefined };
+  }
+};
+var readProps = (node, frontmatter) => {
+  const props = {};
+  let lossy = false;
+  for (const attribute of node.attributes ?? []) {
+    if (attribute.type !== "mdxJsxAttribute" || !attribute.name) {
+      lossy = true;
+      continue;
+    }
+    if (attribute.value === null || attribute.value === undefined) {
+      props[attribute.name] = true;
+    } else if (isString(attribute.value)) {
+      props[attribute.name] = attribute.value;
+    } else {
+      const result = evaluateExpression(attribute.value.value, frontmatter);
+      if (result.ok) {
+        props[attribute.name] = result.value;
+      } else {
+        lossy = true;
+      }
+    }
+  }
+  return { lossy, props };
+};
+var hasOffsets = (node) => typeof node.position?.start?.offset === "number" && typeof node.position?.end?.offset === "number";
+var applySplices = (text, splices) => {
+  let result = text;
+  for (const splice of [...splices].toSorted((a, b) => b.start - a.start)) {
+    const lineStart = result.lastIndexOf(`
+`, splice.start - 1) + 1;
+    const prefix = result.slice(lineStart, splice.start);
+    const indent = /^[\t ]+$/u.test(prefix) ? prefix : "";
+    const replacement = indent ? splice.text.split(`
+`).map((line, index) => index === 0 || line === "" ? line : `${indent}${line}`).join(`
+`) : splice.text;
+    result = result.slice(0, splice.start) + replacement + result.slice(splice.end);
+  }
+  return result;
+};
+var dedent = (text) => {
+  const lines = text.split(`
+`);
+  const rest = lines.slice(1).filter((line) => line.trim() !== "");
+  if (rest.length === 0) {
+    return text;
+  }
+  const indent = Math.min(...rest.map((line) => line.length - line.trimStart().length));
+  if (indent === 0) {
+    return text;
+  }
+  return [
+    lines[0],
+    ...lines.slice(1).map((line) => line.trim() === "" ? "" : line.slice(indent))
+  ].join(`
+`);
+};
+var isJsxElement = (node) => node.type === "mdxJsxFlowElement" || node.type === "mdxJsxTextElement";
+var cellText = (value) => String(value ?? "").replaceAll(/\s*\n\s*/gu, " ").replaceAll("|", "\\|").trim();
+var cellCode = (value) => {
+  const text = cellText(value);
+  return text && !text.includes("`") ? `\`${text}\`` : text;
+};
+var isTypeEntryMap = (value) => typeof value === "object" && value !== null;
+var typeTable = ({ children, props }) => {
+  const { type } = props;
+  if (!isTypeEntryMap(type)) {
+    return null;
+  }
+  const entries = Object.entries(type);
+  const rows = entries.map(([name, info]) => {
+    const prop = cellCode(`${name}${info.required ? "" : "?"}`);
+    const typeCell = info.typeDescriptionLink ? `[${cellCode(info.type)}](${cellText(info.typeDescriptionLink)})` : cellCode(info.type);
+    const defaultCell = info.default === undefined ? "-" : cellCode(info.default);
+    const description = cellText([info.description, info.typeDescription].filter((part) => isString(part) && part !== "").join(" "));
+    return [prop, typeCell, defaultCell, description];
+  });
+  const table = rows.length > 0 ? markdownTable([["Prop", "Type", "Default", "Description"], ...rows], {
+    alignDelimiters: false
+  }) : "";
+  return [table, children].filter(Boolean).join(`
+
+`);
+};
+var callout = ({ children, props }) => {
+  const type = isString(props.type) ? props.type : "info";
+  const label = isString(props.title) && props.title !== "" ? props.title : type.charAt(0).toUpperCase() + type.slice(1);
+  if (!children) {
+    return `> **${label}**`;
+  }
+  const body = children.split(`
+`).map((line) => line.trim() === "" ? ">" : `> ${line}`).join(`
+`);
+  return `> **${label}**
+>
+${body}`;
+};
+var listItem = (index, content) => {
+  const marker = `${index}. `;
+  return content.split(`
+`).map((line, lineIndex) => {
+    if (lineIndex === 0) {
+      return `${marker}${line}`;
+    }
+    return line === "" ? "" : `    ${line}`;
+  }).join(`
+`);
+};
+var steps = ({ childComponents, children }) => {
+  const items = childComponents("Step");
+  if (items.length === 0) {
+    return children;
+  }
+  return items.map((step, index) => {
+    const title = isString(step.props.title) && step.props.title !== "" ? `**${step.props.title}**` : "";
+    const content = [title, step.children].filter(Boolean).join(`
+
+`);
+    return listItem(index + 1, content);
+  }).join(`
+
+`);
+};
+var tabs = ({ childComponents, children }) => {
+  const items = childComponents("Tab");
+  if (items.length === 0) {
+    return children;
+  }
+  return items.map((tab, index) => {
+    const title = isString(tab.props.title) && tab.props.title !== "" ? tab.props.title : `Tab ${index + 1}`;
+    return tab.children ? `**${title}**
+
+${tab.children}` : `**${title}**`;
+  }).join(`
+
+`);
+};
+var linkText = (value) => value.replaceAll(/[[\]]/gu, String.raw`\$&`);
+var linkDestination = (href) => /[\s()<>]/u.test(href) ? `<${href.replaceAll(/[<>]/gu, String.raw`\$&`)}>` : href;
+var textProp = (value) => {
+  if (isString(value)) {
+    return value.trim();
+  }
+  return isNumber(value) ? String(value) : "";
+};
+var card = ({ children, lossy, props }) => {
+  if (lossy) {
+    return null;
+  }
+  const title = textProp(props.title);
+  const href = isString(props.href) ? props.href.trim() : "";
+  const body = children.trim();
+  const cta = textProp(props.cta);
+  const label = title || href;
+  if (label === "") {
+    const rest = [body, cta].filter(Boolean).join(`
+
+`);
+    return rest === "" ? null : rest;
+  }
+  const head = href === "" ? `**${label}**` : `**[${linkText(label)}](${linkDestination(href)})**`;
+  return [head, body, cta].filter(Boolean).join(`
+
+`);
+};
+var cardGroup = ({ childBlocks }) => childBlocks().map((block) => block.markdown).join(`
+
+`);
+var youtube = ({ props }) => {
+  let input = "";
+  if (isString(props.id)) {
+    input = props.id;
+  } else if (isString(props.url)) {
+    input = props.url;
+  }
+  const videoId = parseYouTubeId(input);
+  if (!videoId) {
+    return null;
+  }
+  const start = isNumber(props.start) && props.start > 0 ? `&t=${Math.floor(props.start)}s` : "";
+  const title = isString(props.title) && props.title !== "" ? props.title : "Watch on YouTube";
+  return `[${title}](https://www.youtube.com/watch?v=${videoId}${start})`;
+};
+var inlineCode = (text) => {
+  const runs = text.match(/`+/gu);
+  const longest = runs ? Math.max(...runs.map((run) => run.length)) : 0;
+  const delimiter = "`".repeat(longest + 1);
+  const padded = text.startsWith("`") || text.endsWith("`") ? ` ${text} ` : text;
+  return `${delimiter}${padded}${delimiter}`;
+};
+var fencedBlock = (lang, code) => {
+  const trimmed = code.replace(/(?<!\n)\n+$/u, "");
+  const runs = trimmed.match(/`+/gu);
+  const longest = runs ? Math.max(...runs.map((run) => run.length)) : 0;
+  const fence = "`".repeat(Math.max(3, longest + 1));
+  return `${fence}${lang}
+${trimmed}
+${fence}`;
+};
+var exampleComponentSerializers = (examples) => ({
+  Component: ({ props }) => {
+    const path = isString(props.path) ? props.path : undefined;
+    const example = path === undefined ? undefined : examples[path];
+    return example ? fencedBlock(example.lang, example.source) : null;
+  }
+});
+var SERIALIZERS = {
+  Callout: callout,
+  Card: card,
+  CardGroup: cardGroup,
+  Steps: steps,
+  Tabs: tabs,
+  TypeTable: typeTable,
+  YouTube: youtube
+};
+var escapeRegExp = (value) => value.replaceAll(/[$()*+.?[\\\]^{|}]/gu, String.raw`\$&`);
+var componentHint = (registry) => new RegExp(`<(?:${Object.keys(registry).map(escapeRegExp).join("|")})[\\s/>]`, "u");
+var BUILT_IN_HINT = componentHint(SERIALIZERS);
+var componentRegistry = (components) => components && Object.keys(components).length > 0 ? { ...SERIALIZERS, ...components } : SERIALIZERS;
+var renderSlice = (walk, start, end, nodes) => {
+  const splices = [];
+  collectSplices(walk, nodes, splices);
+  const spliced = applySplices(walk.source.slice(start, end), splices.map((splice) => ({
+    ...splice,
+    end: splice.end - start,
+    start: splice.start - start
+  })));
+  return dedent(spliced).trim();
+};
+var renderChildren = (walk, node) => {
+  const children = (node.children ?? []).filter(hasOffsets);
+  const [first] = children;
+  if (!first) {
+    return "";
+  }
+  const start = first.position.start.offset;
+  return renderSlice(walk, start, children.at(-1)?.position.end.offset ?? start, children);
+};
+var renderBlock = (walk, node) => {
+  const serializer = isJsxElement(node) && node.name ? walk.registry[node.name] : undefined;
+  const text = serializer ? serializeElement(serializer, walk, node) : null;
+  return text ?? renderSlice(walk, node.position.start.offset, node.position.end.offset, node.children ?? []);
+};
+var serializeElement = (serializer, walk, node) => serializer({
+  ...readProps(node, walk.frontmatter),
+  childBlocks: () => (node.children ?? []).filter(hasOffsets).map((child) => ({
+    markdown: renderBlock(walk, child),
+    name: isJsxElement(child) ? child.name : undefined
+  })),
+  childComponents: (name) => (node.children ?? []).filter((child) => isJsxElement(child) && child.name === name).map((child) => ({
+    ...readProps(child, walk.frontmatter),
+    children: renderChildren(walk, child)
+  })),
+  children: renderChildren(walk, node),
+  frontmatter: walk.frontmatter ?? {}
+});
+var downlevelComponentNode = (node, walk) => {
+  const serializer = node.type === "mdxJsxFlowElement" && node.name ? walk.registry[node.name] : undefined;
+  return serializer && hasOffsets(node) ? serializeElement(serializer, walk, node) : null;
+};
+var collectSplices = (walk, nodes, out) => {
+  for (const node of nodes) {
+    const text = hasOffsets(node) ? downlevelComponentNode(node, walk) : null;
+    if (text !== null && hasOffsets(node)) {
+      out.push({
+        end: node.position.end.offset,
+        start: node.position.start.offset,
+        text
+      });
+      continue;
+    }
+    collectSplices(walk, node.children ?? [], out);
+  }
+};
+var downlevelComponents = (source, components, frontmatter) => {
+  const registry = componentRegistry(components);
+  const hint = registry === SERIALIZERS ? BUILT_IN_HINT : componentHint(registry);
+  if (!hint.test(source)) {
+    return source;
+  }
+  let tree;
+  try {
+    tree = mdxToMdast(source, { features: MDX_FEATURES });
+  } catch {
+    return source;
+  }
+  const splices = [];
+  collectSplices({ frontmatter, registry, source }, tree.children ?? [], splices);
+  return splices.length > 0 ? applySplices(source, splices) : source;
+};
+
+// src/deploy/rss.ts
+import { escape as escapeXml } from "html-escaper";
+var capitalize = (value) => value.charAt(0).toUpperCase() + value.slice(1);
+var pageDate = (page) => {
+  const raw = page.meta.date ?? page.meta.changelog?.date;
+  if (!raw) {
+    return;
+  }
+  const date = new Date(raw);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+};
+var buildRssFeeds = (project) => {
+  const { config } = project;
+  const { rss } = config.seo;
+  const { site } = config.deployment;
+  if (!(rss.enabled && site)) {
+    return [];
+  }
+  const base = siteRoot(site);
+  const deployBase = normalizeBasePath(config.deployment.base);
+  const rootLink = `${base}${deployBase}`;
+  const feeds = [];
+  for (const type of rss.types) {
+    const pages = project.graph.pages.filter((page) => page.contentType === type && !(page.meta.draft || page.meta.sidebar.hidden));
+    if (pages.length === 0) {
+      continue;
+    }
+    const items = pages.map((page) => ({
+      date: pageDate(page),
+      description: page.description,
+      link: encodeURI(`${base}${withBasePath(deployBase, page.route)}`),
+      title: page.title
+    })).toSorted((a, b) => (b.date?.getTime() ?? 0) - (a.date?.getTime() ?? 0)).slice(0, rss.limit);
+    feeds.push({
+      description: config.description,
+      items,
+      link: rootLink,
+      path: `/${type}/rss.xml`,
+      title: `${config.title} — ${capitalize(type)}`,
+      type
+    });
+  }
+  return feeds;
+};
+var renderItem = (item) => {
+  const parts = [
+    `    <title>${escapeXml(item.title)}</title>`,
+    `    <link>${escapeXml(item.link)}</link>`,
+    `    <guid isPermaLink="true">${escapeXml(item.link)}</guid>`
+  ];
+  if (item.description) {
+    parts.push(`    <description>${escapeXml(item.description)}</description>`);
+  }
+  if (item.date) {
+    parts.push(`    <pubDate>${item.date.toUTCString()}</pubDate>`);
+  }
+  return `  <item>
+${parts.join(`
+`)}
+  </item>`;
+};
+var renderRssFeed = (feed) => {
+  const feedSelfHref = `${feed.link}${feed.path}`;
+  const channel = [
+    `  <title>${escapeXml(feed.title)}</title>`,
+    `  <link>${escapeXml(feed.link)}</link>`,
+    `  <description>${escapeXml(feed.description ?? feed.title)}</description>`,
+    `  <atom:link href="${escapeXml(feedSelfHref)}" rel="self" type="application/rss+xml" />`
+  ];
+  const items = feed.items.map(renderItem).join(`
+`);
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+<channel>
+${channel.join(`
+`)}
+${items}
+</channel>
+</rss>
+`;
+};
+
+// src/ai/openapi-components.ts
+var inlineText = (text) => text.trim().replaceAll(/\s+/gu, " ").replaceAll(/[\\`*_[\]<>~]/gu, String.raw`\$&`);
+var listItem2 = (signature, operation) => {
+  const tail = [
+    inlineText(operation.summary),
+    operation.deprecated ? "Deprecated." : ""
+  ].filter(Boolean).join(" ");
+  return `- [${inlineCode(signature)}](${linkDestination(operation.route)})${tail ? ` — ${tail}` : ""}`;
+};
+var openapiComponentSerializers = (specs) => {
+  const spec = (source) => isString(source) ? specOf(specs, source) : undefined;
+  return {
+    ApiOverview: ({ props }) => {
+      const data = spec(props.source);
+      if (!data) {
+        return null;
+      }
+      const { addresses, label } = specAddresses(data);
+      const lines = [
+        data.version ? `Version ${inlineText(data.version)}` : "",
+        addresses.length > 0 ? `${label}: ${addresses.map(inlineCode).join(", ")}` : ""
+      ].filter(Boolean);
+      return lines.length > 0 ? lines.join(`
+
+`) : null;
+    },
+    ApiTagOperations: ({ props }) => {
+      const { tag } = props;
+      const data = spec(props.source);
+      if (!(data && isString(tag))) {
+        return null;
+      }
+      const items = Object.values(data.operations).filter((operation) => operation.tagSlug === tag).map((operation) => listItem2(operationSignature(data, operation), operation));
+      return items.length > 0 ? items.join(`
+`) : null;
+    },
+    Operation: ({ props }) => {
+      const { id } = props;
+      const data = spec(props.source);
+      if (!(data && isString(id))) {
+        return null;
+      }
+      const operation = operationOf(data, id);
+      if (!operation) {
+        return null;
+      }
+      const signature = inlineCode(operationSignature(data, operation));
+      return operation.deprecated ? `${signature}
+
+**Deprecated.**` : signature;
+    }
+  };
+};
+
+// src/ai/serializers.ts
+var projectComponentSerializers = (project) => ({
+  ...exampleComponentSerializers(project.examples ?? {}),
+  ...openapiComponentSerializers(project.sources.find(isOpenApiSource)?.openApiData() ?? {}),
+  ...project.config.ai.markdownComponents
+});
+
+// src/ai/skills.ts
+import { join } from "pathe";
+
+// src/ai/tar.ts
+import { createTar } from "nanotar";
+var encoder = new TextEncoder;
+
+// src/ai/skills.ts
+var AGENT_SKILLS_DIR = "/.well-known/agent-skills";
+var AGENT_SKILLS_INDEX_PATH = "/.well-known/agent-skills/index.json";
+
+// src/ai/visibility.ts
+var CODE_FENCE_BLOCK = /^(?<fence>`{3,}|~{3,})[^\n]*\n[\s\S]*?^\k<fence>[^\n]*(?=\n|$)/gmu;
+var FENCE_TOKEN = /\u0000blume-fence-(?<index>\d+)\u0000/gu;
+var visibilityBlock = (audience) => new RegExp(`<Visibility\\s+for\\s*=\\s*(?:"${audience}"|'${audience}')\\s*>(?<inner>[\\s\\S]*?)</Visibility\\s*>`, "gu");
+var BLOCKS = {
+  agents: visibilityBlock("agents"),
+  web: visibilityBlock("web")
+};
+var applyAudienceVisibility = (markdown, audience) => {
+  const fences = [];
+  const masked = markdown.replace(CODE_FENCE_BLOCK, (block) => {
+    fences.push(block);
+    return `\x00blume-fence-${fences.length - 1}\x00`;
+  });
+  let touched = false;
+  const filtered = masked.replaceAll(BLOCKS[audience === "agents" ? "web" : "agents"], () => {
+    touched = true;
+    return "";
+  }).replaceAll(BLOCKS[audience], (_match, inner) => {
+    touched = true;
+    return inner;
+  });
+  const tidied = touched ? filtered.replaceAll(/\n{3,}/gu, `
+
+`) : filtered;
+  return tidied.replaceAll(FENCE_TOKEN, (token, index) => fences[Number(index)] ?? token);
+};
+var applyAgentVisibility = (markdown) => applyAudienceVisibility(markdown, "agents");
+
+// src/ai/llms.ts
+var pageUrl = (route, site, base = "") => {
+  const path = withBasePath(base, route);
+  return encodeURI(site ? absoluteUrl(site, path) : path);
+};
+var oneLine = (text) => text.replaceAll(/\s+/gu, " ").trim();
+var agentResourceLines = (project) => {
+  const { config } = project;
+  const { site } = config.deployment;
+  const url = (path) => pageUrl(path, site, normalizeBasePath(config.deployment.base));
+  const lines = [
+    `- [llms-full.txt](${url("/llms-full.txt")}): The full Markdown of every page in one file.`,
+    `- [Page Markdown](${url("/index.md")}): Append \`.md\` to any page URL to fetch that page as raw Markdown.`
+  ];
+  if (config.ai.api) {
+    lines.push(`- [JSON API](${url(API_PAGES_PATH)}): Page index of the JSON docs API; each entry links the page's JSON and Markdown forms. Described by the OpenAPI document at ${url(OPENAPI_PATH)}.`);
+  }
+  if (config.ai.mcp.enabled) {
+    lines.push(`- [MCP server](${url(config.ai.mcp.route)}): Streamable HTTP Model Context Protocol server with search_docs, get_page, list_pages, and get_navigation tools, plus every page as a resource. Discovery document: ${url("/.well-known/mcp.json")}`);
+  }
+  if (config.ai.skills) {
+    lines.push(`- [Agent skills](${url(AGENT_SKILLS_INDEX_PATH)}): Agent Skills discovery index of the skills this site publishes.`);
+  }
+  if (hasApiCatalog(config)) {
+    lines.push(`- [API catalog](${url(API_CATALOG_PATH)}): RFC 9727 linkset of the APIs documented here.`);
+  }
+  if (config.seo.agentReadability) {
+    lines.push(`- [agent-readability.json](${url("/agent-readability.json")}): Manifest of every agent-facing artifact on this site.`);
+  }
+  if (site && config.seo.sitemap) {
+    lines.push(`- [Sitemap](${url("/sitemap.xml")}): Every indexable page URL with its last-modified date.`);
+  }
+  return lines;
+};
+var eligiblePages = (project, options = {}) => project.graph.pages.filter((page) => !(page.meta.ai.exclude || page.meta.draft || page.meta.sidebar.hidden || page.meta.seo.noindex && page.source.name !== "openapi" || options.versions === "current" && page.version !== "") && (project.config.ai.llmsTxt.openapi || page.source.name !== "openapi"));
+var indexedNavigations = (project) => {
+  const { i18n, versions } = project.config;
+  const current = i18n ? i18n.locales.flatMap(({ code, label }) => {
+    const nav = project.graph.navigationByLocale[code];
+    if (!nav) {
+      return [];
+    }
+    return [
+      { label: code === i18n.defaultLocale ? undefined : label, nav }
+    ];
+  }) : [{ nav: project.graph.navigation }];
+  const archived = (versions?.archived ?? []).flatMap((version) => {
+    const byLocale = project.graph.navigationByVersion[version.id] ?? {};
+    const versionLabel = `${version.label ?? version.id} (archived)`;
+    return Object.entries(byLocale).flatMap(([code, nav]) => {
+      const locale = i18n?.locales.find((entry) => entry.code === code);
+      const label = locale && code !== i18n?.defaultLocale ? `${locale.label} — ${versionLabel}` : versionLabel;
+      return [{ label, nav }];
+    });
+  });
+  return [...current, ...archived];
+};
+var buildLlmsIndex = (project, options = {}) => {
+  const { config } = project;
+  const { site } = config.deployment;
+  const base = normalizeBasePath(config.deployment.base);
+  const eligible = eligiblePages(project);
+  const byRoute = new Map(eligible.map((page) => [page.route, page]));
+  const seen = new Set;
+  const line = (page) => {
+    seen.add(page.route);
+    const summary = page.description ? `: ${page.description}` : "";
+    return `- [${page.title}](${pageUrl(page.route, site, base)})${summary}`;
+  };
+  const renderLevel = (nodes, depth) => {
+    const list = [];
+    const groupBlocks = [];
+    for (const node of nodes) {
+      if (node.kind === "page") {
+        const page = byRoute.get(node.route);
+        if (page && !seen.has(page.route)) {
+          list.push(line(page));
+        }
+        continue;
+      }
+      const rootPage = node.route ? byRoute.get(node.route) : undefined;
+      const blocks2 = renderLevel(node.children, depth + 1);
+      if (rootPage && !seen.has(rootPage.route)) {
+        blocks2.unshift(line(rootPage));
+      }
+      if (blocks2.length > 0) {
+        groupBlocks.push(`${"#".repeat(Math.min(depth, 6))} ${node.label}`, ...blocks2);
+      }
+    }
+    return list.length > 0 ? [list.join(`
+`), ...groupBlocks] : groupBlocks;
+  };
+  const renderNav = (nav, depth) => {
+    const loose = nav.sidebar.filter((node) => node.kind === "page");
+    const groups = nav.sidebar.filter((node) => node.kind === "group");
+    const looseBlocks = renderLevel(loose, depth + 1);
+    return [
+      ...looseBlocks.length > 0 ? [`${"#".repeat(depth)} Docs`, ...looseBlocks] : [],
+      ...renderLevel(groups, depth)
+    ];
+  };
+  const blocks = [];
+  for (const { label, nav } of indexedNavigations(project)) {
+    if (label) {
+      const localized = renderNav(nav, 3);
+      if (localized.length > 0) {
+        blocks.push(`## ${label}`, ...localized);
+      }
+      continue;
+    }
+    blocks.push(...renderNav(nav, 2));
+  }
+  const leftover = eligible.filter((page) => !seen.has(page.route)).toSorted((a, b) => a.route.localeCompare(b.route));
+  if (leftover.length > 0) {
+    blocks.push(blocks.length > 0 ? "## Other" : "## Docs", leftover.map(line).join(`
+`));
+  }
+  const feeds = buildRssFeeds(project);
+  if (feeds.length > 0) {
+    blocks.push("## RSS Feeds", feeds.map((feed) => `- [${feed.title}](${pageUrl(feed.path, site, base)})`).join(`
+`));
+  }
+  const skills = options.skills ?? [];
+  if (skills.length > 0) {
+    blocks.push("## Agent skills", skills.map((skill) => `- [${skill.name}](${pageUrl(`${AGENT_SKILLS_DIR}/${skill.path}`, site, base)}): ${oneLine(skill.description)}`).join(`
+`));
+  }
+  blocks.push("## Agent resources", agentResourceLines(project).join(`
+`));
+  const header = config.description ? `# ${config.title}
+
+> ${config.description}` : `# ${config.title}`;
+  const { details } = config.ai.llmsTxt;
+  const lead = details ? `${header}
+
+${details}` : header;
+  return `${[lead, ...blocks].join(`
+
+`)}
+`;
+};
+
+// src/ai/markdown.ts
+var agentMarkdown = (entry) => entry.md ?? entry.mdx;
+var markdownTokenCount = (text) => Math.ceil(text.length / 4);
+var buildRawMarkdown = async (project) => {
+  const pageById = new Map(project.graph.pages.map((page) => [page.id, page]));
+  const components = projectComponentSerializers(project);
+  const readRoute = async (route) => {
+    const page = pageById.get(route.id);
+    if (page) {
+      return await readExpandedEntryText(project, page);
+    }
+    return route.sourcePath ? await readFile(route.sourcePath, "utf-8") : "";
+  };
+  const entries = await Promise.all(project.manifest.routes.map(async (route) => {
+    let text = await readRoute(route);
+    if (route.sourcePath) {
+      text = rewriteRelativeImages({
+        deployBase: project.config.deployment.base,
+        projectRoot: project.context.root,
+        source: text,
+        sourcePath: route.sourcePath
+      });
+    }
+    const source = applyAgentVisibility(text);
+    const md = downlevelComponents(source, components, frontmatter_default(source).data);
+    const entry = md === source ? { mdx: source } : { md, mdx: source };
+    return [route.path, entry];
+  }));
+  const map = Object.fromEntries(entries);
+  if (!map["/"]) {
+    map["/"] = { mdx: buildLlmsIndex(project) };
+  }
+  return map;
+};
+var markdownRoutePaths = (project) => {
+  const paths = project.manifest.routes.map((route) => route.path);
+  return paths.includes("/") ? paths : [...paths, "/"];
+};
+
+// src/search/documents.ts
+import { markdownToMdast, mdxToMdast as mdxToMdast2 } from "satteri";
+
+// src/markdown/fence-meta.ts
+var QUOTED_ATTR = /[\w-]+=(?:"[^"]*"|'[^']*')/gu;
+var LINE_RANGE = /\{[^}]*\}/u;
+var META_TOKEN = new RegExp(`${QUOTED_ATTR.source}|${LINE_RANGE.source}|\\S+`, "gu");
+var metaTokens = (meta) => meta?.match(META_TOKEN) ?? [];
+var RESERVED_META_KEYWORDS = new Set([
+  "lineNumbers",
+  "ts2js",
+  "twoslash"
+]);
+var isLineRange = (token) => token.startsWith("{");
+
+// src/markdown/code-title.ts
+var TITLE_ATTR = /(?:^|\s)title=(?:"(?<dq>[^"]*)"|'(?<sq>[^']*)')/u;
+var isTitleToken = (token) => token.length > 0 && !isLineRange(token) && !token.includes("=") && !RESERVED_META_KEYWORDS.has(token);
+var parseCodeTitle = (raw) => {
+  if (!raw) {
+    return;
+  }
+  const scrubbed = raw.replace(QUOTED_ATTR, (attr) => attr.startsWith("title=") ? attr : " ");
+  const explicit = scrubbed.match(TITLE_ATTR);
+  const attrTitle = explicit?.groups?.dq ?? explicit?.groups?.sq;
+  if (attrTitle) {
+    return attrTitle;
+  }
+  return metaTokens(raw).find(isTitleToken);
+};
+
+// src/search/facets.ts
+var isFacetValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+var pageFacets = (page, config) => {
+  const declared = config.content.types[page.contentType]?.facets;
+  if (!declared || declared.length === 0 || !page.custom) {
+    return;
+  }
+  const facets = {};
+  for (const key of declared) {
+    const value = page.custom[key];
+    if (isFacetValue(value)) {
+      facets[key] = String(value);
+    }
+  }
+  return Object.keys(facets).length > 0 ? facets : undefined;
+};
+
+// src/search/documents.ts
+var HTML_OR_JSX = /<\/?[a-zA-Z][^\n<>]*>|<\/?>/gu;
+var WHITESPACE = /\s+/gu;
+var INLINE_PARENTS = new Set([
+  "delete",
+  "emphasis",
+  "footnoteReference",
+  "link",
+  "linkReference",
+  "mdxJsxTextElement",
+  "strong",
+  "subscript",
+  "superscript",
+  "textDirective"
+]);
+var NON_PROSE = new Set([
+  "image",
+  "imageReference",
+  "inlineMath",
+  "math",
+  "mdxFlowExpression",
+  "mdxTextExpression",
+  "mdxjsEsm"
+]);
+var MD_PARSE = { features: { ...MARKDOWN_FEATURES, frontmatter: false } };
+var MDX_PARSE = { features: { ...MDX_FEATURES, frontmatter: false } };
+var parseMdx = (markdown) => {
+  try {
+    return mdxToMdast2(markdown, MDX_PARSE);
+  } catch {
+    return;
+  }
+};
+var parseMarkdown = (markdown, format) => format === "mdx" ? parseMdx(markdown) : markdownToMdast(markdown, MD_PARSE);
+var collectCode = (node, out, walk) => {
+  if (!walk.includeCodeBlocks) {
+    return;
+  }
+  const title = parseCodeTitle(node.meta ?? undefined);
+  if (title) {
+    out.push(title, " ");
+  }
+  out.push(node.value, " ");
+};
+var separatesWords = (node) => !INLINE_PARENTS.has(node.type) || node.children.length === 0;
+var collectText = (node, out, walk) => {
+  if (NON_PROSE.has(node.type)) {
+    return;
+  }
+  switch (node.type) {
+    case "code": {
+      collectCode(node, out, walk);
+      return;
+    }
+    case "mdxJsxFlowElement": {
+      const text = downlevelComponentNode(node, walk.downlevel);
+      if (text !== null) {
+        collectText(markdownToMdast(text, MD_PARSE), out, walk);
+        return;
+      }
+      break;
+    }
+    case "inlineCode": {
+      out.push(node.value);
+      return;
+    }
+    case "html": {
+      out.push(node.value.replaceAll(HTML_COMMENT, " ").replaceAll(HTML_OR_JSX, " "), " ");
+      return;
+    }
+    case "break": {
+      out.push(" ");
+      return;
+    }
+    case "heading": {
+      const last = node.children.at(-1);
+      const trailing = last?.type === "text" ? last : undefined;
+      const inner = [];
+      const kept = trailing ? node.children.slice(0, -1) : node.children;
+      for (const child of kept) {
+        collectText(child, inner, walk);
+      }
+      if (trailing) {
+        const stripped = parseHeadingMarkers(trailing.value).text;
+        const literal = stripped === "" && node.children.length === 1;
+        inner.push(literal ? trailing.value : stripped);
+      }
+      out.push(inner.join("").trimEnd(), " ");
+      return;
+    }
+    default: {
+      break;
+    }
+  }
+  if ("value" in node) {
+    out.push(node.value);
+    return;
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      collectText(child, out, walk);
+    }
+    if (separatesWords(node)) {
+      out.push(" ");
+    }
+  }
+};
+var toPlainText = (markdown, format, walk) => {
+  const tree = parseMarkdown(markdown, format);
+  if (!tree) {
+    return "";
+  }
+  const out = [];
+  collectText(tree, out, walk);
+  return out.join("").replaceAll(WHITESPACE, " ").trim();
+};
+var buildCrumbIndex = (sidebar) => {
+  const index = new Map;
+  const groupRoutes = new Map;
+  const walk = (nodes, trail) => {
+    for (const node of nodes) {
+      if (node.kind === "group") {
+        if (node.route && !groupRoutes.has(node.route)) {
+          groupRoutes.set(node.route, {
+            breadcrumb: [...trail, node.label],
+            section: node.label
+          });
+        }
+        walk(node.children, [...trail, node.label]);
+      } else if (node.route) {
+        index.set(node.route, {
+          breadcrumb: trail,
+          section: trail.at(-1) ?? ""
+        });
+      }
+    }
+  };
+  walk(sidebar, []);
+  for (const [route, crumbs] of groupRoutes) {
+    if (!index.has(route)) {
+      index.set(route, crumbs);
+    }
+  }
+  return index;
+};
+var pageBody = async (project, page, options, components) => {
+  if (!page) {
+    return "";
+  }
+  const parsed = frontmatter_default(await readExpandedEntryText(project, page));
+  const visible = applyAudienceVisibility(parsed.content, options?.audience ?? "web");
+  if (options?.content === "markdown") {
+    return downlevelComponents(visible.trim(), components, parsed.data);
+  }
+  return toPlainText(visible, page.format, {
+    downlevel: {
+      frontmatter: parsed.data,
+      registry: componentRegistry(components),
+      source: visible
+    },
+    includeCodeBlocks: project.config.search.indexing.includeCodeBlocks
+  });
+};
+var buildSearchDocuments = async (project, options) => {
+  const pageById = new Map(project.graph.pages.map((page) => [page.id, page]));
+  const byLocale = Object.values(project.graph.navigationByLocale ?? {});
+  const byVersion = Object.values(project.graph.navigationByVersion ?? {}).flatMap((locales) => Object.values(locales)).map((nav) => nav.sidebar);
+  const sidebars = [
+    ...byLocale.length > 0 ? byLocale.map((nav) => nav.sidebar) : [project.graph.navigation?.sidebar ?? []],
+    ...byVersion
+  ];
+  const crumbs = new Map;
+  for (const sidebar of sidebars) {
+    for (const [route, crumb] of buildCrumbIndex(sidebar)) {
+      crumbs.set(route, crumb);
+    }
+  }
+  const indexable = project.manifest.routes.filter((route) => {
+    if (!options?.includeWhenDisabled) {
+      return route.indexable;
+    }
+    const page = pageById.get(route.id);
+    return page ? contentIndexable(page, project.config) : false;
+  });
+  const components = projectComponentSerializers(project);
+  return await Promise.all(indexable.map(async (route) => {
+    const page = pageById.get(route.id);
+    const body = await pageBody(project, page, options, components);
+    const tags = page?.meta?.search?.tags;
+    const crumb = crumbs.get(route.path);
+    const facets = page ? pageFacets(page, project.config) : undefined;
+    const document = {
+      breadcrumb: crumb?.breadcrumb ?? [],
+      content: body,
+      contentType: route.contentType,
+      description: page?.description ?? "",
+      locale: route.locale,
+      route: route.path,
+      section: crumb?.section || "Docs",
+      tags: tags && tags.length > 0 ? tags : undefined,
+      title: route.title,
+      version: route.version
+    };
+    if (facets) {
+      document.facets = facets;
+    }
+    return document;
+  }));
+};
+
+// src/ai/mcp/data.ts
+var buildMcpData = async (project) => {
+  const { config, graph, manifest } = project;
+  const [documents, rawMarkdown] = await Promise.all([
+    buildSearchDocuments(project, {
+      audience: "agents",
+      includeWhenDisabled: true
+    }),
+    buildRawMarkdown(project)
+  ]);
+  const pages = Object.fromEntries(Object.entries(rawMarkdown).map(([route, entry]) => [
+    route,
+    agentMarkdown(entry)
+  ]));
+  const pageById = new Map(graph.pages.map((page) => [page.id, page]));
+  const routes = [];
+  for (const route of manifest.routes) {
+    if (route.hidden) {
+      continue;
+    }
+    const page = pageById.get(route.id);
+    const facets = page ? pageFacets(page, config) : undefined;
+    const entry = {
+      contentType: route.contentType,
+      description: page?.description,
+      indexable: route.indexable,
+      lastModified: route.lastModified ?? null,
+      locale: route.locale,
+      route: route.path,
+      title: route.title,
+      version: route.version
+    };
+    if (facets) {
+      entry.facets = facets;
+    }
+    routes.push(entry);
+  }
+  const data = {
+    base: normalizeBasePath(config.deployment.base),
+    defaultLocale: config.i18n?.defaultLocale,
+    documents: documents.map((doc) => {
+      const document = {
+        content: doc.content,
+        contentType: doc.contentType,
+        description: doc.description,
+        locale: doc.locale,
+        route: doc.route,
+        title: doc.title,
+        version: doc.version
+      };
+      if (doc.facets) {
+        document.facets = doc.facets;
+      }
+      return document;
+    }),
+    instructions: config.ai.mcp.instructions,
+    name: config.ai.mcp.name ?? config.title,
+    navigation: graph.navigation,
+    pages,
+    routes,
+    site: config.deployment.site ?? null,
+    version: manifest.blumeVersion
+  };
+  if (config.versions) {
+    data.archivedVersions = config.versions.archived.map((version) => version.id);
+    data.navigationByVersion = graph.navigationByVersion;
+  }
+  if (config.i18n) {
+    data.navigationByLocale = graph.navigationByLocale;
+  }
+  return data;
+};
+
+export { buildRssFeeds, renderRssFeed, agentMarkdown, markdownTokenCount, buildRawMarkdown, markdownRoutePaths, buildSearchDocuments, buildMcpData };
+
+//# debugId=8258B61E89F8EE8E64756E2164756E21
+//# sourceMappingURL=chunk-ynacq3ev.js.map