@lupinum/ginko-content 0.1.2 → 0.1.3

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

@@ -0,0 +1,273 @@
+import { getRequestURL } from "h3";
+import { linkMarkdown, queryMarkdownEnabledContent, resolveContentMarkdownByRoute } from "./agent-markdown.js";
+import { agentMarkdownPathForRoute, agentRawPathForRoute, agentRoutePathFromIndexSlug, agentRoutePathFromRawSlug, normalizeAgentRoutePath } from "../agent-paths.js";
+import { contentConfig } from "./storage-access.js";
+const localizedValue = (value, locale, fallback = "") => {
+  if (typeof value === "string") return value;
+  if (!value) return fallback;
+  return value[locale] || value[defaultLocale()] || Object.values(value)[0] || fallback;
+};
+const defaultLocale = () => contentConfig().agent?.site?.defaultLocale || contentConfig().defaultLocale || contentConfig().locales?.[0] || "en";
+export const getAgentLocales = () => {
+  const site = contentConfig().agent?.site;
+  const locales = site?.locales?.length ? site.locales : contentConfig().locales;
+  return locales?.length ? locales : [defaultLocale()];
+};
+export const isSupportedAgentLocale = (locale) => Boolean(locale && getAgentLocales().includes(locale));
+const resolveSiteUrl = (event) => {
+  const configured = contentConfig().agent?.site?.url;
+  if (configured) return configured;
+  if (event && !import.meta.prerender) {
+    const url = getRequestURL(event);
+    return `${url.protocol}//${url.host}`;
+  }
+  return "http://localhost:3000";
+};
+const joinUrl = (base, path) => new URL(normalizeAgentRoutePath(path), base).toString();
+const prefixLocale = (path, locale) => {
+  const normalized = normalizeAgentRoutePath(path);
+  if (locale === defaultLocale()) return normalized;
+  if (normalized === `/${locale}` || normalized.startsWith(`/${locale}/`)) return normalized;
+  if (normalized === "/") return `/${locale}`;
+  return `/${locale}${normalized}`;
+};
+const sectionConfig = (id) => {
+  const sections = contentConfig().agent?.sections || [];
+  return sections.find((section) => section.id === id);
+};
+const resolveSection = (id, locale) => {
+  const resolvedId = id || "content";
+  const section = sectionConfig(resolvedId);
+  return {
+    id: resolvedId,
+    title: localizedValue(section?.title, locale, resolvedId === "content" ? "Content" : resolvedId),
+    order: section?.order ?? 1e3
+  };
+};
+const collectionSectionId = (collection) => contentConfig().collections?.[collection]?.agent?.section || "content";
+const resolveLocalizedMaybeFunction = async (value, ctx) => {
+  if (typeof value === "function") return await value(ctx);
+  return localizedValue(value, ctx.locale);
+};
+const resolveAppPageRoute = (page, locale) => normalizeAgentRoutePath(localizedValue(page.route, locale, "/"));
+const createAppPageContext = (locale, siteUrl) => ({
+  locale,
+  defaultLocale: defaultLocale(),
+  siteUrl
+});
+const metadataPolicy = () => {
+  const metadata = contentConfig().agent?.markdown?.metadata;
+  if (metadata === false) return { enabled: false, defaultFields: [] };
+  if (Array.isArray(metadata)) return { enabled: true, defaultFields: metadata };
+  return {
+    enabled: metadata?.enabled !== false,
+    defaultFields: Array.isArray(metadata?.defaultFields) ? metadata.defaultFields : []
+  };
+};
+const createGinkoAgentPage = (meta, locale, siteUrl) => {
+  const path = prefixLocale(meta.path, locale);
+  const rawPath = agentRawPathForRoute(path);
+  const section = resolveSection(collectionSectionId(meta.collection), locale);
+  return {
+    title: meta.title,
+    description: meta.description,
+    path,
+    markdownPath: agentMarkdownPathForRoute(path),
+    rawPath,
+    url: joinUrl(siteUrl, path),
+    markdownUrl: joinUrl(siteUrl, rawPath),
+    section: section.id,
+    sectionTitle: section.title,
+    sectionOrder: section.order,
+    locale,
+    source: "ginko",
+    collection: meta.collection,
+    updated: meta.lastModified,
+    metadataFields: meta.metadataFields,
+    includeInIndex: meta.includeInIndex,
+    includeInFull: meta.includeInFull
+  };
+};
+const createAppOwnedAgentPages = async (locale, siteUrl) => {
+  const pages = contentConfig().agent?.pages || [];
+  const result = [];
+  for (const page of pages) {
+    const ctx = createAppPageContext(locale, siteUrl);
+    const path = resolveAppPageRoute(page, locale);
+    const rawPath = agentRawPathForRoute(path);
+    const section = resolveSection(page.section, locale);
+    result.push({
+      title: await resolveLocalizedMaybeFunction(page.title, ctx),
+      description: await resolveLocalizedMaybeFunction(page.description, ctx),
+      path,
+      markdownPath: agentMarkdownPathForRoute(path),
+      rawPath,
+      url: joinUrl(siteUrl, path),
+      markdownUrl: joinUrl(siteUrl, rawPath),
+      section: section.id,
+      sectionTitle: section.title,
+      sectionOrder: section.order,
+      locale,
+      source: "app-owned",
+      updated: page.updated,
+      metadataFields: page.metadata,
+      includeInIndex: page.includeInIndex !== false,
+      includeInFull: page.includeInFull !== false,
+      markdown: await page.render(ctx)
+    });
+  }
+  return result;
+};
+const sortPages = (pages) => pages.sort((a, b) => {
+  const sectionDelta = a.sectionOrder - b.sectionOrder;
+  if (sectionDelta) return sectionDelta;
+  return a.path.localeCompare(b.path);
+});
+const assertUniqueAgentPages = (pages) => {
+  const seen = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    for (const [kind, value] of [
+      ["route", page.path],
+      ["raw route", page.rawPath],
+      ["markdown route", page.markdownPath]
+    ]) {
+      const key = `${kind}:${value}`;
+      const existing = seen.get(key);
+      if (existing) {
+        throw new Error(
+          `Duplicate agent ${kind} "${value}" for "${existing.title}" (${existing.source}) and "${page.title}" (${page.source}). Every agent-facing page must have one canonical route.`
+        );
+      }
+      seen.set(key, page);
+    }
+  }
+};
+export const buildAgentPageIndex = async (event, locale = defaultLocale()) => {
+  const siteUrl = resolveSiteUrl(event);
+  const content = await queryMarkdownEnabledContent(event, { locale });
+  const pages = [
+    ...await createAppOwnedAgentPages(locale, siteUrl),
+    ...content.map((meta) => createGinkoAgentPage(meta, locale, siteUrl))
+  ];
+  assertUniqueAgentPages(pages);
+  return sortPages(pages);
+};
+const sourceLabel = (source) => source === "ginko" ? "ginko-content" : "app-owned";
+const metadataForPage = (page) => ({
+  title: page.title,
+  description: page.description,
+  url: page.url,
+  route: page.path,
+  locale: page.locale,
+  section: page.sectionTitle,
+  collection: page.collection,
+  source: sourceLabel(page.source),
+  updated: page.updated
+});
+const quoteYamlString = (value) => JSON.stringify(value);
+const renderYamlValue = (value) => {
+  if (Array.isArray(value)) {
+    if (!value.length) return "[]";
+    return value.map((entry) => `
+  - ${quoteYamlString(entry)}`).join("");
+  }
+  return quoteYamlString(value);
+};
+export const renderAgentMarkdownFrontmatter = (page) => {
+  const policy = metadataPolicy();
+  if (!policy.enabled) return "";
+  const fields = page.metadataFields?.length ? page.metadataFields : policy.defaultFields;
+  const metadata = metadataForPage(page);
+  const lines = fields.flatMap((field) => {
+    const value = metadata[field];
+    return value ? [`${field}: ${renderYamlValue(value)}`] : [];
+  });
+  return lines.length ? `---
+${lines.join("\n")}
+---
+
+` : "";
+};
+export const renderAgentMarkdownPage = (page, markdown) => `${renderAgentMarkdownFrontmatter(page)}${markdown.trim()}
+`;
+export const renderLlmsTxt = (pages, locale = defaultLocale()) => {
+  const site = contentConfig().agent?.site;
+  const visible = pages.filter((page) => page.includeInIndex);
+  const sections = /* @__PURE__ */ new Map();
+  for (const page of visible) {
+    const entry = sections.get(page.section) || { title: page.sectionTitle, order: page.sectionOrder, pages: [] };
+    entry.pages.push(page);
+    sections.set(page.section, entry);
+  }
+  const lines = [
+    `# ${localizedValue(site?.title, locale, "Site")}`,
+    "",
+    `> ${localizedValue(site?.description, locale, "")}`
+  ];
+  if (site?.profile) lines.push("", `Profile: ${site.profile}`);
+  if (site?.contentSignals) {
+    lines.push(
+      `AI input: ${site.contentSignals.aiInput ? "yes" : "no"}`,
+      `AI training: ${site.contentSignals.aiTrain ? "yes" : "no"}`
+    );
+  }
+  for (const section of Array.from(sections.values()).sort((a, b) => a.order - b.order || a.title.localeCompare(b.title))) {
+    lines.push("", `## ${section.title}`, "");
+    for (const page of section.pages) {
+      lines.push(`- ${linkMarkdown(page.title, page.markdownUrl)}: ${page.description.replace(/\n+/g, " ")}`);
+    }
+  }
+  return `${lines.join("\n").trim()}
+`;
+};
+export const resolveMarkdownForPublicRoute = async (event, routePath, locale = localeFromAgentPath(routePath)) => {
+  const siteUrl = resolveSiteUrl(event);
+  const normalized = normalizeAgentRoutePath(routePath);
+  const appPage = (await createAppOwnedAgentPages(locale, siteUrl)).find((page) => page.path === normalized);
+  if (appPage?.markdown) {
+    return { markdown: renderAgentMarkdownPage(appPage, appPage.markdown) };
+  }
+  const ginkoPage = await resolveContentMarkdownByRoute(event, normalized, { locale });
+  if (!ginkoPage) return null;
+  return {
+    ...ginkoPage,
+    markdown: renderAgentMarkdownPage(createGinkoAgentPage(ginkoPage, locale, siteUrl), ginkoPage.markdown)
+  };
+};
+export const renderLlmsFullTxt = async (event, locale = defaultLocale()) => {
+  const pages = await buildAgentPageIndex(event, locale);
+  const lines = [renderLlmsTxt(pages, locale).trim()];
+  for (const page of pages.filter((page2) => page2.includeInFull)) {
+    const markdown = page.markdown ? renderAgentMarkdownPage(page, page.markdown) : (await resolveMarkdownForPublicRoute(event, page.path, locale))?.markdown;
+    if (!markdown) continue;
+    lines.push("", "---", "", `Source: ${page.url}`, "", markdown.trim());
+  }
+  return `${lines.join("\n").trim()}
+`;
+};
+export const localeFromAgentPath = (path) => {
+  const normalized = normalizeAgentRoutePath(path);
+  const fallback = defaultLocale();
+  for (const locale of getAgentLocales()) {
+    if (locale !== fallback && (normalized === `/${locale}` || normalized.startsWith(`/${locale}/`))) {
+      return locale;
+    }
+  }
+  return fallback;
+};
+export const routePathFromRawSlug = agentRoutePathFromRawSlug;
+export const routePathFromIndexSlug = agentRoutePathFromIndexSlug;
+export const collectAgentMarkdownPrerenderRoutes = async (event) => {
+  const routes = /* @__PURE__ */ new Set();
+  for (const locale of getAgentLocales()) {
+    const pages = await buildAgentPageIndex(event, locale);
+    for (const page of pages) {
+      routes.add(page.rawPath);
+      routes.add(page.markdownPath);
+    }
+    const prefix = locale === defaultLocale() ? "" : `/${locale}`;
+    routes.add(prefix ? `${prefix}/llms.txt` : "/llms.txt");
+    routes.add(prefix ? `${prefix}/llms-full.txt` : "/llms-full.txt");
+  }
+  return Array.from(routes);
+};

