@lupinum/ginko-content 0.1.2 → 0.1.3

package/dist/runtime/server/agent-markdown.d.ts

@@ -0,0 +1,83 @@
+import type { H3Event } from 'h3';
+import type { MarkdownNode, ParsedContent } from '../../types/content';
+import type { AgentMetadataField, ContentCollectionConfig } from '../../types/config';
+export interface AgentMarkdownPublicSignals {
+    search?: 'yes' | 'no';
+    aiInput?: 'yes' | 'no';
+    aiTrain?: 'yes' | 'no';
+}
+export interface ResolvedAgentMarkdownOptions {
+    includeInIndex: boolean;
+    includeInFull: boolean;
+    metadata: AgentMetadataField[];
+}
+export interface AgentMarkdown {
+    path: string;
+    markdownPath: string;
+    rawPath: string;
+    locale?: string;
+    collection: string;
+    title: string;
+    description: string;
+    markdown: string;
+    sourceFile?: string;
+    canonicalUrl: string;
+    lastModified?: string;
+    publicSignals?: AgentMarkdownPublicSignals;
+    metadataFields: string[];
+    includeInIndex: boolean;
+    includeInFull: boolean;
+}
+export type AgentMarkdownMeta = Omit<AgentMarkdown, 'markdown'>;
+export interface AgentMarkdownContext {
+    collection: string;
+    page: ParsedContent;
+    path: string;
+    locale?: string;
+    prop: (name: string) => string;
+    props: (node?: MarkdownNode) => Record<string, unknown>;
+    cleanProps: (node?: MarkdownNode) => Record<string, unknown>;
+    children: (node?: MarkdownNode) => string;
+    renderChildren: (node: MarkdownNode) => string;
+    renderNode: (node: MarkdownNode) => string;
+    blockquote: (value: string) => string;
+    jsonFence: (value: unknown) => string;
+    link: (label: string, href: string) => string;
+    omitted: (name: string, reason?: string) => string;
+    xmlComponent: (name: string, props?: Record<string, unknown>, children?: string) => string;
+}
+export type AgentMarkdownSerializer = (node: MarkdownNode, ctx: AgentMarkdownContext) => string | null | undefined;
+export type AgentMarkdownSerializerMap = Record<string, AgentMarkdownSerializer>;
+export interface AgentMarkdownSerializerRegistrationOptions {
+    override?: boolean;
+}
+export interface AgentMarkdownComponent {
+    render: AgentMarkdownSerializer;
+}
+export type AgentMarkdownComponentMap = Record<string, AgentMarkdownComponent>;
+export declare const getMarkdownProp: (node: MarkdownNode, name: string) => string;
+export declare const renderMarkdownChildren: (node: MarkdownNode, ctx: AgentMarkdownContext) => string;
+export declare const blockquoteMarkdown: (value: string) => string;
+export declare const linkMarkdown: (label: string, href: string) => string;
+export declare const imageMarkdown: (alt: string, src: string) => string;
+export declare const jsonFenceMarkdown: (value: unknown) => string;
+export declare const xmlComponentMarkdown: (name: string, props?: Record<string, unknown>, children?: string) => string;
+export declare const registerAgentMarkdownSerializer: (name: string, serializer: AgentMarkdownSerializer, options?: AgentMarkdownSerializerRegistrationOptions) => void;
+export declare const registerAgentMarkdownSerializers: (entries: AgentMarkdownSerializerMap, options?: AgentMarkdownSerializerRegistrationOptions) => void;
+export declare const defineAgentMarkdownComponent: (component: AgentMarkdownComponent) => AgentMarkdownComponent;
+export declare const registerAgentMarkdownComponent: (name: string, component: AgentMarkdownComponent, options?: AgentMarkdownSerializerRegistrationOptions) => void;
+export declare const registerAgentMarkdownComponents: (entries: AgentMarkdownComponentMap, options?: AgentMarkdownSerializerRegistrationOptions) => void;
+export declare const clearAgentMarkdownSerializers: () => void;
+export declare const resolveAgentMarkdownOptions: (collection: ContentCollectionConfig | undefined) => ResolvedAgentMarkdownOptions | null;
+export declare function resolveContentMarkdown(event: H3Event, collection: string, routeOrPath?: string, options?: {
+    locale?: string;
+}): Promise<AgentMarkdown | null>;
+export declare function resolveContentMarkdownByRoute(event: H3Event, routePath: string, options?: {
+    locale?: string;
+    collections?: string[];
+}): Promise<AgentMarkdown | null>;
+export declare function queryMarkdownEnabledContent(event: H3Event, options?: {
+    locale?: string;
+    collections?: string[];
+    limit?: number;
+}): Promise<AgentMarkdownMeta[]>;