package/dist/runtime/server/api/agent-llms

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

package/dist/runtime/server/api/agent-llms-full

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

package/dist/runtime/server/api/agent-llms-full.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/api/agent-llms-full.js

@@ -0,0 +1,13 @@
+import { createError, defineEventHandler } from "h3";
+import { isSupportedAgentLocale, localeFromAgentPath, renderLlmsFullTxt } from "../agent-site.js";
+import { setAgentMarkdownHeaders } from "../agent-http.js";
+export default defineEventHandler(async (event) => {
+  const path = event.node.req.url?.replace(/\?.*$/, "") || "/";
+  const explicitLocale = /^\/([^/]+)\/llms-full\.txt$/i.exec(path)?.[1];
+  if (explicitLocale && !isSupportedAgentLocale(explicitLocale)) {
+    throw createError({ statusCode: 404, statusMessage: "Agent locale not found" });
+  }
+  const locale = localeFromAgentPath(path);
+  setAgentMarkdownHeaders(event);
+  return renderLlmsFullTxt(event, locale);
+});

package/dist/runtime/server/api/agent-llms.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/api/agent-llms.js

@@ -0,0 +1,14 @@
+import { createError, defineEventHandler } from "h3";
+import { localeFromAgentPath, renderLlmsTxt, buildAgentPageIndex, isSupportedAgentLocale } from "../agent-site.js";
+import { appendResponseHeader, setAgentMarkdownHeaders } from "../agent-http.js";
+export default defineEventHandler(async (event) => {
+  const path = event.node.req.url?.replace(/\?.*$/, "") || "/";
+  const explicitLocale = /^\/([^/]+)\/llms\.txt$/i.exec(path)?.[1];
+  if (explicitLocale && !isSupportedAgentLocale(explicitLocale)) {
+    throw createError({ statusCode: 404, statusMessage: "Agent locale not found" });
+  }
+  const locale = localeFromAgentPath(path);
+  setAgentMarkdownHeaders(event);
+  appendResponseHeader(event, "link", `<${path.replace(/llms\.txt$/i, "llms-full.txt")}>; rel="alternate"; type="text/markdown"`);
+  return renderLlmsTxt(await buildAgentPageIndex(event, locale), locale);
+});