package/dist/runtime/server/agent-markdown.js

@@ -0,0 +1,449 @@
+import { kebabCase, pascalCase } from "scule";
+import { agentMarkdownPathForRoute, agentRawPathForRoute, normalizeAgentRoutePath } from "../agent-paths.js";
+import { getCollectionPath } from "../query/routes.js";
+import { getContentProvider } from "./providers/index.js";
+import { contentConfig } from "./storage-access.js";
+const serializers = /* @__PURE__ */ new Map();
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const defaultLocale = () => contentConfig().defaultLocale || contentConfig().locales?.[0] || contentConfig().agent?.site?.defaultLocale || "en";
+const configuredLocales = () => {
+  const locales = contentConfig().agent?.site?.locales?.length ? contentConfig().agent?.site?.locales : contentConfig().locales;
+  return locales?.length ? locales : [defaultLocale()];
+};
+const prefixLocalizedHref = (path, locale) => {
+  const normalized = normalizeAgentRoutePath(path);
+  if (!locale || locale === defaultLocale()) return normalized;
+  if (configuredLocales().some((candidate) => normalized === `/${candidate}` || normalized.startsWith(`/${candidate}/`))) return normalized;
+  return normalized === "/" ? `/${locale}` : `/${locale}${normalized}`;
+};
+const isExternalHref = (href) => /^[a-z][a-z0-9+.-]*:/i.test(href) || href.startsWith("//");
+const routeMarkdownPathForHref = (href, locale, currentPath = "/") => {
+  const hash = href.match(/#.*$/)?.[0] || "";
+  const withoutHash = href.replace(/#.*$/, "");
+  if (!withoutHash) return href;
+  if (isExternalHref(withoutHash)) return href;
+  if (withoutHash.endsWith(".md")) return href;
+  const target = withoutHash.startsWith("/") ? prefixLocalizedHref(withoutHash, locale) : new URL(withoutHash, `https://agent.local${normalizeAgentRoutePath(currentPath)}`).pathname;
+  return `${agentMarkdownPathForRoute(target)}${hash}`;
+};
+export const getMarkdownProp = (node, name) => {
+  const props = isRecord(node.props) ? node.props : {};
+  const value = props[name];
+  return typeof value === "string" ? value : "";
+};
+export const renderMarkdownChildren = (node, ctx) => ctx.renderChildren(node);
+export const blockquoteMarkdown = (value) => value.trim().split("\n").map((line) => line ? `> ${line}` : ">").join("\n");
+const escapeMarkdownLinkLabel = (value) => value.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+const escapeMarkdownLinkHref = (value) => value.replace(/\)/g, "%29").replace(/\s/g, "%20");
+const isSafeMarkdownHref = (href) => {
+  if (!href) return false;
+  if (href.startsWith("//")) return false;
+  if (href.startsWith("/") || href.startsWith("#") || href.startsWith("./") || href.startsWith("../")) return true;
+  return /^(https?:|mailto:|tel:)/i.test(href);
+};
+export const linkMarkdown = (label, href) => {
+  const resolvedLabel = label || href;
+  if (!href || !isSafeMarkdownHref(href)) return escapeMarkdownLinkLabel(resolvedLabel);
+  return `[${escapeMarkdownLinkLabel(resolvedLabel)}](${escapeMarkdownLinkHref(href)})`;
+};
+export const imageMarkdown = (alt, src) => {
+  if (!src || !isSafeMarkdownHref(src)) return escapeMarkdownLinkLabel(alt || src);
+  return `![${escapeMarkdownLinkLabel(alt)}](${escapeMarkdownLinkHref(src)})`;
+};
+export const jsonFenceMarkdown = (value) => `\`\`\`json
+${JSON.stringify(value, null, 2)}
+\`\`\``;
+const xmlNamePattern = /^[a-z][\w.:-]*$/i;
+const safeXmlName = (name) => xmlNamePattern.test(name) ? name : "component";
+const escapeXmlAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+const isScalarXmlAttributeValue = (value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+const shouldDropAgentProp = (name) => {
+  const normalized = name.trim();
+  const sensitive = normalized.toLowerCase();
+  return !normalized || normalized === "class" || normalized === "style" || normalized === "key" || normalized === "ref" || normalized.startsWith("v-") || normalized.startsWith("@") || normalized.startsWith("on") || normalized.startsWith("data-") || normalized.startsWith("aria-") || /token|secret|password|passwd|credential|authorization|apikey|api-key|clientsecret|client-secret|privatekey|private-key|accesskey|access-key/i.test(sensitive);
+};
+const normalizeAgentPropName = (name) => {
+  const normalized = name.trim();
+  if (normalized.startsWith(":")) return normalized.slice(1);
+  if (normalized.startsWith("v-bind:")) return normalized.slice("v-bind:".length);
+  return normalized;
+};
+const cleanAgentPropValue = (value) => {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (Array.isArray(value)) {
+    const clean = value.map((entry) => cleanAgentPropValue(entry)).filter((entry) => entry !== void 0);
+    return clean.length ? clean : void 0;
+  }
+  if (isRecord(value)) {
+    const clean = cleanPropsObject(value);
+    return Object.keys(clean).length ? clean : void 0;
+  }
+  return value;
+};
+const cleanPropsObject = (props) => {
+  if (!isRecord(props)) return {};
+  const clean = {};
+  for (const [name, value] of Object.entries(props)) {
+    const normalizedName = normalizeAgentPropName(name);
+    const cleanedValue = cleanAgentPropValue(value);
+    if (shouldDropAgentProp(normalizedName) || cleanedValue === void 0) continue;
+    if (!(normalizedName in clean) || normalizedName === name.trim()) {
+      clean[normalizedName] = cleanedValue;
+    }
+  }
+  return clean;
+};
+export const xmlComponentMarkdown = (name, props = {}, children = "") => {
+  const tagName = safeXmlName(name);
+  const cleanProps = cleanPropsObject(props);
+  const attrs = [];
+  const complexProps = {};
+  for (const [key, value] of Object.entries(cleanProps)) {
+    if (!xmlNamePattern.test(key)) {
+      complexProps[key] = value;
+      continue;
+    }
+    if (isScalarXmlAttributeValue(value)) {
+      attrs.push(`${key}="${escapeXmlAttribute(String(value))}"`);
+      continue;
+    }
+    complexProps[key] = value;
+  }
+  const attrText = attrs.length ? ` ${attrs.join(" ")}` : "";
+  const bodyParts = [
+    Object.keys(complexProps).length ? jsonFenceMarkdown(complexProps) : "",
+    children.trim()
+  ].filter(Boolean);
+  if (!bodyParts.length) return `<${tagName}${attrText} />`;
+  return `<${tagName}${attrText}>
+${bodyParts.join("\n\n")}
+</${tagName}>`;
+};
+export const registerAgentMarkdownSerializer = (name, serializer, options = {}) => {
+  const existing = serializers.get(name);
+  if (existing === serializer && !options.override) return;
+  if (existing && !options.override) {
+    throw new Error(
+      `Agent Markdown serializer "${name}" is already registered. Use { override: true } only when replacing an existing serializer intentionally.`
+    );
+  }
+  serializers.set(name, serializer);
+};
+export const registerAgentMarkdownSerializers = (entries, options = {}) => {
+  for (const [name, serializer] of Object.entries(entries)) {
+    registerAgentMarkdownSerializer(name, serializer, options);
+  }
+};
+export const defineAgentMarkdownComponent = (component) => component;
+export const registerAgentMarkdownComponent = (name, component, options = {}) => {
+  registerAgentMarkdownSerializer(name, component.render, options);
+};
+export const registerAgentMarkdownComponents = (entries, options = {}) => {
+  for (const [name, component] of Object.entries(entries)) {
+    registerAgentMarkdownComponent(name, component, options);
+  }
+};
+export const clearAgentMarkdownSerializers = () => {
+  serializers.clear();
+};
+export const resolveAgentMarkdownOptions = (collection) => {
+  if (!collection || collection.type === "data") return null;
+  const value = collection.agent?.markdown;
+  if (value === true) {
+    return {
+      includeInIndex: true,
+      includeInFull: true,
+      metadata: []
+    };
+  }
+  if (!value || !isRecord(value)) return null;
+  return {
+    includeInIndex: value.includeInIndex !== false,
+    includeInFull: value.includeInFull !== false,
+    metadata: Array.isArray(value.metadata) ? value.metadata.filter((field) => typeof field === "string" && field.length > 0) : []
+  };
+};
+const collectionConfig = (collection) => contentConfig().collections?.[collection];
+const markdownEnabledCollectionEntries = (collections) => Object.entries(contentConfig().collections || {}).filter(([name, config]) => (!collections?.length || collections.includes(name)) && resolveAgentMarkdownOptions(config));
+const isPublicPage = (page, config) => Boolean(
+  page && config && config.type !== "data" && config.sitemap !== false && !page._draft && !page._partial && !page._navigation && page.navigation !== false && page.robots !== "noindex" && page.sitemap !== false
+);
+const escapeMarkdownText = (value) => value.replace(/\*/g, "\\*").replace(/_/g, "\\_").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+const textValue = (node) => {
+  if (node.type === "text") return node.value || "";
+  return (node.children || []).map((child) => textValue(child)).join("");
+};
+const renderChildren = (node, ctx) => (node.children || []).map((child) => renderNode(child, ctx)).join("").trim();
+const block = (value) => value.trim() ? `${value.trim()}
+
+` : "";
+const renderList = (node, ctx, ordered = false) => block((node.children || []).map((child, index) => {
+  const body = renderChildren(child, ctx).replace(/\n+/g, "\n  ").trim();
+  return `${ordered ? `${index + 1}.` : "-"} ${body}`;
+}).join("\n"));
+const renderTable = (node, ctx) => {
+  const rows = (node.children || []).flatMap(
+    (section) => section.tag === "thead" || section.tag === "tbody" ? section.children || [] : [section]
+  ).filter((row) => row.tag === "tr");
+  if (!rows.length) return "";
+  const cells = rows.map(
+    (row) => (row.children || []).filter((cell) => cell.tag === "th" || cell.tag === "td").map((cell) => renderChildren(cell, ctx).replace(/\|/g, "\\|").trim())
+  );
+  const width = Math.max(...cells.map((row) => row.length));
+  const normalized = cells.map((row) => [...row, ...Array.from({ length: width - row.length }, () => "")]);
+  const [head = [], ...bodyRows] = normalized;
+  return block([
+    `| ${head.join(" | ")} |`,
+    `| ${head.map(() => "---").join(" | ")} |`,
+    ...bodyRows.map((row) => `| ${row.join(" | ")} |`)
+  ].join("\n"));
+};
+const renderUnknownComponentOmission = (name, reason) => `> Component omitted: \`${name}\`.
+> ${reason || "This page contains an interactive or site-specific block that has no agent markdown serializer yet."}`;
+const renderUnknownComponent = (node, ctx) => {
+  const tag = node.tag || "component";
+  const props = cleanPropsObject(node.props);
+  const children = renderChildren(node, ctx);
+  if (children || Object.keys(props).length) {
+    return block(xmlComponentMarkdown(tag, props, children));
+  }
+  return block(renderUnknownComponentOmission(tag));
+};
+const serializerForTag = (tag) => {
+  const markdownTags = contentConfig().markdown?.tags || {};
+  const candidates = new Set([
+    tag,
+    pascalCase(tag),
+    kebabCase(tag),
+    markdownTags[tag],
+    markdownTags[pascalCase(tag)],
+    markdownTags[kebabCase(tag)]
+  ].filter((value) => Boolean(value)));
+  for (const candidate of candidates) {
+    const serializer = serializers.get(candidate);
+    if (serializer) return serializer;
+  }
+};
+const renderNode = (node, ctx) => {
+  if (node.type === "text") return node.value || "";
+  const tag = node.tag || "";
+  const serializer = tag ? serializerForTag(tag) : void 0;
+  if (serializer) {
+    const nodeCtx = {
+      ...ctx,
+      prop: (name) => getMarkdownProp(node, name),
+      props: (target) => isRecord((target || node).props) ? (target || node).props : {},
+      cleanProps: (target) => cleanPropsObject((target || node).props),
+      children: (target) => renderChildren(target || node, nodeCtx)
+    };
+    const rendered = serializer(node, nodeCtx);
+    if (typeof rendered === "string") return block(rendered);
+  }
+  if (!tag) return renderChildren(node, ctx);
+  if (/^h[1-6]$/.test(tag)) {
+    const depth = Number(tag.slice(1));
+    return block(`${"#".repeat(Math.max(1, Math.min(6, depth)))} ${renderChildren(node, ctx)}`);
+  }
+  switch (tag) {
+    case "p":
+      return block(renderChildren(node, ctx));
+    case "blockquote":
+      return block(renderChildren(node, ctx).split("\n").map((line) => `> ${line}`).join("\n"));
+    case "strong":
+    case "b":
+      return `**${renderChildren(node, ctx)}**`;
+    case "em":
+    case "i":
+      return `_${renderChildren(node, ctx)}_`;
+    case "span":
+      return renderChildren(node, ctx);
+    case "code":
+      return `\`${node.value || textValue(node)}\``;
+    case "pre":
+      return block(`\`\`\`
+${textValue(node)}
+\`\`\``);
+    case "a": {
+      const href = typeof node.props?.href === "string" ? node.props.href : "";
+      const text = renderChildren(node, ctx) || href;
+      return href ? linkMarkdown(text, routeMarkdownPathForHref(href, ctx.locale, ctx.path)) : text;
+    }
+    case "ul":
+      return renderList(node, ctx);
+    case "ol":
+      return renderList(node, ctx, true);
+    case "li":
+      return renderChildren(node, ctx);
+    case "hr":
+      return "---\n\n";
+    case "br":
+      return "\n";
+    case "img": {
+      const src = typeof node.props?.src === "string" ? node.props.src : "";
+      const alt = typeof node.props?.alt === "string" ? node.props.alt : "";
+      return src ? imageMarkdown(alt, src) : escapeMarkdownLinkLabel(alt);
+    }
+    case "table":
+      return renderTable(node, ctx);
+    case "thead":
+    case "tbody":
+    case "tr":
+    case "th":
+    case "td":
+      return renderChildren(node, ctx);
+    default:
+      return renderUnknownComponent(node, ctx);
+  }
+};
+const renderMarkdownRoot = (body, context) => {
+  if (!body?.children?.length) return "";
+  const ctx = {
+    ...context,
+    prop: () => "",
+    props: (node) => node ? isRecord(node.props) ? node.props : {} : {},
+    cleanProps: (node) => cleanPropsObject(node?.props),
+    children: (node) => node ? renderChildren(node, ctx) : "",
+    renderChildren: (node) => renderChildren(node, ctx),
+    renderNode: (node) => renderNode(node, ctx),
+    blockquote: (value) => blockquoteMarkdown(value),
+    jsonFence: (value) => jsonFenceMarkdown(value),
+    link: (label, href) => linkMarkdown(label, href),
+    omitted: (name, reason) => renderUnknownComponentOmission(name, reason),
+    xmlComponent: (name, props, children) => xmlComponentMarkdown(name, props, children)
+  };
+  return body.children.map((node) => renderNode(node, ctx)).join("").trim();
+};
+const hasH1 = (markdown) => /^#\s+/m.test(markdown);
+const normalizeDescription = (page) => typeof page.description === "string" && page.description.trim() ? page.description.trim() : "";
+const renderAgentMarkdown = (page, collection, path, locale, _options) => {
+  const title = typeof page.title === "string" && page.title.trim() ? page.title.trim() : path.split("/").filter(Boolean).pop() || "Index";
+  const description = normalizeDescription(page);
+  const rendered = renderMarkdownRoot(page.body, { collection, page, path, locale });
+  const parts = [];
+  if (!hasH1(rendered)) parts.push(`# ${escapeMarkdownText(title)}`);
+  if (description && !rendered.includes(description)) parts.push(`> ${description}`);
+  if (rendered) parts.push(rendered);
+  return parts.join("\n\n").trim() + "\n";
+};
+const toAgentMarkdown = (collection, page, options) => {
+  const path = normalizeAgentRoutePath(page.path || page._requestedRoute || page._path);
+  const locale = page.locale || page._resolvedLocale || page._locale;
+  const title = typeof page.title === "string" && page.title.trim() ? page.title.trim() : path.split("/").filter(Boolean).pop() || "Index";
+  const description = normalizeDescription(page);
+  return {
+    path,
+    markdownPath: agentMarkdownPathForRoute(path),
+    rawPath: agentRawPathForRoute(path),
+    ...locale ? { locale } : {},
+    collection,
+    title,
+    description,
+    markdown: renderAgentMarkdown(page, collection, path, locale, options),
+    ...page._file ? { sourceFile: page._file } : {},
+    canonicalUrl: path,
+    ...typeof page.updated === "string" ? { lastModified: page.updated } : {},
+    metadataFields: options.metadata,
+    includeInIndex: options.includeInIndex,
+    includeInFull: options.includeInFull
+  };
+};
+const collectionHandle = (name, config) => ({ ...config, name });
+const routeBaseForLocale = (config, locale) => {
+  if (!config.route) return "";
+  if (typeof config.route === "string") return normalizeAgentRoutePath(config.route);
+  const localized = locale ? config.route[locale] : void 0;
+  return typeof localized === "string" ? normalizeAgentRoutePath(localized) : "";
+};
+const collectionDefaultLocale = (config) => {
+  const collectionI18n = config.i18n && typeof config.i18n === "object" ? config.i18n : void 0;
+  return collectionI18n?.defaultLocale || contentConfig().defaultLocale || contentConfig().agent?.site?.defaultLocale;
+};
+const prefixRequestedLocale = (path, locale, defaultLocale2) => {
+  const normalized = normalizeAgentRoutePath(path);
+  if (!locale || locale === defaultLocale2) return normalized;
+  if (normalized === `/${locale}` || normalized.startsWith(`/${locale}/`)) return normalized;
+  if (normalized === "/") return `/${locale}`;
+  return `/${locale}${normalized}`;
+};
+const publicPathForLocale = (collection, config, rowPath, locale, defaultLocale2) => {
+  const normalizedRowPath = normalizeAgentRoutePath(rowPath || "/");
+  const base = routeBaseForLocale(config, locale);
+  if (base && (normalizedRowPath === base || normalizedRowPath.startsWith(`${base}/`))) {
+    return prefixRequestedLocale(normalizedRowPath, locale, defaultLocale2);
+  }
+  return getCollectionPath(collectionHandle(collection, config), {
+    ...locale ? { locale } : {},
+    path: normalizedRowPath
+  });
+};
+const publicPathForQueryRow = (collection, config, row, locale) => {
+  const requested = row.path || row._requestedRoute;
+  if (requested) return normalizeAgentRoutePath(requested);
+  const defaultLocale2 = collectionDefaultLocale(config);
+  const rowPath = normalizeAgentRoutePath(row._path || "/");
+  const resolvedLocale = row._resolvedLocale || row._locale;
+  if (locale && resolvedLocale && locale !== resolvedLocale) {
+    const sourceLocalePath = publicPathForLocale(collection, config, rowPath, resolvedLocale, defaultLocale2);
+    return prefixRequestedLocale(sourceLocalePath, locale, defaultLocale2);
+  }
+  return publicPathForLocale(collection, config, rowPath, locale, defaultLocale2);
+};
+export async function resolveContentMarkdown(event, collection, routeOrPath = "/", options = {}) {
+  const config = collectionConfig(collection);
+  const agentOptions = resolveAgentMarkdownOptions(config);
+  if (!config || !agentOptions) return null;
+  const provider = await getContentProvider(event);
+  if (!provider.page) return null;
+  const page = await provider.page(event, collection, routeOrPath, {
+    ...options.locale ? { locale: options.locale } : {}
+  });
+  if (!page || !isPublicPage(page, config)) return null;
+  return toAgentMarkdown(collection, page, agentOptions);
+}
+export async function resolveContentMarkdownByRoute(event, routePath, options = {}) {
+  for (const [collection] of markdownEnabledCollectionEntries(options.collections)) {
+    const page = await resolveContentMarkdown(event, collection, routePath, {
+      ...options.locale ? { locale: options.locale } : {}
+    });
+    if (page) return page;
+  }
+  return null;
+}
+const normalizeQueryResult = (value) => Array.isArray(value.result) ? value.result : [];
+export async function queryMarkdownEnabledContent(event, options = {}) {
+  const provider = await getContentProvider(event);
+  const result = [];
+  for (const [collection, config] of markdownEnabledCollectionEntries(options.collections)) {
+    const agentOptions = resolveAgentMarkdownOptions(config);
+    if (!agentOptions) continue;
+    const rows = normalizeQueryResult(await provider.query(event, {
+      collection,
+      only: ["path", "locale", "localePaths", "_path", "_locale", "_resolvedLocale", "_requestedRoute", "_file", "_draft", "_partial", "_navigation", "title", "description", "updated", "navigation", "robots", "sitemap"],
+      ...options.limit ? { limit: options.limit } : {},
+      ...options.locale ? { resolveLocale: { locale: options.locale, fallback: true } } : {}
+    }));
+    for (const row of rows) {
+      if (!isPublicPage(row, config)) continue;
+      const locale = options.locale || row._resolvedLocale || row._locale;
+      const path = publicPathForQueryRow(collection, config, row, locale);
+      const title = typeof row.title === "string" && row.title.trim() ? row.title.trim() : path.split("/").filter(Boolean).pop() || "Index";
+      const description = normalizeDescription(row);
+      result.push({
+        path,
+        markdownPath: agentMarkdownPathForRoute(path),
+        rawPath: agentRawPathForRoute(path),
+        ...locale ? { locale } : {},
+        collection,
+        title,
+        description,
+        ...row._file ? { sourceFile: row._file } : {},
+        canonicalUrl: path,
+        ...typeof row.updated === "string" ? { lastModified: row.updated } : {},
+        metadataFields: agentOptions.metadata,
+        includeInIndex: agentOptions.includeInIndex,
+        includeInFull: agentOptions.includeInFull
+      });
+    }
+  }
+  return result;
+}

package/dist/runtime/server/agent-site

@@ -0,0 +1 @@
+export * from './agent-site.js'

package/dist/runtime/server/agent-site.d.ts

@@ -0,0 +1,38 @@
+import type { H3Event } from 'h3';
+import type { AgentMarkdown } from './agent-markdown';
+import type { AgentMetadataField } from '../../types/config';
+export type AgentPageSource = 'ginko' | 'app-owned';
+export interface AgentPage {
+    title: string;
+    description: string;
+    path: string;
+    markdownPath: string;
+    rawPath: string;
+    url: string;
+    markdownUrl: string;
+    section: string;
+    sectionTitle: string;
+    sectionOrder: number;
+    locale: string;
+    source: AgentPageSource;
+    collection?: string;
+    updated?: string;
+    metadataFields?: readonly AgentMetadataField[];
+    includeInIndex: boolean;
+    includeInFull: boolean;
+    markdown?: string;
+}
+export declare const getAgentLocales: () => any;
+export declare const isSupportedAgentLocale: (locale: string | undefined) => boolean;
+export declare const buildAgentPageIndex: (event: H3Event, locale?: any) => Promise<AgentPage[]>;
+export declare const renderAgentMarkdownFrontmatter: (page: AgentPage) => string;
+export declare const renderAgentMarkdownPage: (page: AgentPage, markdown: string) => string;
+export declare const renderLlmsTxt: (pages: AgentPage[], locale?: any) => string;
+export declare const resolveMarkdownForPublicRoute: (event: H3Event, routePath: string, locale?: any) => Promise<AgentMarkdown | {
+    markdown: string;
+} | null>;
+export declare const renderLlmsFullTxt: (event: H3Event, locale?: any) => Promise<string>;
+export declare const localeFromAgentPath: (path: string) => any;
+export declare const routePathFromRawSlug: (slug: string | string[] | undefined) => string;
+export declare const routePathFromIndexSlug: (slug: string | string[] | undefined) => string;
+export declare const collectAgentMarkdownPrerenderRoutes: (event: H3Event) => Promise<string[]>;