package/dist/runtime/server/api/agent-raw

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

package/dist/runtime/server/api/agent-raw.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/api/agent-raw.js

@@ -0,0 +1,17 @@
+import { createError, defineEventHandler } from "h3";
+import { localeFromAgentPath, resolveMarkdownForPublicRoute, routePathFromRawSlug } from "../agent-site.js";
+import { setAgentMarkdownHeaders } from "../agent-http.js";
+import { isUnsafeAgentRoutePath } from "../../agent-paths.js";
+export default defineEventHandler(async (event) => {
+  const routePath = routePathFromRawSlug(event.context.params?.slug);
+  if (isUnsafeAgentRoutePath(routePath)) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid markdown route path" });
+  }
+  const locale = localeFromAgentPath(routePath);
+  const page = await resolveMarkdownForPublicRoute(event, routePath, locale);
+  if (!page) {
+    throw createError({ statusCode: 404, statusMessage: "Markdown page not found" });
+  }
+  setAgentMarkdownHeaders(event, { noindex: true });
+  return page.markdown;
+});

package/dist/runtime/server/api/locales.d.ts

@@ -1,6 +1,6 @@
 declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
-    path?: any;
-    canonicalKey: any;
+    path?: string | undefined;
+    canonicalKey: string;
     locale: string;
 }[]>>;
 export default _default;

package/dist/runtime/server/api/locales.js

@@ -1,8 +1,10 @@
 import { createError, defineEventHandler, getQuery } from "h3";
 import { resolveProviderContentVariants } from "../provider-query.js";
 export default defineEventHandler(async (event) => {
-  const identity = typeof getQuery(event).identity === "string" ? getQuery(event).identity : "";
-  const collection = event.context.params?.collection;
+  const query = getQuery(event);
+  const identity = typeof query.identity === "string" ? query.identity : "";
+  const params = event.context.params;
+  const collection = typeof params?.collection === "string" ? params.collection : "";
   if (!collection || !identity) {
     throw createError({
       statusCode: 400,

package/dist/runtime/server/api/navigation.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<import("../../../types").NavItem[]>>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../types").NavItem[]>>;
 export default _default;

package/dist/runtime/server/api/query.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<number | import("../../../types").ParsedContent | import("../../../types").ParsedContent[] | import("../../../types/api").ContentQueryResponse<import("../../../types").ParsedContent> | undefined>>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../types/api").ContentQueryResponse<unknown>>>;
 export default _default;

package/dist/runtime/server/api/query.js

@@ -1,6 +1,9 @@
 import { defineEventHandler } from "h3";
 import { getContentQuery } from "../../utils/query.js";
 import { getContentProvider } from "../providers/index.js";
+import { normalizeProviderQueryResponse } from "../provider-query.js";
 export default defineEventHandler(async (event) => {
-  return await (await getContentProvider(event)).query(event, getContentQuery(event));
+  const query = getContentQuery(event);
+  const provider = await getContentProvider(event);
+  return normalizeProviderQueryResponse(query, await provider.query(event, query), provider.name);
 });

package/dist/runtime/server/api/revalidate.js

@@ -7,7 +7,7 @@ const normalizePath = (path) => {
   const normalized = path.startsWith("/") ? path : `/${path}`;
   return normalized.replace(/\/{2,}/g, "/");
 };
-const normalizeStringList = (value, normalize = (value2) => value2) => Array.isArray(value) ? Array.from(new Set(value.filter((entry) => typeof entry === "string" && entry.trim()).map((entry) => normalize(entry.trim())))) : void 0;
+const normalizeStringList = (value, normalize = (value2) => value2) => Array.isArray(value) ? Array.from(new Set(value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => normalize(entry.trim())))) : void 0;
 const SIGNATURE_TOLERANCE_MS = 5 * 60 * 1e3;
 async function hmacSha256Hex(secret, value) {
   const encoder = new TextEncoder();
@@ -98,7 +98,7 @@ export default defineEventHandler(async (event) => {
     });
   }
   const rawBody = await readRawBody(event).catch(() => void 0);
-  const bodyText = typeof rawBody === "string" ? rawBody : rawBody?.toString();
+  const bodyText = typeof rawBody === "string" ? rawBody : rawBody === void 0 ? void 0 : String(rawBody);
   if (!bodyText) {
     throw createError({
       statusCode: 400,

package/dist/runtime/server/api/site-data.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("..").MaybeContentProviderResult<import("../../../public/provider").ContentProviderSiteDataResponse<unknown>>>>;
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../../public/provider").ContentProviderSiteDataResponse<unknown>>>;
 export default _default;

package/dist/runtime/server/collection-helpers.js

@@ -57,7 +57,7 @@ export async function queryFilesystemCollectionPage(event, collection, routeOrPa
     ...options,
     loadVariantPage: async (input) => {
       try {
-        return await executeFilesystemContentQuery(event, {
+        const response = await executeFilesystemContentQuery(event, {
           collection,
           first: true,
           resolveVariant: {
@@ -66,6 +66,7 @@ export async function queryFilesystemCollectionPage(event, collection, routeOrPa
             fallback: input.fallback
           }
         });
+        return response.result || null;
       } catch (error) {
         if (isNotFoundError(error)) {
           return null;

package/dist/runtime/server/middleware/agent-link-headers

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

package/dist/runtime/server/middleware/agent-link-headers.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

package/dist/runtime/server/middleware/agent-link-headers.js

@@ -0,0 +1,42 @@
+import { defineEventHandler, getRequestURL, setHeader } from "h3";
+import { getAgentLocales, localeFromAgentPath, resolveMarkdownForPublicRoute } from "../agent-site.js";
+import { agentMarkdownPathForRoute, agentRawPathForRoute, normalizeAgentRoutePath } from "../../agent-paths.js";
+import { appendResponseHeader } from "../agent-http.js";
+import { contentConfig } from "../storage-access.js";
+const shouldAdvertise = (pathname) => !pathname.startsWith("/_") && !pathname.startsWith("/api/") && !pathname.endsWith(".css") && !pathname.endsWith(".js") && !pathname.endsWith(".png") && !pathname.endsWith(".jpg") && !pathname.endsWith(".jpeg") && !pathname.endsWith(".webp") && !pathname.endsWith(".svg") && !pathname.endsWith(".ico");
+const canAdvertisePageAlternate = (pathname) => !pathname.endsWith(".md") && !pathname.endsWith(".txt") && !pathname.endsWith(".xml") && !pathname.endsWith(".json");
+export default defineEventHandler(async (event) => {
+  const { pathname } = getRequestURL(event);
+  if (!shouldAdvertise(pathname)) return;
+  const signals = contentConfig().agent?.site?.contentSignals;
+  if (signals) {
+    setHeader(
+      event,
+      "content-signal",
+      [
+        `search=${signals.search ? "yes" : "no"}`,
+        `ai-input=${signals.aiInput ? "yes" : "no"}`,
+        `ai-train=${signals.aiTrain ? "yes" : "no"}`
+      ].join(", ")
+    );
+  }
+  const locale = localeFromAgentPath(pathname);
+  const defaultLocale = contentConfig().agent?.site?.defaultLocale || contentConfig().defaultLocale || getAgentLocales()[0];
+  const prefix = locale && locale !== defaultLocale ? `/${locale}` : "";
+  const page = canAdvertisePageAlternate(pathname) ? await resolveMarkdownForPublicRoute(event, pathname, locale) : null;
+  const pagePath = normalizeAgentRoutePath(pathname);
+  const pageLinks = page ? [
+    `<${agentRawPathForRoute(pagePath)}>; rel="alternate"; type="text/markdown"`,
+    `<${agentMarkdownPathForRoute(pagePath)}>; rel="alternate"; type="text/markdown"`
+  ] : [];
+  appendResponseHeader(
+    event,
+    "link",
+    [
+      ...pageLinks,
+      `<${prefix}/llms.txt>; rel="llms"; type="text/markdown"`,
+      `<${prefix}/llms-full.txt>; rel="alternate"; type="text/markdown"`,
+      '</sitemap.xml>; rel="sitemap"; type="application/xml"'
+    ].join(", ")
+  );
+});

package/dist/runtime/server/middleware/agent-markdown

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

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void>>;
+export default _default;

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

@@ -0,0 +1,43 @@
+import { createError, defineEventHandler, getRequestURL, send } from "h3";
+import {
+  buildAgentPageIndex,
+  getAgentLocales,
+  localeFromAgentPath,
+  renderLlmsTxt,
+  resolveMarkdownForPublicRoute
+} from "../agent-site.js";
+import { acceptsMarkdown, addVaryHeader, setAgentMarkdownHeaders } from "../agent-http.js";
+import { isUnsafeAgentRoutePath, normalizeAgentRoutePath } from "../../agent-paths.js";
+const shouldSkip = (pathname) => pathname.startsWith("/_") || pathname.startsWith("/api/") || pathname.startsWith("/raw/") || pathname === "/robots.txt" || pathname === "/sitemap.xml" || pathname.endsWith(".txt") || pathname.endsWith(".xml") || pathname.endsWith(".json") || pathname.endsWith(".ico") || pathname.endsWith(".png") || pathname.endsWith(".jpg") || pathname.endsWith(".jpeg") || pathname.endsWith(".webp") || pathname.endsWith(".svg") || pathname.endsWith(".css") || pathname.endsWith(".js");
+export default defineEventHandler(async (event) => {
+  const { pathname } = getRequestURL(event);
+  const rawPathname = event.node.req.url?.split("?")[0] || pathname;
+  if (isUnsafeAgentRoutePath(rawPathname)) {
+    throw createError({ statusCode: 400, statusMessage: "Invalid markdown route path" });
+  }
+  if (shouldSkip(pathname)) return;
+  addVaryHeader(event, "accept");
+  if (pathname.endsWith("/index.md")) {
+    const routePath = normalizeAgentRoutePath(pathname.replace(/\/index\.md$/i, "") || "/");
+    if (isUnsafeAgentRoutePath(routePath)) {
+      throw createError({ statusCode: 400, statusMessage: "Invalid markdown route path" });
+    }
+    const locale2 = localeFromAgentPath(routePath);
+    const page2 = await resolveMarkdownForPublicRoute(event, routePath, locale2);
+    if (!page2) return;
+    setAgentMarkdownHeaders(event, { noindex: true });
+    return send(event, page2.markdown, "text/markdown; charset=utf-8");
+  }
+  if (!acceptsMarkdown(event)) return;
+  if (pathname === "/" || getAgentLocales().some((locale2) => pathname === `/${locale2}`)) {
+    const locale2 = localeFromAgentPath(pathname);
+    setAgentMarkdownHeaders(event);
+    return send(event, renderLlmsTxt(await buildAgentPageIndex(event, locale2), locale2), "text/markdown; charset=utf-8");
+  }
+  const locale = localeFromAgentPath(pathname);
+  const page = await resolveMarkdownForPublicRoute(event, pathname, locale);
+  if (page) {
+    setAgentMarkdownHeaders(event);
+    return send(event, page.markdown, "text/markdown; charset=utf-8");
+  }
+});

package/dist/runtime/server/plugins/sitemap.js

@@ -3,6 +3,7 @@ import { getContentRuntimeConfig } from "../runtime-config.js";
 import { GINKO_SITEMAP_SOURCE_NAME, resolveContentSitemapSource } from "../../utils/sitemap-source.js";
 const LEGACY_NUXT_CONTENT_V2_SOURCE = "@nuxt/content@v2:urls";
 export default defineNitroPlugin((nitro) => {
+  ;
   nitro.hooks.hook("sitemap:sources", (ctx) => {
     const runtimeConfig = getContentRuntimeConfig();
     const sitemap = runtimeConfig.public.content?.sitemap;

package/dist/runtime/server/provider-query.d.ts

@@ -3,18 +3,21 @@ import type { ContentCollectionMap } from '@lupinum/ginko-content';
 import type { ParsedContent } from '../../types/content';
 import type { ContentQueryResponse } from '../../types/api';
 import type { CollectionQueryBuilder, ContentQueryBuilderParams, ContentQueryRequest, ResolveContentReferenceOptions } from '../../types/query';
-export declare const normalizeProviderQueryResult: <T>(response: ContentQueryResponse<T> | T[] | T | number | undefined) => T[];
+export declare const normalizeProviderQueryResult: <T>(response: ContentQueryResponse<T>) => T[];
+export declare const normalizeProviderQueryResponse: <T>(params: ContentQueryBuilderParams, response: unknown, providerName?: string) => ContentQueryResponse<T>;
 export declare const resolveProviderContentVariants: (event: H3Event, identity: string, options: ResolveContentReferenceOptions) => Promise<{
-    canonicalKey: any;
+    canonicalKey: string;
     selected: any;
-    variants: (ParsedContent | import(".").ContentProviderResult<number | ParsedContent | ParsedContent[] | ContentQueryResponse<ParsedContent> | undefined>)[];
+    variants: ParsedContent[];
     availableLocales: string[];
-    variantPaths: any;
+    variantPaths: {
+        [k: string]: string;
+    };
     requestedLocale: string | undefined;
     resolvedLocale: any;
     fallback: boolean;
 } | null>;
-export declare const createServerProviderQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryRequest) => Promise<import(".").MaybeContentProviderResult<number | T | ContentQueryResponse<T> | T[] | undefined>>;
+export declare const createServerProviderQueryFetch: <T = ParsedContent>(event: H3Event) => (query: ContentQueryRequest) => Promise<ContentQueryResponse<T>>;
 export declare const createServerContentQuery: <T = ParsedContent>(event: H3Event, query?: string | ContentQueryBuilderParams, ...pathParts: string[]) => import("@lupinum/ginko-content").ContentQueryBuilder<T>;
 export declare function serverQueryCollection<K extends keyof ContentCollectionMap & string>(event: H3Event, collection: K): CollectionQueryBuilder<ContentCollectionMap[K]>;
 export declare function serverQueryCollection<T = ParsedContent>(event: H3Event, collection: string): CollectionQueryBuilder<T>;