@lupinum/ginko-content 0.1.2 → 0.1.3

package/dist/module.mjs

@@ -1,103 +1,37 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { join as join$1, basename, resolve as resolve$1, relative as relative$1, dirname } from 'node:path';
-import { pathToFileURL } from 'node:url';
 import { addTypeTemplate, addImports, addServerImports, addComponentsDir, addPlugin, addServerHandler, defineNuxtModule, createResolver, useLogger, addTemplate } from '@nuxt/kit';
 import { defu } from 'defu';
+import fs, { existsSync } from 'fs';
+import { join, relative, resolve, isAbsolute } from 'pathe';
+import jiti from 'jiti';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+import { genSafeVariableName, genImport } from 'knitwork';
 import { hash } from 'ohash';
-import { resolve, join, relative, isAbsolute } from 'pathe';
-import { withTrailingSlash } from 'ufo';
-import { normalizeContentConfigCollectionNames } from '../dist/types/config';
-export { defineCollection, defineContentConfig, reference } from '../dist/types/config';
 import 'unstorage/drivers/fs';
 import 'unstorage/drivers/http';
 import 'unstorage/drivers/github';
-import { WebSocketServer } from 'ws';
 import { consola } from 'consola';
-import fs, { existsSync } from 'fs';
-import jiti from 'jiti';
-import { createRequire } from 'node:module';
-import { genSafeVariableName, genImport } from 'knitwork';
-import { listen } from 'listhen';
 import { makeIgnored } from '../dist/core/content/ignore';
-import { readFile, readdir } from 'node:fs/promises';
-import { resolveContentSitemapSource, GINKO_SITEMAP_SOURCE_NAME } from '../dist/runtime/utils/sitemap-source';
 import { resolveCollectionI18nConfig } from '../dist/features/localization/config';
+import { readFile, readdir } from 'node:fs/promises';
+import { join as join$1, basename, resolve as resolve$1, relative as relative$1, dirname } from 'node:path';
 import { globby } from 'globby';
-import { transformContent } from '../dist/parsers/index';
-import { expandDataLocaleVariants } from '../dist/core/content/locale';
 import { buildContentGraph } from '../dist/core/content/graph';
+import { expandDataLocaleVariants } from '../dist/core/content/locale';
 import { normalizeCollectionSources, normalizeCollectionExcludes } from '../dist/core/content/sources';
-import { resolveCollectionI18n, prefixPathWithLocale } from '../dist/features/localization/path';
 import { resolveCollection } from '../dist/core/content/collection';
+import { transformContent } from '../dist/parsers/index';
+import { resolveCollectionI18n, prefixPathWithLocale } from '../dist/features/localization/path';
+import { resolveContentSitemapSource, GINKO_SITEMAP_SOURCE_NAME } from '../dist/runtime/utils/sitemap-source';
 import { normalizeRouteMounts, normalizeContentPath } from '../dist/core/content/path';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { withTrailingSlash } from 'ufo';
+import { normalizeContentConfigCollectionNames } from '../dist/types/config';
+export { agentMetadataFields, defineAgentAppPage, defineAgentMarkdownPolicy, defineAgentMetadataFields, defineAgentSection, defineCollection, defineContentConfig, reference } from '../dist/types/config';
 import { collectTopLevelReferenceFieldsByTarget } from '../dist/core/references/schema';
 
 const name = "@lupinum/ginko-content";
-const version = "0.1.2";
-
-const logger = consola.withTag("@lupinum/ginko-content");
-const CACHE_VERSION = 3;
-const MOUNT_PREFIX = "content:source:";
-function useContentMounts(nuxt, storages) {
-  const key = (path, prefix = "") => `${MOUNT_PREFIX}${path.replace(/[/:]/g, "_")}${prefix.replace(/\//g, ":")}`;
-  const baseDir = nuxt.options.future?.compatibilityVersion === 4 ? nuxt.options.rootDir : nuxt.options.srcDir;
-  storages = Object.entries(storages).reduce((mounts, [name, storage]) => {
-    mounts[key(storage.name || name, storage.prefix)] = storage;
-    return mounts;
-  }, {});
-  const defaultStorage = key("content");
-  if (!storages[defaultStorage]) {
-    storages[defaultStorage] = {
-      name: defaultStorage,
-      driver: "fs",
-      base: resolve(baseDir, "content")
-    };
-  }
-  return storages;
-}
-function createWebSocket() {
-  const wss = new WebSocketServer({ noServer: true });
-  const serve = (req, socket = req.socket, head = "") => wss.handleUpgrade(req, socket, head, (client) => wss.emit("connection", client, req));
-  const broadcast = (data) => {
-    data = JSON.stringify(data);
-    for (const client of wss.clients) {
-      try {
-        client.send(data);
-      } catch {
-        logger.debug("Skipping websocket client that is not ready to receive content refresh events.");
-      }
-    }
-  };
-  return {
-    serve,
-    broadcast,
-    close: () => {
-      wss.clients.forEach((client) => client.close());
-      return new Promise((resolve2) => wss.close(resolve2));
-    }
-  };
-}
-function processMarkdownOptions(options) {
-  const anchorLinks = typeof options.anchorLinks === "boolean" ? { depth: options.anchorLinks ? 6 : 0, exclude: [] } : { depth: 4, exclude: [1], ...options.anchorLinks };
-  const plugins = options.plugins?.length ? options.plugins : [
-    ["toc", { depth: 2, searchDepth: 2 }],
-    "summary"
-  ];
-  return {
-    ...options,
-    anchorLinks,
-    plugins: resolveMarkdownPlugins(plugins)
-  };
-}
-function resolveMarkdownPlugins(plugins) {
-  return (plugins || []).map((plugin) => {
-    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
-    return {
-      name,
-      options
-    };
-  });
-}
+const version = "0.1.3";
 
 const CONFIG_FILES = [
   "content.config.ts",
@@ -175,7 +109,7 @@ const createVirtualContentTemplates = (contentContext, nuxt, contentConfigPath,
     write: true,
     getContents: () => {
       const cache = contentContext.cache;
-      if (!cache || cache === false) {
+      if (!cache) {
         return [
           "export const loadContentCacheAdapter = () => undefined",
           "export default {}"
@@ -211,14 +145,66 @@ const registerVirtualContentAliases = (nuxt, transformersTemplate, virtualConfig
   });
 };
 
+consola.withTag("@lupinum/ginko-content");
+const CACHE_VERSION = 3;
+const MOUNT_PREFIX = "content:source:";
+function useContentMounts(nuxt, storages) {
+  const key = (path, prefix = "") => `${MOUNT_PREFIX}${path.replace(/[/:]/g, "_")}${prefix.replace(/\//g, ":")}`;
+  const baseDir = nuxt.options.future?.compatibilityVersion === 4 ? nuxt.options.rootDir : nuxt.options.srcDir;
+  storages = Object.entries(storages).reduce((mounts, [name, storage]) => {
+    mounts[key(storage.name || name, storage.prefix)] = storage;
+    return mounts;
+  }, {});
+  const defaultStorage = key("content");
+  if (!storages[defaultStorage]) {
+    storages[defaultStorage] = {
+      name: defaultStorage,
+      driver: "fs",
+      base: resolve(baseDir, "content")
+    };
+  }
+  return storages;
+}
+function processMarkdownOptions(options) {
+  const anchorLinks = typeof options.anchorLinks === "boolean" ? { depth: options.anchorLinks ? 6 : 0, exclude: [] } : { depth: 4, exclude: [1], ...options.anchorLinks };
+  const plugins = options.plugins?.length ? options.plugins : [
+    ["toc", { depth: 2, searchDepth: 2 }],
+    "summary"
+  ];
+  return {
+    anchorLinks,
+    tags: options.tags || {},
+    image: options.image,
+    plugins: resolveMarkdownPlugins(plugins)
+  };
+}
+function resolveMarkdownPlugins(plugins) {
+  return (plugins || []).map((plugin) => {
+    const [name, options] = Array.isArray(plugin) ? plugin : [plugin, {}];
+    return {
+      name,
+      options
+    };
+  });
+}
+
 const registerContentDevRuntime = (nuxt, options, contentContext) => {
   const isIgnored = makeIgnored(contentContext.ignores);
+  let viteServer;
+  if (options.watch !== false) {
+    nuxt.options.vite ||= {};
+    nuxt.options.vite.plugins ||= [];
+    nuxt.options.vite.plugins.push({
+      name: "ginko-content-hmr",
+      configureServer(server) {
+        viteServer = server;
+      }
+    });
+  }
   nuxt.hook("nitro:init", async (nitro) => {
-    if (!options.watch || !options.watch.ws) {
+    if (options.watch === false) {
       return;
     }
-    const ws = createWebSocket();
-    const { server, url } = await listen(() => "Ginko", options.watch.ws);
     const unwatch = await nitro.storage.watch(async (event, key) => {
       if (!key.startsWith(MOUNT_PREFIX) || isIgnored(key)) {
         return;
@@ -227,56 +213,85 @@ const registerContentDevRuntime = (nuxt, options, contentContext) => {
       await nitro.storage.removeItem("cache:content:_manifest.json");
       await nitro.storage.removeItem("cache:content:_nav.json");
       await nitro.storage.removeItem("cache:content:_meta.json");
-      ws.broadcast({ event, key });
+      await nitro.storage.removeItem(`cache:content:parsed:${key}`);
+      const payload = { event, key };
+      viteServer?.ws.send({
+        type: "custom",
+        event: "ginko-content:update",
+        data: payload
+      });
     });
     nitro.hooks.hook("close", async () => {
       await unwatch();
-      await ws.close();
-      await server.close();
     });
-    server.on("upgrade", ws.serve);
-    nitro.options.runtimeConfig.public.content.wsUrl = url.replace("http", "ws");
     await nitro.storage.removeItem("cache:content:_manifest.json");
     await nitro.storage.removeItem("cache:content:_nav.json");
     await nitro.storage.removeItem("cache:content:_meta.json");
   });
 };
 
+const runtimeAppImportSpecs = [
+  { name: "getCollectionPath", as: "getCollectionPath", from: "./query/routes.js" },
+  { name: "useContentHead", as: "useContentHead", from: "./app/composables/head.js" },
+  { name: "useContentPage", as: "useContentPage", from: "./app/composables/use-content.js" },
+  { name: "useContentOne", as: "useContentOne", from: "./app/composables/use-content.js" },
+  { name: "useContentMany", as: "useContentMany", from: "./app/composables/use-content.js" },
+  { name: "useContentPagination", as: "useContentPagination", from: "./app/composables/use-content.js" },
+  { name: "useContentBacklinks", as: "useContentBacklinks", from: "./app/composables/use-content.js" },
+  { name: "useContentResolveOne", as: "useContentResolveOne", from: "./app/composables/use-content.js" },
+  { name: "useContentVariants", as: "useContentVariants", from: "./app/composables/use-content.js" },
+  { name: "useContentTree", as: "useContentTree", from: "./app/composables/use-content.js" },
+  { name: "useContentNavigation", as: "useContentNavigation", from: "./app/composables/use-content.js" },
+  { name: "useContentNeighbors", as: "useContentNeighbors", from: "./app/composables/use-content.js" },
+  { name: "useContentSwitchLocalePath", as: "useContentSwitchLocalePath", from: "./app/composables/route.js" },
+  { name: "useContentSearchData", as: "useContentSearchData", from: "./app/composables/search.js" },
+  { name: "useContentSearchResults", as: "useContentSearchResults", from: "./app/composables/search.js" },
+  { name: "querySiteData", as: "querySiteData", from: "./app/composables/site-data.js" }
+];
+const runtimeServerImportSpecs = [
+  { name: "one", as: "one" },
+  { name: "many", as: "many" },
+  { name: "paginate", as: "paginate" },
+  { name: "backlinks", as: "backlinks" },
+  { name: "resolveOne", as: "resolveOne" },
+  { name: "variants", as: "variants" },
+  { name: "tree", as: "tree" },
+  { name: "neighbors", as: "neighbors" },
+  { name: "getCollectionPath", as: "getCollectionPath" },
+  { name: "queryCollectionsSitemapEntries", as: "queryCollectionsSitemapEntries" }
+];
+const generatedContentServerValueNames = [
+  ...runtimeServerImportSpecs.map((spec) => spec.name),
+  "contentCacheHeaders",
+  "noopContentCache",
+  "vercelContentCache",
+  "clearContentCacheHint",
+  "collectContentCacheHint",
+  "getContentCacheHint",
+  "withContentCache",
+  "createContentProviderError"
+];
+const generatedContentServerTypeSpecs = [
+  { local: "ContentCacheAdapter", exported: "ContentCacheAdapter" },
+  { local: "ContentCacheHint", exported: "ContentCacheHint" },
+  { local: "ContentCacheHintInput", exported: "ContentCacheHintInput" },
+  { local: "ContentCacheInvalidateInput", exported: "ContentCacheInvalidateInput" },
+  { local: "ContentProvider", exported: "ContentProvider" },
+  { local: "ContentProviderCapabilities", exported: "ContentProviderCapabilities" },
+  { local: "ContentProviderResult<T>", exported: "ContentProviderResult<T>" },
+  { local: "MaybeContentProviderResult<T>", exported: "MaybeContentProviderResult<T>" },
+  { local: "ContentProviderErrorCode", exported: "ContentProviderErrorCode" },
+  { local: "VercelContentCacheOptions", exported: "VercelContentCacheOptions" }
+];
 const registerRuntimeImports = (resolveRuntimeModule) => {
-  addImports([
-    { name: "getCollectionPath", as: "getCollectionPath", from: resolveRuntimeModule("./query/routes.js") },
-    { name: "useContentHead", as: "useContentHead", from: resolveRuntimeModule("./app/composables/head.js") },
-    // Vue composables — reactive wrappers over the same options shape.
-    { name: "useContentPage", as: "useContentPage", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentOne", as: "useContentOne", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentMany", as: "useContentMany", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentPagination", as: "useContentPagination", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentBacklinks", as: "useContentBacklinks", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentResolveOne", as: "useContentResolveOne", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentVariants", as: "useContentVariants", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentTree", as: "useContentTree", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentNavigation", as: "useContentNavigation", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentNeighbors", as: "useContentNeighbors", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentLocaleSwitch", as: "useContentLocaleSwitch", from: resolveRuntimeModule("./app/composables/use-content.js") },
-    { name: "useContentSwitchLocalePath", as: "useContentSwitchLocalePath", from: resolveRuntimeModule("./app/composables/route.js") },
-    // Search & site data — keep the headless useContentSearch export explicit
-    // because Nuxt UI owns the same auto-import name.
-    { name: "useContentSearchData", as: "useContentSearchData", from: resolveRuntimeModule("./app/composables/search.js") },
-    { name: "useContentSearchResults", as: "useContentSearchResults", from: resolveRuntimeModule("./app/composables/search.js") },
-    { name: "querySiteData", as: "querySiteData", from: resolveRuntimeModule("./app/composables/site-data.js") }
-  ]);
-  addServerImports([
-    { name: "one", as: "one", from: resolveRuntimeModule("./server/index.js") },
-    { name: "many", as: "many", from: resolveRuntimeModule("./server/index.js") },
-    { name: "paginate", as: "paginate", from: resolveRuntimeModule("./server/index.js") },
-    { name: "backlinks", as: "backlinks", from: resolveRuntimeModule("./server/index.js") },
-    { name: "resolveOne", as: "resolveOne", from: resolveRuntimeModule("./server/index.js") },
-    { name: "variants", as: "variants", from: resolveRuntimeModule("./server/index.js") },
-    { name: "tree", as: "tree", from: resolveRuntimeModule("./server/index.js") },
-    { name: "neighbors", as: "neighbors", from: resolveRuntimeModule("./server/index.js") },
-    { name: "getCollectionPath", as: "getCollectionPath", from: resolveRuntimeModule("./server/index.js") },
-    { name: "queryCollectionsSitemapEntries", as: "queryCollectionsSitemapEntries", from: resolveRuntimeModule("./server/index.js") }
-  ]);
+  addImports(runtimeAppImportSpecs.map((spec) => ({
+    ...spec,
+    from: resolveRuntimeModule(spec.from)
+  })));
+  addServerImports(runtimeServerImportSpecs.map((spec) => ({
+    ...spec,
+    from: resolveRuntimeModule("./server/index.js")
+  })));
 };
 const registerRuntimeComponents = (resolve) => {
   addComponentsDir({
@@ -332,11 +347,11 @@ const registerContentI18nTemplate = (addTemplateImpl, hasNuxtI18nModule) => {
     ].join("\n")
   });
 };
-const registerUserContentComponents = async (nuxt, resolve) => {
+const registerUserContentComponents = async (nuxt, _resolve) => {
   const layers = [...nuxt.options._layers];
   for (const layer of layers) {
     const srcDir = layer.config.srcDir;
-    const globalComponents = resolve(srcDir, "components/content");
+    const globalComponents = join(srcDir, "components/content");
     const dirStat = await fs.promises.stat(globalComponents).catch((error) => {
       if (error.code === "ENOENT") {
         return null;
@@ -362,6 +377,12 @@ const registerGeneratedTypes = (contentConfigPath, resolveRuntimeModuleRoot, col
     const key = JSON.stringify(name);
     return `    ${key}: StrictParsedContent & __GeneratedCollectionSchema<__ContentCollectionExport<${key}>>`;
   });
+  const contentServerValueDeclarations = generatedContentServerValueNames.map(
+    (name) => `  const ${name}: typeof import('${resolveRuntimeModuleRoot("./server")}').${name}`
+  );
+  const contentServerTypeDeclarations = generatedContentServerTypeSpecs.map(
+    (spec) => `  type ${spec.local} = import('${resolveRuntimeModuleRoot("./server")}').${spec.exported}`
+  );
   return addTypeTemplate({
     filename: "types/content.d.ts",
     getContents: () => [
@@ -418,42 +439,36 @@ const registerGeneratedTypes = (contentConfigPath, resolveRuntimeModuleRoot, col
       "  interface ContentCollectionI18nMap extends Pick<__GeneratedContentCollectionMap, __GeneratedI18nCollectionNames> {}",
       "}",
       "declare module '#content/server' {",
-      `  const one: typeof import('${resolveRuntimeModuleRoot("./server")}').one`,
-      `  const many: typeof import('${resolveRuntimeModuleRoot("./server")}').many`,
-      `  const paginate: typeof import('${resolveRuntimeModuleRoot("./server")}').paginate`,
-      `  const backlinks: typeof import('${resolveRuntimeModuleRoot("./server")}').backlinks`,
-      `  const resolveOne: typeof import('${resolveRuntimeModuleRoot("./server")}').resolveOne`,
-      `  const variants: typeof import('${resolveRuntimeModuleRoot("./server")}').variants`,
-      `  const tree: typeof import('${resolveRuntimeModuleRoot("./server")}').tree`,
-      `  const neighbors: typeof import('${resolveRuntimeModuleRoot("./server")}').neighbors`,
-      `  const queryCollectionsSitemapEntries: typeof import('${resolveRuntimeModuleRoot("./server")}').queryCollectionsSitemapEntries`,
-      `  const contentCacheHeaders: typeof import('${resolveRuntimeModuleRoot("./server")}').contentCacheHeaders`,
-      `  const noopContentCache: typeof import('${resolveRuntimeModuleRoot("./server")}').noopContentCache`,
-      `  const vercelContentCache: typeof import('${resolveRuntimeModuleRoot("./server")}').vercelContentCache`,
-      `  const clearContentCacheHint: typeof import('${resolveRuntimeModuleRoot("./server")}').clearContentCacheHint`,
-      `  const collectContentCacheHint: typeof import('${resolveRuntimeModuleRoot("./server")}').collectContentCacheHint`,
-      `  const getContentCacheHint: typeof import('${resolveRuntimeModuleRoot("./server")}').getContentCacheHint`,
-      `  const withContentCache: typeof import('${resolveRuntimeModuleRoot("./server")}').withContentCache`,
-      `  const createContentProviderError: typeof import('${resolveRuntimeModuleRoot("./server")}').createContentProviderError`,
-      `  type ContentCacheAdapter = import('${resolveRuntimeModuleRoot("./server")}').ContentCacheAdapter`,
-      `  type ContentCacheHint = import('${resolveRuntimeModuleRoot("./server")}').ContentCacheHint`,
-      `  type ContentCacheHintInput = import('${resolveRuntimeModuleRoot("./server")}').ContentCacheHintInput`,
-      `  type ContentCacheInvalidateInput = import('${resolveRuntimeModuleRoot("./server")}').ContentCacheInvalidateInput`,
-      `  type ContentProvider = import('${resolveRuntimeModuleRoot("./server")}').ContentProvider`,
-      `  type ContentProviderCapabilities = import('${resolveRuntimeModuleRoot("./server")}').ContentProviderCapabilities`,
-      `  type ContentProviderResult<T> = import('${resolveRuntimeModuleRoot("./server")}').ContentProviderResult<T>`,
-      `  type MaybeContentProviderResult<T> = import('${resolveRuntimeModuleRoot("./server")}').MaybeContentProviderResult<T>`,
-      `  type ContentProviderErrorCode = import('${resolveRuntimeModuleRoot("./server")}').ContentProviderErrorCode`,
-      `  type VercelContentCacheOptions = import('${resolveRuntimeModuleRoot("./server")}').VercelContentCacheOptions`,
+      ...contentServerValueDeclarations,
+      ...contentServerTypeDeclarations,
       "}"
     ].filter(Boolean).join("\n")
   });
 };
 const registerDevRuntimePlugin = (resolveRuntimeModule) => {
-  addPlugin(resolveRuntimeModule("./app/plugins/ws.js"));
+  addPlugin(resolveRuntimeModule("./app/plugins/hot-reload.js"));
+};
+
+const normalizeAgentRouteOptions = (options) => {
+  if (options.agent === false) {
+    return {
+      routes: false,
+      linkHeaders: false,
+      markdownNegotiation: false,
+      prerender: false
+    };
+  }
+  return {
+    routes: options.agent?.routes !== false,
+    linkHeaders: options.agent?.linkHeaders !== false,
+    markdownNegotiation: options.agent?.markdownNegotiation !== false,
+    prerender: options.agent?.prerender !== false
+  };
 };
 
 const registerContentServerHandlers = (nuxt, options, resolveRuntimeModule, buildIntegrity) => {
+  const revalidate = options.revalidate === false ? void 0 : options.revalidate;
+  const sitemap = options.sitemap === false ? false : options.sitemap === true ? { path: "/sitemap" } : options.sitemap;
   addServerHandler({
     method: "get",
     route: `${options.api.baseURL}/query/**:params`,
@@ -474,7 +489,7 @@ const registerContentServerHandlers = (nuxt, options, resolveRuntimeModule, buil
     route: `${options.api.baseURL}/site-data`,
     handler: resolveRuntimeModule("./server/api/site-data.js")
   });
-  if (options.revalidate && options.revalidate !== false && options.revalidate.token) {
+  if (revalidate?.token) {
     addServerHandler({
       method: "post",
       route: `${options.api.baseURL}/revalidate`,
@@ -486,10 +501,10 @@ const registerContentServerHandlers = (nuxt, options, resolveRuntimeModule, buil
     route: nuxt.options.dev ? `${options.api.baseURL}/cache.json` : `${options.api.baseURL}/cache.${buildIntegrity}.json`,
     handler: resolveRuntimeModule("./server/api/cache.js")
   });
-  if (options.sitemap !== false) {
+  if (sitemap !== false) {
     addServerHandler({
       method: "get",
-      route: `${options.api.baseURL}${options.sitemap.path || "/sitemap"}`,
+      route: `${options.api.baseURL}${sitemap.path || "/sitemap"}`,
       handler: resolveRuntimeModule("./server/api/sitemap.js")
     });
   }
@@ -505,6 +520,46 @@ const registerContentServerHandlers = (nuxt, options, resolveRuntimeModule, buil
       handler: resolveRuntimeModule("./server/api/navigation.js")
     });
   }
+  const agent = normalizeAgentRouteOptions(options);
+  if (agent.routes) {
+    addServerHandler({
+      method: "get",
+      route: "/llms.txt",
+      handler: resolveRuntimeModule("./server/api/agent-llms.js")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/llms-full.txt",
+      handler: resolveRuntimeModule("./server/api/agent-llms-full.js")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/:locale/llms.txt",
+      handler: resolveRuntimeModule("./server/api/agent-llms.js")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/:locale/llms-full.txt",
+      handler: resolveRuntimeModule("./server/api/agent-llms-full.js")
+    });
+    addServerHandler({
+      method: "get",
+      route: "/raw/**:slug",
+      handler: resolveRuntimeModule("./server/api/agent-raw.js")
+    });
+  }
+  if (agent.markdownNegotiation) {
+    addServerHandler({
+      middleware: true,
+      handler: resolveRuntimeModule("./server/middleware/agent-markdown.js")
+    });
+  }
+  if (agent.linkHeaders) {
+    addServerHandler({
+      middleware: true,
+      handler: resolveRuntimeModule("./server/middleware/agent-link-headers.js")
+    });
+  }
 };
 const registerContentSearchServerHandlers = (apiBaseURL, search, resolveRuntimeModule) => {
   const searchBaseURL = search.apiBaseURL || `${apiBaseURL.replace(/\/$/, "")}/search`;
@@ -523,12 +578,58 @@ const registerContentSearchServerHandlers = (apiBaseURL, search, resolveRuntimeM
   }
 };
 
-const SITEMAP_INDEX = "sitemap_index.xml";
-const assert = (condition, message) => {
-  if (!condition) {
-    throw new Error(message);
-  }
+const registerContentComponentsTemplate = (addTemplateImpl) => {
+  addTemplateImpl({
+    filename: "content-components.mjs",
+    getContents({ app, nuxt }) {
+      const componentsMap = app.components.filter((component) => {
+        if (component.island) {
+          return false;
+        }
+        if (component.filePath.endsWith(".css")) {
+          return false;
+        }
+        if (component.pascalName === "ClientOnly" || component.filePath.includes("nuxt/dist/") || component.filePath.includes("NuxtWelcome")) {
+          return false;
+        }
+        return true;
+      }).reduce((map, component) => {
+        const importPath = isAbsolute(component.filePath) ? "./" + relative(nuxt.options.buildDir, component.filePath).replace(/\b\.(?!vue)\w+$/g, "") : component.filePath.replace(/\b\.(?!vue)\w+$/g, "");
+        map[component.pascalName] = map[component.pascalName] || [
+          component.pascalName,
+          importPath,
+          component.global,
+          component.export || "default"
+        ];
+        return map;
+      }, {});
+      const componentsList = Object.values(componentsMap);
+      const globalComponents = componentsList.filter((component) => component[2]).map((component) => component[0]);
+      const localComponents = componentsList.filter((component) => !component[2]);
+      return [
+        "const pickExport = (mod, exportName, componentName, path) => {",
+        "  const resolved = exportName === 'default' ? mod?.default || mod : mod?.[exportName]",
+        "  if (!resolved) {",
+        '    throw new Error(`[nuxt-content] Missing export "${exportName}" for component "${componentName}" in "${path}".`)',
+        "  }",
+        "  return resolved",
+        "}",
+        "export const localComponentLoaders = {",
+        ...localComponents.map(([pascalName, path, , exp]) => {
+          const pathLiteral = JSON.stringify(path);
+          const exportLiteral = JSON.stringify(exp);
+          const nameLiteral = JSON.stringify(pascalName);
+          return `  ${pascalName}: () => import(${pathLiteral}).then(mod => pickExport(mod, ${exportLiteral}, ${nameLiteral}, ${pathLiteral})),`;
+        }),
+        "}",
+        `export const globalComponents = ${JSON.stringify(globalComponents)}`,
+        `export const localComponents = ${JSON.stringify(localComponents.map((component) => component[0]))}`
+      ].join("\n");
+    }
+  });
 };
+
+const SITEMAP_INDEX = "sitemap_index.xml";
 const countTag = (xml, tag) => (xml.match(new RegExp(`<${tag}>`, "g")) || []).length;
 const extractLocValues = (xml) => {
   return Array.from(xml.matchAll(/<loc>([^<]+)<\/loc>/g), (match) => match[1]);
@@ -595,10 +696,9 @@ const discoverSitemapsFromDisk = async (outputPublicDir) => {
   }
   const rootSitemapPath = join$1(outputPublicDir, "sitemap.xml");
   const rootSitemapXml = await readFile(rootSitemapPath, "utf8");
-  assert(
-    countTag(rootSitemapXml, "url") > 0 || rootSitemapXml.includes("<urlset"),
-    `Content sitemap assertion failed: no child sitemap files were discovered in ${indexPath} or ${sitemapDir}, and ${rootSitemapPath} is not a urlset sitemap.`
-  );
+  if (!(countTag(rootSitemapXml, "url") > 0 || rootSitemapXml.includes("<urlset"))) {
+    throw new Error(`Content sitemap assertion failed: no child sitemap files were discovered in ${indexPath} or ${sitemapDir}, and ${rootSitemapPath} is not a urlset sitemap.`);
+  }
   return [{
     name: "sitemap",
     path: rootSitemapPath,
@@ -633,7 +733,9 @@ async function assertGeneratedSitemaps({
   logger
 }) {
   const discoveredSitemaps = targets || (outputPublicDir ? await discoverSitemapsFromDisk(outputPublicDir) : []);
-  assert(discoveredSitemaps.length > 0, "Content sitemap assertion failed: no sitemap targets were available for validation.");
+  if (discoveredSitemaps.length === 0) {
+    throw new Error("Content sitemap assertion failed: no sitemap targets were available for validation.");
+  }
   const targetMap = new Map(discoveredSitemaps.map((target) => [target.name, target]));
   const failures = [];
   for (const sitemapName of Object.keys(options.sitemaps)) {
@@ -675,7 +777,7 @@ async function assertGeneratedSitemaps({
       failures.push([
         `- Placeholder sitemap URLs found: ${placeholderSiteUrls.join(", ")}`,
         "Expected production URLs in generated sitemap loc values.",
-        "Set site.url or runtimeConfig.public.siteUrl to the deployed origin for production release checks."
+        "Set site.url or runtimeConfig.public.content.siteUrl to the deployed origin for production release checks."
       ].join(" "));
     }
   }
@@ -707,283 +809,14 @@ const createSitemapAssertionTargetsFromPrerenderedSitemaps = (sitemaps) => {
     }
     return true;
   });
-  assert(targets.length > 0, "Content sitemap assertion failed: no sitemap urlsets were available from sitemap:prerender:done.");
+  if (targets.length === 0) {
+    throw new Error("Content sitemap assertion failed: no sitemap urlsets were available from sitemap:prerender:done.");
+  }
   return targets;
 };
 
-function hasNuxtModule(modules = [], name) {
-  return modules.some((entry) => {
-    if (typeof entry === "string") {
-      return entry === name;
-    }
-    if (Array.isArray(entry) && typeof entry[0] === "string") {
-      return entry[0] === name;
-    }
-    return false;
-  });
-}
-function hasNuxtI18nModule(modules = []) {
-  return hasNuxtModule(modules, "@nuxtjs/i18n");
-}
-function hasNuxtSitemapModule(modules = []) {
-  return hasNuxtModule(modules, "@nuxtjs/sitemap");
-}
-function configureNuxtSitemapSource(nuxt, apiBaseURL, sitemapPath = "/sitemap") {
-  if (!hasNuxtSitemapModule(nuxt.options.modules)) {
-    return;
-  }
-  const source = {
-    context: {
-      name: GINKO_SITEMAP_SOURCE_NAME
-    },
-    fetch: resolveContentSitemapSource(apiBaseURL, sitemapPath)
-  };
-  const sitemap = nuxt.options.sitemap ??= {};
-  const sources = Array.isArray(sitemap.sources) ? sitemap.sources : [];
-  sitemap.sources = [
-    ...sources.filter((item) => {
-      if (typeof item === "string") return item !== source.fetch;
-      return item?.fetch !== source.fetch && item?.context?.name !== GINKO_SITEMAP_SOURCE_NAME;
-    }),
-    source
-  ];
-}
-function resolveNuxtSitemapPrerenderRoutes(nuxt) {
-  if (!hasNuxtSitemapModule(nuxt.options.modules)) {
-    return [];
-  }
-  const nuxtSitemap = nuxt.options.sitemap;
-  if (nuxtSitemap?.sitemaps === false) {
-    return ["/sitemap.xml"];
-  }
-  const nuxtI18n = nuxt.options.i18n || {};
-  if (!hasNuxtI18nModule(nuxt.options.modules) || !Array.isArray(nuxtI18n.locales) || nuxtI18n.locales.length === 0) {
-    return ["/sitemap.xml"];
-  }
-  const childRoutes = nuxtI18n.locales.map((locale) => typeof locale === "string" ? locale : locale.language || locale.code).filter(Boolean).map((locale) => `/__sitemap__/${locale}.xml`);
-  return Array.from(/* @__PURE__ */ new Set(["/sitemap.xml", "/sitemap_index.xml", ...childRoutes]));
-}
-function resolveModuleI18nOptions(options, nuxt) {
-  if (options.i18n === false) {
-    return {
-      locales: [],
-      defaultLocale: void 0,
-      fallback: {},
-      translatedSlugs: false,
-      strictTranslatedSlugs: false
-    };
-  }
-  const moduleI18n = options.i18n === true ? {} : options.i18n || {};
-  const nuxtI18n = nuxt.options.i18n || {};
-  const nuxtLocales = Array.isArray(nuxtI18n.locales) ? nuxtI18n.locales.map((locale) => typeof locale === "string" ? locale : locale.code).filter(Boolean) : [];
-  const locales = Array.from(new Set([
-    moduleI18n.defaultLocale,
-    nuxtI18n.defaultLocale,
-    ...moduleI18n.locales || [],
-    ...nuxtLocales
-  ].filter(Boolean)));
-  const defaultLocale = moduleI18n.defaultLocale || nuxtI18n.defaultLocale || locales[0];
-  return {
-    locales,
-    defaultLocale,
-    fallback: defu({}, moduleI18n.fallback),
-    translatedSlugs: moduleI18n.translatedSlugs ?? false,
-    strictTranslatedSlugs: moduleI18n.strictTranslatedSlugs ?? false
-  };
-}
-function normalizeSitemapOptions(options) {
-  if (options.sitemap === false) {
-    return false;
-  }
-  const sitemap = options.sitemap === true ? {} : options.sitemap;
-  return {
-    path: sitemap.path || "/sitemap",
-    include: sitemap.include,
-    exclude: sitemap.exclude || [],
-    includeDrafts: sitemap.includeDrafts,
-    assert: normalizeContentSitemapAssertOptions(sitemap.assert)
-  };
-}
-function normalizeSearchOptions(options) {
-  if (options.search === false) {
-    return false;
-  }
-  return {
-    engine: options.search?.engine || "minisearch",
-    ignoredTags: options.search?.ignoredTags || ["script", "style", "pre"],
-    filterQuery: options.search?.filterQuery || { _draft: false, _partial: false },
-    collections: options.search?.collections,
-    extraFields: options.search?.extraFields || [],
-    apiBaseURL: options.search?.apiBaseURL,
-    minisearch: normalizeMiniSearchOptions(options.search?.minisearch)
-  };
-}
-const defaultMiniSearchOptions = {
-  fields: ["title", "content", "headings"],
-  storeFields: ["path", "title", "excerpt", "anchor", "locale", "collection"],
-  boost: {
-    title: 4,
-    headings: 2,
-    content: 1
-  },
-  fuzzy: 0.2,
-  prefix: true
-};
-const requiredMiniSearchStoreFields = ["path", "title", "excerpt"];
-function normalizeMiniSearchOptions(options = {}) {
-  const fields = options?.fields?.filter((field) => typeof field === "string" && field.length > 0);
-  const storeFields = options?.storeFields?.filter((field) => typeof field === "string" && field.length > 0);
-  const boost = Object.fromEntries(
-    Object.entries(options?.boost || {}).filter((entry) => typeof entry[0] === "string" && entry[0].length > 0 && typeof entry[1] === "number" && Number.isFinite(entry[1]))
-  );
-  const resolvedFields = fields?.length ? fields : [...defaultMiniSearchOptions.fields];
-  const resolvedStoreFields = storeFields?.length ? storeFields : defaultMiniSearchOptions.storeFields;
-  return {
-    fields: resolvedFields,
-    storeFields: Array.from(/* @__PURE__ */ new Set([...requiredMiniSearchStoreFields, ...resolvedStoreFields])),
-    boost: Object.keys(boost).length ? boost : { ...defaultMiniSearchOptions.boost },
-    fuzzy: typeof options?.fuzzy === "boolean" || typeof options?.fuzzy === "number" ? options.fuzzy : defaultMiniSearchOptions.fuzzy,
-    prefix: typeof options?.prefix === "boolean" ? options.prefix : defaultMiniSearchOptions.prefix
-  };
-}
-function createSearchRuntimeConfig(search, apiBaseURL) {
-  const resolvedApiBaseURL = search.apiBaseURL || `${apiBaseURL.replace(/\/$/, "")}/search`;
-  return {
-    apiBaseURL: resolvedApiBaseURL,
-    indexURL: `${resolvedApiBaseURL.replace(/\/$/, "")}/index.json`,
-    engine: search.engine || "minisearch",
-    minisearch: normalizeMiniSearchOptions(search.minisearch)
-  };
-}
-
-const resolveNuxtSiteUrl = (nuxt) => {
-  const publicRuntime = nuxt.options.runtimeConfig.public;
-  const configuredSiteUrl = publicRuntime.siteUrl;
-  if (typeof configuredSiteUrl === "string" && configuredSiteUrl.length > 0) {
-    return configuredSiteUrl;
-  }
-  const nuxtSite = nuxt.options.site;
-  return typeof nuxtSite?.url === "string" && nuxtSite.url.length > 0 ? nuxtSite.url : void 0;
-};
-const applyContentRuntimeConfig = (nuxt, options, contentContext, runtimeCollections, buildIntegrity, cacheIntegrity) => {
-  const searchRuntime = contentContext.search === false ? false : {
-    apiBaseURL: contentContext.search.apiBaseURL || `${options.api.baseURL.replace(/\/$/, "")}/search`,
-    indexURL: `${(contentContext.search.apiBaseURL || `${options.api.baseURL.replace(/\/$/, "")}/search`).replace(/\/$/, "")}/index.json`,
-    engine: contentContext.search.engine || "minisearch",
-    minisearch: normalizeMiniSearchOptions(contentContext.search.minisearch)
-  };
-  const contentRuntime = defu(nuxt.options.runtimeConfig.public.content, {
-    locales: contentContext.locales,
-    provider: contentContext.provider || "filesystem",
-    providers: contentContext.providers || {},
-    defaultLocale: contentContext.defaultLocale || void 0,
-    localeFallback: contentContext.localeFallback || {},
-    translatedSlugs: contentContext.translatedSlugs ?? false,
-    strictTranslatedSlugs: contentContext.strictTranslatedSlugs ?? false,
-    collections: runtimeCollections,
-    integrity: buildIntegrity,
-    experimental: {
-      stripQueryParameters: options.experimental.stripQueryParameters
-    },
-    respectPathCase: options.respectPathCase ?? false,
-    api: {
-      baseURL: options.api.baseURL
-    },
-    markdown: {
-      plugins: contentContext.markdown.plugins,
-      tags: contentContext.markdown.tags,
-      anchorLinks: contentContext.markdown.anchorLinks,
-      image: contentContext.markdown.image || "auto"
-    },
-    sitemap: contentContext.sitemap ? {
-      path: contentContext.sitemap.path || "/sitemap",
-      ...contentContext.sitemap.include?.length ? { include: contentContext.sitemap.include } : {},
-      ...contentContext.sitemap.exclude?.length ? { exclude: contentContext.sitemap.exclude } : {},
-      ...typeof contentContext.sitemap.includeDrafts === "boolean" ? { includeDrafts: contentContext.sitemap.includeDrafts } : {}
-    } : false,
-    search: searchRuntime,
-    navigation: contentContext.navigation,
-    wsUrl: "",
-    contentHead: options.contentHead ?? true
-  });
-  const siteUrl = resolveNuxtSiteUrl(nuxt);
-  if (siteUrl) {
-    nuxt.options.runtimeConfig.public.siteUrl = siteUrl;
-  }
-  nuxt.options.runtimeConfig.public.content = contentRuntime;
-  nuxt.options.runtimeConfig.content = defu(nuxt.options.runtimeConfig.content, {
-    cacheVersion: CACHE_VERSION,
-    cacheIntegrity,
-    revalidate: options.revalidate && options.revalidate !== false && options.revalidate.token ? {
-      token: options.revalidate.token,
-      allowUnsigned: options.revalidate.allowUnsigned === true
-    } : false,
-    ...contentContext,
-    collections: runtimeCollections
-  });
-};
-
-const registerContentComponentsTemplate = (addTemplateImpl) => {
-  addTemplateImpl({
-    filename: "content-components.mjs",
-    getContents({ app, nuxt }) {
-      const componentsMap = app.components.filter((component) => {
-        if (component.island) {
-          return false;
-        }
-        if (component.filePath.endsWith(".css")) {
-          return false;
-        }
-        if (component.pascalName === "ClientOnly" || component.filePath.includes("nuxt/dist/") || component.filePath.includes("NuxtWelcome")) {
-          return false;
-        }
-        return true;
-      }).reduce((map, component) => {
-        const importPath = isAbsolute(component.filePath) ? "./" + relative(nuxt.options.buildDir, component.filePath).replace(/\b\.(?!vue)\w+$/g, "") : component.filePath.replace(/\b\.(?!vue)\w+$/g, "");
-        map[component.pascalName] = map[component.pascalName] || [
-          component.pascalName,
-          importPath,
-          component.global,
-          component.export || "default"
-        ];
-        return map;
-      }, {});
-      const componentsList = Object.values(componentsMap);
-      const globalComponents = componentsList.filter((component) => component[2]).map((component) => component[0]);
-      const localComponents = componentsList.filter((component) => !component[2]);
-      return [
-        "const pickExport = (mod, exportName, componentName, path) => {",
-        "  const resolved = exportName === 'default' ? mod?.default || mod : mod?.[exportName]",
-        "  if (!resolved) {",
-        '    throw new Error(`[nuxt-content] Missing export "${exportName}" for component "${componentName}" in "${path}".`)',
-        "  }",
-        "  return resolved",
-        "}",
-        "export const localComponentLoaders = {",
-        ...localComponents.map(([pascalName, path, , exp]) => {
-          const pathLiteral = JSON.stringify(path);
-          const exportLiteral = JSON.stringify(exp);
-          const nameLiteral = JSON.stringify(pascalName);
-          return `  ${pascalName}: () => import(${pathLiteral}).then(mod => pickExport(mod, ${exportLiteral}, ${nameLiteral}, ${pathLiteral})),`;
-        }),
-        "}",
-        `export const globalComponents = ${JSON.stringify(globalComponents)}`,
-        `export const localComponents = ${JSON.stringify(localComponents.map((component) => component[0]))}`
-      ].join("\n");
-    }
-  });
-};
-
-const appendHook = (hooks, name, handler) => {
-  const existing = hooks[name];
-  if (!existing) {
-    hooks[name] = handler;
-    return;
-  }
-  hooks[name] = Array.isArray(existing) ? [...existing, handler] : [existing, handler];
-};
-const resolveSitemapCollections = (collections, sitemap) => {
-  if (!sitemap || sitemap === false) {
+const resolveSitemapCollections = (collections, sitemap) => {
+  if (!sitemap) {
     return [];
   }
   const include = sitemap.include?.length ? sitemap.include : Object.keys(collections);
@@ -997,7 +830,7 @@ const toTranslatedSlugSourcePattern = (source) => {
     return match ? `${match[1]}.*${match[2] || ""}` : segment;
   }).join("/");
 };
-const parseCollectionFiles = async (rootDir, collections, collectionNames, contentContext) => {
+const parseDerivedCollectionFiles = async (rootDir, collections, collectionNames, contentContext) => {
   const contentDir = resolve$1(rootDir, "content");
   const patterns = Array.from(new Set(
     collectionNames.flatMap((name) => {
@@ -1028,7 +861,7 @@ const parseCollectionFiles = async (rootDir, collections, collectionNames, conte
   for (const id of ids) {
     const file = resolve$1(contentDir, id);
     const content = await readFile(file, "utf8");
-    const normalizedId = `content:${relative$1(contentDir, file).replaceAll("\\", "/")}`;
+    const normalizedId = `content:${relative$1(contentDir, file).replace(/\\/g, "/")}`;
     const parsed = await transformContent(normalizedId, content, {
       markdown: contentContext.markdown,
       yaml: contentContext.yaml,
@@ -1042,29 +875,36 @@ const parseCollectionFiles = async (rootDir, collections, collectionNames, conte
         collectionResolver: (filePath) => resolveCollection(filePath, collections, contentContext.locales || [])
       }
     });
-    const collection = parsed._collection ? collections[parsed._collection] : void 0;
-    documents.push(...expandDataLocaleVariants(parsed, collection?.i18n));
+    const collection = typeof parsed._collection === "string" ? collections[parsed._collection] : void 0;
+    documents.push(...expandDataLocaleVariants(parsed, collection?.i18n === true ? void 0 : collection?.i18n));
   }
   return documents;
 };
-const collectPrerenderRoutes = async (rootDir, contentContext) => {
+const collectDerivedDocuments = async (rootDir, contentContext) => {
   const collections = contentContext.collections || {};
-  if (!contentContext.sitemap || contentContext.sitemap === false) {
-    return [];
-  }
-  const includeCollections = resolveSitemapCollections(collections, contentContext.sitemap);
-  if (!includeCollections.length) {
-    return [];
+  const includedCollections = resolveSitemapCollections(collections, contentContext.sitemap);
+  if (!includedCollections.length) {
+    return { collections, includedCollections, graph: buildContentGraph([], { locales: contentContext.locales, defaultLocale: contentContext.defaultLocale }) };
   }
-  const documents = await parseCollectionFiles(rootDir, collections, includeCollections, contentContext);
+  const documents = await parseDerivedCollectionFiles(rootDir, collections, includedCollections, contentContext);
   const graph = buildContentGraph(documents, {
     locales: contentContext.locales,
     defaultLocale: contentContext.defaultLocale
   });
+  return { collections, includedCollections, graph };
+};
+const collectDerivedPrerenderRoutes = async (rootDir, contentContext) => {
+  if (!contentContext.sitemap) {
+    return [];
+  }
+  const { includedCollections, graph } = await collectDerivedDocuments(rootDir, contentContext);
+  if (!includedCollections.length) {
+    return [];
+  }
   const routes = /* @__PURE__ */ new Set();
-  for (const collection of includeCollections) {
+  for (const collection of includedCollections) {
     const { defaultLocale } = resolveCollectionI18n(collection, contentContext);
-    const includeDrafts = contentContext.sitemap && contentContext.sitemap !== false ? Boolean(contentContext.sitemap.includeDrafts) : false;
+    const includeDrafts = Boolean(contentContext.sitemap.includeDrafts);
     const seenCanonicalKeys = /* @__PURE__ */ new Set();
     for (const contentId of graph.byCollection[collection] || []) {
       const document = graph.byId[contentId];
@@ -1091,18 +931,12 @@ const collectPrerenderRoutes = async (rootDir, contentContext) => {
   return Array.from(routes).sort();
 };
 const collectSitemapCollectionRouteCounts = async (rootDir, contentContext) => {
-  const collections = contentContext.collections || {};
-  const includedCollections = resolveSitemapCollections(collections, contentContext.sitemap);
+  const { includedCollections, graph } = await collectDerivedDocuments(rootDir, contentContext);
   if (!includedCollections.length) {
     return {};
   }
-  const documents = await parseCollectionFiles(rootDir, collections, includedCollections, contentContext);
-  const graph = buildContentGraph(documents, {
-    locales: contentContext.locales,
-    defaultLocale: contentContext.defaultLocale
-  });
   const counts = Object.fromEntries(includedCollections.map((collection) => [collection, 0]));
-  const includeDrafts = contentContext.sitemap && contentContext.sitemap !== false ? Boolean(contentContext.sitemap.includeDrafts) : false;
+  const includeDrafts = contentContext.sitemap ? Boolean(contentContext.sitemap.includeDrafts) : false;
   for (const collection of includedCollections) {
     const seenCanonicalKeys = /* @__PURE__ */ new Set();
     for (const contentId of graph.byCollection[collection] || []) {
@@ -1126,12 +960,32 @@ const collectSitemapCollectionRouteCounts = async (rootDir, contentContext) => {
   }
   return counts;
 };
+
+const appendHook = (hooks, name, handler) => {
+  const existing = hooks[name];
+  if (!existing) {
+    hooks[name] = handler;
+    return;
+  }
+  hooks[name] = Array.isArray(existing) ? [...existing, handler] : [existing, handler];
+};
 const registerContentNitroIntegrationHooks = (nitroConfig, options, contentContext) => {
-  const usesFilesystemProvider = !contentContext.provider || contentContext.provider === "filesystem";
+  const getHookContentContext = () => {
+    if (!options.resolveContentContext) {
+      return contentContext;
+    }
+    try {
+      return options.resolveContentContext();
+    } catch {
+      return contentContext;
+    }
+  };
   nitroConfig.hooks ||= {};
-  if (contentContext.sitemap?.assert?.enabled) {
+  if (contentContext.sitemap && contentContext.sitemap.assert?.enabled) {
     appendHook(nitroConfig.hooks, "compiled", async (nitro) => {
-      const assertOptions = contentContext.sitemap?.assert;
+      const hookContentContext = getHookContentContext();
+      const hookUsesFilesystemProvider = !hookContentContext.provider || hookContentContext.provider === "filesystem";
+      const assertOptions = hookContentContext.sitemap ? hookContentContext.sitemap.assert : void 0;
       if (!assertOptions || !shouldRunSitemapAssertionOnCompiled(assertOptions, nitro)) {
         return;
       }
@@ -1139,11 +993,11 @@ const registerContentNitroIntegrationHooks = (nitroConfig, options, contentConte
         await assertGeneratedSitemaps({
           outputPublicDir: nitro.options.output.publicDir,
           options: assertOptions,
-          collectionRouteCounts: usesFilesystemProvider ? await collectSitemapCollectionRouteCounts(options.rootDir, contentContext) : {},
+          collectionRouteCounts: hookUsesFilesystemProvider ? await collectSitemapCollectionRouteCounts(options.rootDir, hookContentContext) : {},
           logger: nitro.logger
         });
       } catch (error) {
-        if (error?.code === "ENOENT") {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
           return;
         }
         throw error;
@@ -1151,8 +1005,10 @@ const registerContentNitroIntegrationHooks = (nitroConfig, options, contentConte
     });
   }
   appendHook(nitroConfig.hooks, "prerender:routes", async (routes) => {
-    if (usesFilesystemProvider) {
-      for (const route of await collectPrerenderRoutes(options.rootDir, contentContext)) {
+    const hookContentContext = getHookContentContext();
+    const hookUsesFilesystemProvider = !hookContentContext.provider || hookContentContext.provider === "filesystem";
+    if (hookUsesFilesystemProvider) {
+      for (const route of await collectDerivedPrerenderRoutes(options.rootDir, hookContentContext)) {
         routes.add(route);
       }
     }
@@ -1163,10 +1019,155 @@ const registerContentNitroIntegrationHooks = (nitroConfig, options, contentConte
   });
 };
 
-const getContentPageMeta = (page) => {
-  const content = page.meta?.content;
-  return content && typeof content === "object" ? content : void 0;
-};
+function hasNuxtModule(modules = [], name) {
+  return modules.some((entry) => {
+    if (typeof entry === "string") {
+      return entry === name;
+    }
+    if (Array.isArray(entry) && typeof entry[0] === "string") {
+      return entry[0] === name;
+    }
+    return false;
+  });
+}
+function hasNuxtI18nModule(modules = []) {
+  return hasNuxtModule(modules, "@nuxtjs/i18n");
+}
+function hasNuxtSitemapModule(modules = []) {
+  return hasNuxtModule(modules, "@nuxtjs/sitemap");
+}
+function configureNuxtSitemapSource(nuxt, apiBaseURL, sitemapPath = "/sitemap") {
+  if (!hasNuxtSitemapModule(nuxt.options.modules)) {
+    return;
+  }
+  const source = {
+    context: {
+      name: GINKO_SITEMAP_SOURCE_NAME
+    },
+    fetch: resolveContentSitemapSource(apiBaseURL, sitemapPath)
+  };
+  const sitemap = nuxt.options.sitemap ??= {};
+  const sources = Array.isArray(sitemap.sources) ? sitemap.sources : [];
+  sitemap.sources = [
+    ...sources.filter((item) => {
+      if (typeof item === "string") return item !== source.fetch;
+      return item?.fetch !== source.fetch && item?.context?.name !== GINKO_SITEMAP_SOURCE_NAME;
+    }),
+    source
+  ];
+}
+function resolveNuxtSitemapPrerenderRoutes(nuxt) {
+  if (!hasNuxtSitemapModule(nuxt.options.modules)) {
+    return [];
+  }
+  const nuxtSitemap = nuxt.options.sitemap;
+  if (nuxtSitemap?.sitemaps === false) {
+    return ["/sitemap.xml"];
+  }
+  const nuxtI18n = nuxt.options.i18n || {};
+  if (!hasNuxtI18nModule(nuxt.options.modules) || !Array.isArray(nuxtI18n.locales) || nuxtI18n.locales.length === 0) {
+    return ["/sitemap.xml"];
+  }
+  const childRoutes = nuxtI18n.locales.map((locale) => typeof locale === "string" ? locale : locale.language || locale.code).filter(Boolean).map((locale) => `/__sitemap__/${locale}.xml`);
+  return Array.from(/* @__PURE__ */ new Set(["/sitemap.xml", "/sitemap_index.xml", ...childRoutes]));
+}
+function resolveModuleI18nOptions(options, nuxt) {
+  if (options.i18n === false) {
+    return {
+      locales: [],
+      defaultLocale: void 0,
+      fallback: {},
+      translatedSlugs: false,
+      strictTranslatedSlugs: false
+    };
+  }
+  const moduleI18n = options.i18n === true ? {} : options.i18n || {};
+  const nuxtI18n = nuxt.options.i18n || {};
+  const nuxtLocales = Array.isArray(nuxtI18n.locales) ? nuxtI18n.locales.map((locale) => typeof locale === "string" ? locale : locale.code).filter(Boolean) : [];
+  const locales = Array.from(new Set([
+    moduleI18n.defaultLocale,
+    nuxtI18n.defaultLocale,
+    ...moduleI18n.locales || [],
+    ...nuxtLocales
+  ].filter(Boolean)));
+  const defaultLocale = moduleI18n.defaultLocale || nuxtI18n.defaultLocale || locales[0];
+  return {
+    locales,
+    defaultLocale,
+    fallback: defu({}, moduleI18n.fallback),
+    translatedSlugs: moduleI18n.translatedSlugs ?? false,
+    strictTranslatedSlugs: moduleI18n.strictTranslatedSlugs ?? false
+  };
+}
+function normalizeSitemapOptions(options) {
+  if (options.sitemap === false) {
+    return false;
+  }
+  const sitemap = options.sitemap === true ? {} : options.sitemap;
+  return {
+    path: sitemap.path || "/sitemap",
+    include: sitemap.include,
+    exclude: sitemap.exclude || [],
+    includeDrafts: sitemap.includeDrafts,
+    assert: normalizeContentSitemapAssertOptions(sitemap.assert)
+  };
+}
+function normalizeSearchOptions(options) {
+  if (options.search === false) {
+    return false;
+  }
+  return {
+    engine: options.search?.engine || "minisearch",
+    ignoredTags: options.search?.ignoredTags || ["script", "style", "pre"],
+    filterQuery: options.search?.filterQuery || { _draft: false, _partial: false },
+    collections: options.search?.collections,
+    extraFields: options.search?.extraFields || [],
+    apiBaseURL: options.search?.apiBaseURL,
+    minisearch: normalizeMiniSearchOptions(options.search?.minisearch)
+  };
+}
+const defaultMiniSearchOptions = {
+  fields: ["title", "content", "headings"],
+  storeFields: ["path", "title", "excerpt", "anchor", "locale", "collection"],
+  boost: {
+    title: 4,
+    headings: 2,
+    content: 1
+  },
+  fuzzy: 0.2,
+  prefix: true
+};
+const requiredMiniSearchStoreFields = ["path", "title", "excerpt"];
+function normalizeMiniSearchOptions(options = {}) {
+  const fields = options?.fields?.filter((field) => typeof field === "string" && field.length > 0);
+  const storeFields = options?.storeFields?.filter((field) => typeof field === "string" && field.length > 0);
+  const boost = Object.fromEntries(
+    Object.entries(options?.boost || {}).filter((entry) => typeof entry[0] === "string" && entry[0].length > 0 && typeof entry[1] === "number" && Number.isFinite(entry[1]))
+  );
+  const resolvedFields = fields?.length ? fields : [...defaultMiniSearchOptions.fields];
+  const resolvedStoreFields = storeFields?.length ? storeFields : defaultMiniSearchOptions.storeFields;
+  return {
+    fields: resolvedFields,
+    storeFields: Array.from(/* @__PURE__ */ new Set([...requiredMiniSearchStoreFields, ...resolvedStoreFields])),
+    boost: Object.keys(boost).length ? boost : { ...defaultMiniSearchOptions.boost },
+    fuzzy: typeof options?.fuzzy === "boolean" || typeof options?.fuzzy === "number" ? options.fuzzy : defaultMiniSearchOptions.fuzzy,
+    prefix: typeof options?.prefix === "boolean" ? options.prefix : defaultMiniSearchOptions.prefix
+  };
+}
+function createSearchRuntimeConfig(search, apiBaseURL) {
+  const resolvedApiBaseURL = search.apiBaseURL || `${apiBaseURL.replace(/\/$/, "")}/search`;
+  return {
+    apiBaseURL: resolvedApiBaseURL,
+    indexURL: `${resolvedApiBaseURL.replace(/\/$/, "")}/index.json`,
+    engine: search.engine || "minisearch",
+    minisearch: normalizeMiniSearchOptions(search.minisearch)
+  };
+}
+
+const getContentPageMeta = (page) => {
+  const content = page.meta?.content;
+  return content && typeof content === "object" ? content : void 0;
+};
 const isRouteConfig = (value) => typeof value === "string" || value !== null && typeof value === "object" && Object.values(value).every((entry) => typeof entry === "string");
 const describePage = (page) => page.file || page.path || "<unknown page>";
 const expectedLocalesFor = (collection, locales, defaultLocale) => {
@@ -1218,6 +1219,568 @@ function validatePage(page, contentMeta, collections, options) {
   }
 }
 
+const hasAgentSurface = (config) => Boolean(
+  config.agent || Object.values(config.collections || {}).some((collection) => Boolean(collection.agent?.markdown))
+);
+const agentSectionIds = (sections) => new Set((sections || []).map((section) => section.id).filter(Boolean));
+const validateAgentConfig = (config, options, context) => {
+  if (!hasAgentSurface(config)) return;
+  const agentRoutes = normalizeAgentRouteOptions(options);
+  if (!context.dev && agentRoutes.routes && agentRoutes.prerender && !config.agent?.site?.url) {
+    throw new Error(
+      "@lupinum/ginko-content agent prerender requires agent.site.url for non-dev builds. Set agent.site.url in content.config.ts or disable content.agent.prerender."
+    );
+  }
+  const sections = agentSectionIds(config.agent?.sections);
+  const seenSections = /* @__PURE__ */ new Set();
+  for (const section of config.agent?.sections || []) {
+    if (!section.id) {
+      throw new Error("@lupinum/ginko-content agent section ids must be non-empty strings.");
+    }
+    if (seenSections.has(section.id)) {
+      throw new Error(`Duplicate Ginko agent section id "${section.id}". Agent section ids must be unique.`);
+    }
+    seenSections.add(section.id);
+  }
+  const assertSection = (id, owner) => {
+    if (!id || id === "content") return;
+    if (!sections.has(id)) {
+      throw new Error(
+        `${owner} references unknown Ginko agent section "${id}". Declare it in agent.sections or use the default "content" section.`
+      );
+    }
+  };
+  for (const [name, collection] of Object.entries(config.collections || {})) {
+    if (collection.agent?.markdown || collection.agent?.section) {
+      assertSection(collection.agent.section, `Collection "${name}"`);
+    }
+  }
+  for (const page of config.agent?.pages || []) {
+    assertSection(page.section, `Agent app page "${page.id}"`);
+  }
+};
+
+const normalizeStaticRoutePath = (path) => {
+  if (!path || path === "/") return "/";
+  return `/${path.replace(/\/+/g, "/").replace(/^\/+|\/+$/g, "")}`;
+};
+const collectRawMarkdownLinksFromLlms = (markdown, siteUrl) => {
+  const links = /* @__PURE__ */ new Set();
+  const pattern = /\[[^\]]*\]\(([^)]+)\)/g;
+  for (const match of markdown.matchAll(pattern)) {
+    const href = match[1];
+    if (!href) continue;
+    try {
+      const url = /^[a-z][a-z0-9+.-]*:/i.test(href) ? new URL(href) : new URL(href, siteUrl || "http://localhost:3000");
+      if (url.pathname.startsWith("/raw/") && url.pathname.endsWith(".md")) links.add(url.pathname);
+    } catch {
+      if (href.startsWith("/raw/") && href.endsWith(".md")) links.add(href);
+    }
+  }
+  return Array.from(links);
+};
+const rawMarkdownRouteForPageRoute = (route) => {
+  const normalized = normalizeStaticRoutePath(route);
+  return normalized === "/" ? "/raw/index.md" : `/raw${normalized}.md`;
+};
+const collectRawMarkdownRoutesFromGeneratedFrontmatter = (markdown) => {
+  const links = /* @__PURE__ */ new Set();
+  const addRoutePath = (route) => {
+    links.add(rawMarkdownRouteForPageRoute(route));
+  };
+  const addFrontmatterRoute = (frontmatter) => {
+    const route = /^route:\s*"([^"]+)"/m.exec(frontmatter || "")?.[1];
+    if (!route) return;
+    addRoutePath(route);
+  };
+  const addSourceRoute = (source) => {
+    if (!source) return;
+    try {
+      addRoutePath(new URL(source, "http://localhost:3000").pathname);
+    } catch {
+      addRoutePath(source);
+    }
+  };
+  const sourcePattern = /^Source:\s+(\S+)/gm;
+  for (const match of markdown.matchAll(sourcePattern)) {
+    addSourceRoute(match[1]);
+  }
+  const pageFrontmatterPattern = /^Source:\s+[^\n]+\n\n---\n([\s\S]*?)\n---/gm;
+  for (const match of markdown.matchAll(pageFrontmatterPattern)) {
+    addFrontmatterRoute(match[1]);
+  }
+  const firstFrontmatter = /^---\n([\s\S]*?)\n---/.exec(markdown)?.[1];
+  addFrontmatterRoute(firstFrontmatter);
+  return Array.from(links);
+};
+const publicOutputPath = (publicDir, route) => join(publicDir, normalizeStaticRoutePath(route).replace(/^\//, ""));
+const rawMarkdownIndexRouteForRawRoute = (route) => {
+  if (!route.startsWith("/raw/") || !route.endsWith(".md")) return null;
+  const pageRoute = route.replace(/^\/raw/, "").replace(/\.md$/, "");
+  return pageRoute === "/index" ? "/index.md" : `${pageRoute}/index.md`;
+};
+
+const hookNuxtBoundary$2 = (nuxt, name, callback) => {
+  const hook = nuxt.hook;
+  hook(name, callback);
+};
+const registerStaticOutputGeneration = ({
+  nuxt,
+  options,
+  appContentConfig,
+  contentContext,
+  resolvedI18n,
+  resolveRuntimeModule,
+  getSearchRuntime
+}) => {
+  if (nuxt.options.dev) return;
+  hookNuxtBoundary$2(nuxt, "nitro:build:before", (nitro) => {
+    nitro.hooks.hook("prerender:init", (prerenderer) => {
+      prerenderer.hooks.hook("compiled", async () => {
+        const searchRuntime = getSearchRuntime();
+        const publicDir = nitro.options.output.publicDir || nuxt.options.nitro?.output?.publicDir || resolve$1(nuxt.options.rootDir, ".output/public");
+        const serverFilename = typeof prerenderer.options.rollupConfig?.output?.entryFileNames === "string" ? prerenderer.options.rollupConfig.output.entryFileNames : "index.mjs";
+        const serverEntrypoint = resolve$1(prerenderer.options.output.serverDir, serverFilename);
+        const { localFetch } = await import(pathToFileURL(serverEntrypoint).href);
+        if (searchRuntime !== false && searchRuntime.engine !== "cms" && (!contentContext.provider || contentContext.provider === "filesystem")) {
+          const response = await localFetch(searchRuntime.indexURL);
+          if (!response.ok) {
+            throw new Error(`Failed to generate search index: [${response.status}] ${response.statusText}`);
+          }
+          const json = await response.text();
+          const indexPath = publicOutputPath(publicDir, searchRuntime.indexURL);
+          mkdirSync(dirname(indexPath), { recursive: true });
+          writeFileSync(indexPath, json, "utf8");
+          if (searchRuntime.engine === "pagefind") {
+            const records = JSON.parse(json);
+            const { writePagefindIndex } = await import(resolveRuntimeModule("./server/pagefind.js"));
+            await writePagefindIndex(records, resolve$1(publicDir, "pagefind"));
+          }
+        }
+        const agentRoutes = normalizeAgentRouteOptions(options);
+        if (agentRoutes.routes && agentRoutes.prerender && appContentConfig.agent) {
+          const defaultLocale = appContentConfig.agent.site?.defaultLocale || resolvedI18n.defaultLocale;
+          const locales = appContentConfig.agent.site?.locales?.length ? appContentConfig.agent.site.locales : resolvedI18n.locales;
+          const llmsRoutes = [
+            "/llms.txt",
+            "/llms-full.txt",
+            ...locales.filter((locale) => locale && locale !== defaultLocale).flatMap((locale) => [`/${locale}/llms.txt`, `/${locale}/llms-full.txt`])
+          ];
+          const markdownRoutes = /* @__PURE__ */ new Set();
+          for (const route of llmsRoutes) {
+            const response = await localFetch(route);
+            if (!response.ok) {
+              throw new Error(`Failed to generate agent markdown route ${route}: [${response.status}] ${response.statusText}`);
+            }
+            const body = await response.text();
+            const outputPath = publicOutputPath(publicDir, route);
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, body, "utf8");
+            if (/\/llms\.txt$/i.test(route)) {
+              collectRawMarkdownLinksFromLlms(body, appContentConfig.agent.site?.url).forEach((link) => markdownRoutes.add(link));
+            } else if (/\/llms-full\.txt$/i.test(route)) {
+              collectRawMarkdownRoutesFromGeneratedFrontmatter(body).forEach((link) => markdownRoutes.add(link));
+            }
+          }
+          for (const route of markdownRoutes) {
+            const response = await localFetch(route);
+            if (!response.ok) {
+              throw new Error(`Failed to generate agent markdown route ${route}: [${response.status}] ${response.statusText}`);
+            }
+            const body = await response.text();
+            const outputPath = publicOutputPath(publicDir, route);
+            mkdirSync(dirname(outputPath), { recursive: true });
+            writeFileSync(outputPath, body, "utf8");
+            const indexRoute = rawMarkdownIndexRouteForRawRoute(route);
+            if (indexRoute) {
+              const indexPath = publicOutputPath(publicDir, indexRoute);
+              mkdirSync(dirname(indexPath), { recursive: true });
+              writeFileSync(indexPath, body, "utf8");
+            }
+          }
+        }
+      });
+    });
+  });
+};
+
+const hookNuxtBoundary$1 = (nuxt, name, callback) => {
+  const hook = nuxt.hook;
+  hook(name, callback);
+};
+const registerContentNitroConfig = ({
+  nuxt,
+  options,
+  appContentConfig,
+  contentContext,
+  runtimeInlineDependencies,
+  buildIntegrity,
+  resolvedI18n,
+  resolveRuntimeModule,
+  resolveModuleFile,
+  getResolvedContentContext,
+  getSearchRuntime
+}) => {
+  hookNuxtBoundary$1(nuxt, "nitro:config", (nitroConfig) => {
+    const searchRuntime = getSearchRuntime();
+    nitroConfig.prerender = nitroConfig.prerender || {};
+    nitroConfig.prerender.routes = nitroConfig.prerender.routes || [];
+    const usesFilesystemProvider = !contentContext.provider || contentContext.provider === "filesystem";
+    if (!nuxt.options.dev && usesFilesystemProvider) {
+      nitroConfig.prerender.routes.unshift(`${options.api.baseURL}/cache.${buildIntegrity}.json`);
+    }
+    const sources = useContentMounts(nuxt, contentContext.sources);
+    nitroConfig.devStorage = Object.assign(nitroConfig.devStorage || {}, sources);
+    nitroConfig.devStorage["cache:content"] = {
+      driver: "fs",
+      base: resolve$1(nuxt.options.buildDir, "content-cache")
+    };
+    for (const source of Object.values(sources)) {
+      if (source.driver === "fs" && typeof source.base === "string" && source.base.includes(nuxt.options.srcDir)) {
+        const wildcard = join(source.base, "**/*").replace(withTrailingSlash(nuxt.options.srcDir), "");
+        nuxt.options.ignore.push(wildcard, `!${wildcard}.vue`);
+      }
+    }
+    nitroConfig.bundledStorage = nitroConfig.bundledStorage || [];
+    nitroConfig.bundledStorage.push("cache:content");
+    nitroConfig.externals = defu(typeof nitroConfig.externals === "object" ? nitroConfig.externals : {}, {
+      inline: [
+        resolveModuleFile("./runtime"),
+        ...runtimeInlineDependencies
+      ]
+    });
+    if (searchRuntime !== false && searchRuntime.engine !== "cms" && usesFilesystemProvider) {
+      nitroConfig.routeRules = nitroConfig.routeRules || {};
+      nitroConfig.routeRules[searchRuntime.indexURL] = {
+        prerender: true,
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      };
+    }
+    if (contentContext.sitemap !== false) {
+      nitroConfig.plugins ||= [];
+      const sitemapPlugin = resolveRuntimeModule("server/plugins/sitemap.js");
+      if (!nitroConfig.plugins.includes(sitemapPlugin)) {
+        nitroConfig.plugins.push(sitemapPlugin);
+      }
+    }
+    if (contentContext.cache) {
+      nitroConfig.plugins ||= [];
+      const cachePlugin = resolveRuntimeModule("server/plugins/cache.js");
+      if (!nitroConfig.plugins.includes(cachePlugin)) {
+        nitroConfig.plugins.push(cachePlugin);
+      }
+    }
+    registerContentNitroIntegrationHooks(nitroConfig, {
+      rootDir: nuxt.options.rootDir,
+      sitemapPrerenderRoutes: () => contentContext.sitemap === false ? [] : resolveNuxtSitemapPrerenderRoutes(nuxt),
+      resolveContentContext: getResolvedContentContext
+    }, {
+      collections: contentContext.collections,
+      locales: contentContext.locales,
+      defaultLocale: contentContext.defaultLocale,
+      translatedSlugs: contentContext.translatedSlugs,
+      respectPathCase: contentContext.respectPathCase,
+      markdown: processMarkdownOptions(contentContext.markdown),
+      yaml: contentContext.yaml,
+      csv: contentContext.csv,
+      sitemap: contentContext.sitemap,
+      provider: contentContext.provider
+    });
+    const agentRoutes = normalizeAgentRouteOptions(options);
+    if (agentRoutes.routes && agentRoutes.prerender && appContentConfig.agent) {
+      nitroConfig.prerender.routes.push("/llms.txt", "/llms-full.txt");
+      for (const locale of appContentConfig.agent.site?.locales || resolvedI18n.locales || []) {
+        if (locale && locale !== (appContentConfig.agent.site?.defaultLocale || resolvedI18n.defaultLocale)) {
+          nitroConfig.prerender.routes.push(`/${locale}/llms.txt`, `/${locale}/llms-full.txt`);
+        }
+      }
+      for (const page of appContentConfig.agent.pages || []) {
+        const routes = typeof page.route === "string" ? [page.route] : Object.values(page.route);
+        for (const route of routes) {
+          const normalized = route === "/" ? "/" : `/${route.replace(/^\/+|\/+$/g, "")}`;
+          nitroConfig.prerender.routes.push(
+            normalized === "/" ? "/raw/index.md" : `/raw${normalized}.md`,
+            normalized === "/" ? "/index.md" : `${normalized}/index.md`
+          );
+        }
+      }
+    }
+  });
+};
+
+const BUILTIN_PLUGIN_PEER_DEPS = {
+  highlight: "shiki",
+  math: "katex",
+  mermaid: "beautiful-mermaid"
+};
+function assertConfiguredProviderAvailable(contentContext) {
+  const provider = contentContext.provider || "filesystem";
+  if (provider === "filesystem") return;
+  if (contentContext.providers?.[provider]) return;
+  if (provider === "cms") {
+    throw new Error('content.config.ts sets provider "cms", but no CMS provider module registered it. Add @lupinum/ginko-cms to nuxt.config.ts modules or remove provider: "cms".');
+  }
+  throw new Error(`content.config.ts sets provider "${provider}", but no provider module registered it. Register a module for "${provider}" or add it to content providers.`);
+}
+function validateCollectionNames(collections) {
+  normalizeContentConfigCollectionNames(collections);
+}
+function validateRemovedMarkdownOptions(options) {
+  if (options.highlight !== void 0) {
+    throw new Error("`content.highlight` was removed. Enable syntax highlighting with `content.markdown.plugins`, for example `[['highlight', { ...options }]]`.");
+  }
+  const markdown = options.markdown || {};
+  const removedOptions = ["mdc", "remarkPlugins", "rehypePlugins", "toc"];
+  const removed = removedOptions.filter((key) => typeof markdown[key] !== "undefined");
+  if (removed.length) {
+    throw new Error(`Removed markdown options: ${removed.map((option) => `content.markdown.${String(option)}`).join(", ")}. Use ordered \`content.markdown.plugins\` entries instead.`);
+  }
+}
+async function validateBuiltinMarkdownPlugins(plugins, resolvePath) {
+  for (const plugin of plugins) {
+    const peerDependency = BUILTIN_PLUGIN_PEER_DEPS[plugin.name];
+    if (!peerDependency) {
+      continue;
+    }
+    try {
+      await resolvePath(peerDependency);
+    } catch (error) {
+      const next = new Error(`Markdown plugin "${plugin.name}" requires "${peerDependency}" to be installed.`);
+      next.cause = error;
+      throw next;
+    }
+  }
+}
+
+const contentModuleDefaults = {
+  api: {
+    baseURL: "/api/_content"
+  },
+  i18n: true,
+  sitemap: true,
+  search: {
+    engine: "minisearch",
+    ignoredTags: ["script", "style", "pre"],
+    filterQuery: { _draft: false, _partial: false },
+    extraFields: [],
+    minisearch: {
+      fields: [...defaultMiniSearchOptions.fields],
+      storeFields: [...defaultMiniSearchOptions.storeFields],
+      boost: { ...defaultMiniSearchOptions.boost },
+      fuzzy: defaultMiniSearchOptions.fuzzy,
+      prefix: defaultMiniSearchOptions.prefix
+    }
+  },
+  watch: true,
+  sources: {},
+  ignores: [],
+  collections: {},
+  markdown: {
+    plugins: [],
+    tags: {
+      code: "ProseCode",
+      img: "ProseImg",
+      pre: "ProsePre"
+    },
+    anchorLinks: {
+      depth: 4,
+      exclude: [1]
+    },
+    image: "auto"
+  },
+  yaml: {},
+  csv: {
+    delimiter: ",",
+    json: true
+  },
+  navigation: {
+    fields: []
+  },
+  agent: {
+    routes: true,
+    linkHeaders: true,
+    markdownNegotiation: true,
+    prerender: true
+  },
+  contentHead: true,
+  respectPathCase: false,
+  experimental: {
+    stripQueryParameters: false
+  }
+};
+
+const resolveNuxtSiteUrl = (nuxt) => {
+  const publicRuntime = nuxt.options.runtimeConfig.public;
+  const publicContentRuntime = publicRuntime.content;
+  const configuredSiteUrl = publicContentRuntime?.siteUrl || publicRuntime.siteUrl;
+  if (typeof configuredSiteUrl === "string" && configuredSiteUrl.length > 0) {
+    return configuredSiteUrl;
+  }
+  const nuxtSite = nuxt.options.site;
+  return typeof nuxtSite?.url === "string" && nuxtSite.url.length > 0 ? nuxtSite.url : void 0;
+};
+const sanitizePublicMarkdownPluginValue = (value) => {
+  if (typeof value === "function" || typeof value === "symbol") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizePublicMarkdownPluginValue(item)).filter((item) => item !== void 0);
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).filter(([key]) => key !== "transformers").map(([key, item]) => [key, sanitizePublicMarkdownPluginValue(item)]).filter(([, item]) => item !== void 0));
+};
+const sanitizePublicMarkdownPlugins = (plugins) => plugins.map((plugin) => ({
+  name: plugin.name,
+  options: sanitizePublicMarkdownPluginValue(plugin.options || {})
+}));
+const sanitizePrivateMarkdownPluginValue = (value) => {
+  if (typeof value === "function" || typeof value === "symbol") {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => sanitizePrivateMarkdownPluginValue(item)).filter((item) => item !== void 0);
+  }
+  if (typeof value !== "object" || value === null) {
+    return value;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, sanitizePrivateMarkdownPluginValue(item)]).filter(([, item]) => item !== void 0));
+};
+const sanitizePrivateMarkdownPlugins = (plugins) => plugins.map((plugin) => ({
+  name: plugin.name,
+  options: sanitizePrivateMarkdownPluginValue(plugin.options || {})
+}));
+const applyContentRuntimeConfig = (nuxt, options, contentContext, runtimeCollections, buildIntegrity, cacheIntegrity) => {
+  const revalidate = options.revalidate === false ? void 0 : options.revalidate;
+  const searchRuntime = contentContext.search === false ? false : {
+    apiBaseURL: contentContext.search.apiBaseURL || `${options.api.baseURL.replace(/\/$/, "")}/search`,
+    indexURL: `${(contentContext.search.apiBaseURL || `${options.api.baseURL.replace(/\/$/, "")}/search`).replace(/\/$/, "")}/index.json`,
+    engine: contentContext.search.engine || "minisearch",
+    minisearch: normalizeMiniSearchOptions(contentContext.search.minisearch)
+  };
+  const siteUrl = resolveNuxtSiteUrl(nuxt);
+  const contentRuntime = defu(nuxt.options.runtimeConfig.public.content, {
+    ...siteUrl ? { siteUrl } : {},
+    locales: contentContext.locales,
+    provider: contentContext.provider || "filesystem",
+    providers: contentContext.providers || {},
+    defaultLocale: contentContext.defaultLocale || void 0,
+    localeFallback: contentContext.localeFallback || {},
+    translatedSlugs: contentContext.translatedSlugs ?? false,
+    strictTranslatedSlugs: contentContext.strictTranslatedSlugs ?? false,
+    collections: runtimeCollections,
+    integrity: buildIntegrity,
+    experimental: {
+      stripQueryParameters: options.experimental.stripQueryParameters
+    },
+    respectPathCase: options.respectPathCase ?? false,
+    api: {
+      baseURL: options.api.baseURL
+    },
+    markdown: {
+      plugins: sanitizePublicMarkdownPlugins(contentContext.markdown.plugins),
+      tags: contentContext.markdown.tags,
+      anchorLinks: contentContext.markdown.anchorLinks,
+      image: contentContext.markdown.image || "auto"
+    },
+    sitemap: contentContext.sitemap ? {
+      path: contentContext.sitemap.path || "/sitemap",
+      ...contentContext.sitemap.include?.length ? { include: contentContext.sitemap.include } : {},
+      ...contentContext.sitemap.exclude?.length ? { exclude: contentContext.sitemap.exclude } : {},
+      ...typeof contentContext.sitemap.includeDrafts === "boolean" ? { includeDrafts: contentContext.sitemap.includeDrafts } : {}
+    } : false,
+    search: searchRuntime,
+    navigation: contentContext.navigation,
+    contentHead: options.contentHead ?? true
+  });
+  const privateContentRuntime = {
+    ...contentContext,
+    markdown: {
+      ...contentContext.markdown,
+      plugins: sanitizePrivateMarkdownPlugins(contentContext.markdown.plugins)
+    }
+  };
+  nuxt.options.runtimeConfig.public.content = contentRuntime;
+  nuxt.options.runtimeConfig.content = defu(nuxt.options.runtimeConfig.content, {
+    cacheVersion: CACHE_VERSION,
+    cacheIntegrity,
+    revalidate: revalidate?.token ? {
+      token: revalidate.token,
+      allowUnsigned: revalidate.allowUnsigned === true
+    } : false,
+    ...privateContentRuntime,
+    collections: runtimeCollections
+  });
+};
+
+const registerContentContextFinalization = ({
+  nuxt,
+  options,
+  contentContext,
+  buildIntegrity,
+  resolvePath,
+  resolveRuntimeModule,
+  onResolved
+}) => {
+  nuxt.hook("modules:done", async () => {
+    await nuxt.callHook("content:providers", contentContext.providers ||= {});
+    assertConfiguredProviderAvailable(contentContext);
+    await nuxt.callHook("content:context", contentContext);
+    if (contentContext.search !== false) {
+      registerContentSearchServerHandlers(options.api.baseURL, contentContext.search, resolveRuntimeModule);
+    }
+    contentContext.defaultLocale = contentContext.defaultLocale || contentContext.locales[0];
+    const resolvedContentContext = {
+      ...contentContext,
+      markdown: processMarkdownOptions(contentContext.markdown)
+    };
+    onResolved(resolvedContentContext);
+    await validateBuiltinMarkdownPlugins(resolvedContentContext.markdown.plugins, resolvePath);
+    const runtimeCollections = Object.fromEntries(Object.entries(options.collections || {}).map(([name, collection]) => {
+      const references = collectTopLevelReferenceFieldsByTarget(collection.schema);
+      return [
+        name,
+        {
+          ...collection.source ? { source: collection.source } : {},
+          ...collection.exclude ? { exclude: collection.exclude } : {},
+          ...collection.type ? { type: collection.type } : {},
+          strict: collection.strict ?? true,
+          ...collection.route ? { route: collection.route } : {},
+          ...typeof collection.sitemap === "boolean" ? { sitemap: collection.sitemap } : {},
+          ...collection.i18n && collection.i18n !== true ? { i18n: collection.i18n } : {},
+          ...Object.keys(references).length ? { references } : {}
+        }
+      ];
+    }));
+    const cacheIntegrity = hash({
+      locales: resolvedContentContext.locales,
+      defaultLocale: resolvedContentContext.defaultLocale,
+      localeFallback: resolvedContentContext.localeFallback,
+      translatedSlugs: resolvedContentContext.translatedSlugs,
+      strictTranslatedSlugs: resolvedContentContext.strictTranslatedSlugs,
+      respectPathCase: resolvedContentContext.respectPathCase,
+      collections: runtimeCollections,
+      markdown: resolvedContentContext.markdown,
+      yaml: resolvedContentContext.yaml,
+      csv: resolvedContentContext.csv
+    });
+    applyContentRuntimeConfig(nuxt, options, resolvedContentContext, runtimeCollections, buildIntegrity, cacheIntegrity);
+  });
+};
+
+const hookNuxtBoundary = (nuxt, name2, callback) => {
+  const hook = nuxt.hook;
+  hook(name2, callback);
+};
 const module$1 = defineNuxtModule({
   meta: {
     name,
@@ -1236,69 +1799,7 @@ const module$1 = defineNuxtModule({
       }
     }
   },
-  defaults: {
-    api: {
-      baseURL: "/api/_content"
-    },
-    i18n: true,
-    sitemap: true,
-    search: {
-      engine: "minisearch",
-      ignoredTags: ["script", "style", "pre"],
-      filterQuery: { _draft: false, _partial: false },
-      extraFields: [],
-      minisearch: {
-        fields: ["title", "content", "headings"],
-        storeFields: ["path", "title", "excerpt", "anchor", "locale"],
-        boost: {
-          title: 4,
-          headings: 2,
-          content: 1
-        },
-        fuzzy: 0.2,
-        prefix: true
-      }
-    },
-    watch: {
-      ws: {
-        port: {
-          port: 4e3,
-          portRange: [4e3, 4040]
-        },
-        hostname: "localhost",
-        showURL: false
-      }
-    },
-    sources: {},
-    ignores: [],
-    collections: {},
-    markdown: {
-      plugins: [],
-      tags: {
-        code: "ProseCode",
-        img: "ProseImg",
-        pre: "ProsePre"
-      },
-      anchorLinks: {
-        depth: 4,
-        exclude: [1]
-      },
-      image: "auto"
-    },
-    yaml: {},
-    csv: {
-      delimiter: ",",
-      json: true
-    },
-    navigation: {
-      fields: []
-    },
-    contentHead: true,
-    respectPathCase: false,
-    experimental: {
-      stripQueryParameters: false
-    }
-  },
+  defaults: contentModuleDefaults,
   async setup(options, nuxt) {
     const { resolve, resolvePath } = createResolver(import.meta.url);
     const logger = useLogger(name);
@@ -1317,6 +1818,10 @@ const module$1 = defineNuxtModule({
     });
     const contentConfigPath = resolveContentConfigPath(nuxt);
     const appContentConfig = await loadContentConfig(nuxt);
+    const externalGinkoContentConfig = nuxt.options.ginkoContent;
+    if (externalGinkoContentConfig?.agent && options.agent !== false) {
+      options.agent = defu(options.agent || {}, externalGinkoContentConfig.agent);
+    }
     if (!contentConfigPath || !appContentConfig.collections || !Object.keys(appContentConfig.collections).length) {
       throw new Error("@lupinum/ginko-content requires a content.config.ts with at least one collection. Define collections with defineContentConfig({ collections: { ... } }).");
     }
@@ -1324,6 +1829,10 @@ const module$1 = defineNuxtModule({
     const resolvedSitemap = normalizeSitemapOptions(options);
     const resolvedSearch = normalizeSearchOptions(options);
     validateCollectionNames(appContentConfig.collections);
+    if (!hasAgentSurface(appContentConfig)) {
+      options.agent = false;
+    }
+    validateAgentConfig(appContentConfig, options, { dev: nuxt.options.dev });
     options.collections = Object.fromEntries(Object.entries(appContentConfig.collections).map(([name2, collection]) => [
       name2,
       {
@@ -1353,25 +1862,32 @@ const module$1 = defineNuxtModule({
       sitemap: resolvedSitemap,
       search: resolvedSearch
     };
+    let resolvedContentContext;
+    const getResolvedContentContext = () => {
+      if (!resolvedContentContext) {
+        throw new Error("Content runtime config was read before content context resolution completed.");
+      }
+      return resolvedContentContext;
+    };
     if (resolvedSitemap !== false) {
       configureNuxtSitemapSource(nuxt, options.api.baseURL, resolvedSitemap.path);
     }
     nuxt.hook("pages:extend", (pages) => {
-      validateContentPageRouteMetadata(pages, options.collections, {
+      validateContentPageRouteMetadata(pages, options.collections || {}, {
         locales: resolvedI18n.locales,
         defaultLocale: resolvedI18n.defaultLocale
       });
     });
     if (resolvedSitemap && resolvedSitemap.assert.enabled) {
-      nuxt.hook("sitemap:prerender:done", async ({ sitemaps }) => {
-        const assertOptions = contentContext.sitemap?.assert;
+      hookNuxtBoundary(nuxt, "sitemap:prerender:done", async ({ sitemaps }) => {
+        const assertOptions = resolvedSitemap ? resolvedSitemap.assert : void 0;
         if (!assertOptions || !shouldRunSitemapAssertionOnPrerenderedSitemaps(assertOptions)) {
           return;
         }
         await assertGeneratedSitemaps({
           options: assertOptions,
           targets: createSitemapAssertionTargetsFromPrerenderedSitemaps(sitemaps),
-          collectionRouteCounts: await collectSitemapCollectionRouteCounts(nuxt.options.rootDir, contentContext),
+          collectionRouteCounts: await collectSitemapCollectionRouteCounts(nuxt.options.rootDir, getResolvedContentContext()),
           logger
         });
       });
@@ -1389,146 +1905,40 @@ const module$1 = defineNuxtModule({
       Object.keys(appContentConfig.collections),
       Object.entries(appContentConfig.collections).filter(([, collection]) => Boolean(collection.i18n)).map(([name2]) => name2)
     );
-    await registerUserContentComponents(nuxt, resolve);
+    await registerUserContentComponents(nuxt);
     const getSearchRuntime = () => contentContext.search === false ? false : createSearchRuntimeConfig(contentContext.search, options.api.baseURL);
-    nuxt.hook("nitro:config", (nitroConfig) => {
-      const searchRuntime = getSearchRuntime();
-      nitroConfig.prerender = nitroConfig.prerender || {};
-      nitroConfig.prerender.routes = nitroConfig.prerender.routes || [];
-      const usesFilesystemProvider = !contentContext.provider || contentContext.provider === "filesystem";
-      if (!nuxt.options.dev && usesFilesystemProvider) {
-        nitroConfig.prerender.routes.unshift(`${options.api.baseURL}/cache.${buildIntegrity}.json`);
-      }
-      const sources = useContentMounts(nuxt, contentContext.sources);
-      nitroConfig.devStorage = Object.assign(nitroConfig.devStorage || {}, sources);
-      nitroConfig.devStorage["cache:content"] = {
-        driver: "fs",
-        base: resolve(nuxt.options.buildDir, "content-cache")
-      };
-      for (const source of Object.values(sources)) {
-        if (source.driver === "fs" && source.base.includes(nuxt.options.srcDir)) {
-          const wildcard = join(source.base, "**/*").replace(withTrailingSlash(nuxt.options.srcDir), "");
-          nuxt.options.ignore.push(
-            // Remove `srcDir` from the path
-            wildcard,
-            `!${wildcard}.vue`
-          );
-        }
-      }
-      nitroConfig.bundledStorage = nitroConfig.bundledStorage || [];
-      nitroConfig.bundledStorage.push("cache:content");
-      nitroConfig.externals = defu(typeof nitroConfig.externals === "object" ? nitroConfig.externals : {}, {
-        inline: [
-          resolve("./runtime"),
-          ...runtimeInlineDependencies
-        ]
-      });
-      if (searchRuntime !== false && searchRuntime.engine !== "cms" && usesFilesystemProvider) {
-        nitroConfig.routeRules = nitroConfig.routeRules || {};
-        nitroConfig.routeRules[searchRuntime.indexURL] = {
-          prerender: true,
-          headers: { "Content-Type": "application/json; charset=utf-8" }
-        };
-      }
-      if (contentContext.sitemap !== false) {
-        nitroConfig.plugins ||= [];
-        const sitemapPlugin = resolveRuntimeModule("server/plugins/sitemap.js");
-        if (!nitroConfig.plugins.includes(sitemapPlugin)) {
-          nitroConfig.plugins.push(sitemapPlugin);
-        }
-      }
-      if (contentContext.cache && contentContext.cache !== false) {
-        nitroConfig.plugins ||= [];
-        const cachePlugin = resolveRuntimeModule("server/plugins/cache.js");
-        if (!nitroConfig.plugins.includes(cachePlugin)) {
-          nitroConfig.plugins.push(cachePlugin);
-        }
-      }
-      registerContentNitroIntegrationHooks(nitroConfig, {
-        rootDir: nuxt.options.rootDir,
-        sitemapPrerenderRoutes: () => contentContext.sitemap === false ? [] : resolveNuxtSitemapPrerenderRoutes(nuxt)
-      }, {
-        collections: contentContext.collections,
-        locales: contentContext.locales,
-        defaultLocale: contentContext.defaultLocale,
-        translatedSlugs: contentContext.translatedSlugs,
-        strictTranslatedSlugs: contentContext.strictTranslatedSlugs,
-        respectPathCase: contentContext.respectPathCase,
-        markdown: contentContext.markdown,
-        yaml: contentContext.yaml,
-        csv: contentContext.csv,
-        sitemap: contentContext.sitemap,
-        provider: contentContext.provider
-      });
+    registerContentNitroConfig({
+      nuxt,
+      options,
+      appContentConfig,
+      contentContext,
+      runtimeInlineDependencies,
+      buildIntegrity,
+      resolvedI18n,
+      resolveRuntimeModule,
+      resolveModuleFile: resolve,
+      getResolvedContentContext,
+      getSearchRuntime
     });
-    if (!nuxt.options.dev) {
-      nuxt.hook("nitro:build:before", (nitro) => {
-        nitro.hooks.hook("prerender:init", (prerenderer) => {
-          prerenderer.hooks.hook("compiled", async () => {
-            const searchRuntime = getSearchRuntime();
-            if (searchRuntime === false || searchRuntime.engine === "cms" || contentContext.provider && contentContext.provider !== "filesystem") {
-              return;
-            }
-            const publicDir = nitro.options.output.publicDir || nuxt.options.nitro.output?.publicDir || resolve$1(nuxt.options.rootDir, ".output/public");
-            const serverFilename = typeof prerenderer.options.rollupConfig?.output?.entryFileNames === "string" ? prerenderer.options.rollupConfig.output.entryFileNames : "index.mjs";
-            const serverEntrypoint = resolve$1(prerenderer.options.output.serverDir, serverFilename);
-            const { localFetch } = await import(pathToFileURL(serverEntrypoint).href);
-            const response = await localFetch(searchRuntime.indexURL);
-            if (!response.ok) {
-              throw new Error(`Failed to generate search index: [${response.status}] ${response.statusText}`);
-            }
-            const json = await response.text();
-            const indexPath = join(publicDir, searchRuntime.indexURL.replace(/^\//, ""));
-            mkdirSync(dirname(indexPath), { recursive: true });
-            writeFileSync(indexPath, json, "utf8");
-            if (searchRuntime.engine === "pagefind") {
-              const records = JSON.parse(json);
-              const { writePagefindIndex } = await import(resolveRuntimeModule("./server/pagefind.js"));
-              await writePagefindIndex(records, resolve$1(publicDir, "pagefind"));
-            }
-          });
-        });
-      });
-    }
-    nuxt.hook("modules:done", async () => {
-      await nuxt.callHook("content:providers", contentContext.providers ||= {});
-      assertConfiguredProviderAvailable(contentContext);
-      await nuxt.callHook("content:context", contentContext);
-      if (contentContext.search !== false) {
-        registerContentSearchServerHandlers(options.api.baseURL, contentContext.search, resolveRuntimeModule);
+    registerStaticOutputGeneration({
+      nuxt,
+      options,
+      appContentConfig,
+      contentContext,
+      resolvedI18n,
+      resolveRuntimeModule,
+      getSearchRuntime
+    });
+    registerContentContextFinalization({
+      nuxt,
+      options,
+      contentContext,
+      buildIntegrity,
+      resolvePath,
+      resolveRuntimeModule,
+      onResolved: (context) => {
+        resolvedContentContext = context;
       }
-      contentContext.defaultLocale = contentContext.defaultLocale || contentContext.locales[0];
-      contentContext.markdown = processMarkdownOptions(contentContext.markdown);
-      await validateBuiltinMarkdownPlugins(contentContext.markdown.plugins, resolvePath);
-      const runtimeCollections = Object.fromEntries(Object.entries(options.collections || {}).map(([name2, collection]) => {
-        const references = collectTopLevelReferenceFieldsByTarget(collection.schema);
-        return [
-          name2,
-          {
-            ...collection.source ? { source: collection.source } : {},
-            ...collection.exclude ? { exclude: collection.exclude } : {},
-            ...collection.type ? { type: collection.type } : {},
-            strict: collection.strict ?? true,
-            ...collection.route ? { route: collection.route } : {},
-            ...typeof collection.sitemap === "boolean" ? { sitemap: collection.sitemap } : {},
-            ...collection.i18n && collection.i18n !== true ? { i18n: collection.i18n } : {},
-            ...Object.keys(references).length ? { references } : {}
-          }
-        ];
-      }));
-      const cacheIntegrity = hash({
-        locales: contentContext.locales,
-        defaultLocale: contentContext.defaultLocale,
-        localeFallback: contentContext.localeFallback,
-        translatedSlugs: contentContext.translatedSlugs,
-        strictTranslatedSlugs: contentContext.strictTranslatedSlugs,
-        respectPathCase: contentContext.respectPathCase,
-        collections: runtimeCollections,
-        markdown: contentContext.markdown,
-        yaml: contentContext.yaml,
-        csv: contentContext.csv
-      });
-      applyContentRuntimeConfig(nuxt, options, contentContext, runtimeCollections, buildIntegrity, cacheIntegrity);
     });
     if (nuxt.options.dev) {
       registerDevRuntimePlugin(resolveRuntimeModule);
@@ -1536,46 +1946,5 @@ const module$1 = defineNuxtModule({
     }
   }
 });
-function assertConfiguredProviderAvailable(contentContext) {
-  const provider = contentContext.provider || "filesystem";
-  if (provider === "filesystem") return;
-  if (contentContext.providers?.[provider]) return;
-  if (provider === "cms") {
-    throw new Error('content.config.ts sets provider "cms", but no CMS provider module registered it. Add @lupinum/ginko-cms to nuxt.config.ts modules or remove provider: "cms".');
-  }
-  throw new Error(`content.config.ts sets provider "${provider}", but no provider module registered it. Register a module for "${provider}" or add it to content providers.`);
-}
-function validateCollectionNames(collections) {
-  normalizeContentConfigCollectionNames(collections);
-}
-function validateRemovedMarkdownOptions(options) {
-  if (options.highlight !== void 0) {
-    throw new Error("`content.highlight` was removed. Enable syntax highlighting with `content.markdown.plugins`, for example `[['highlight', { ...options }]]`.");
-  }
-  const markdown = options.markdown || {};
-  const removedOptions = ["mdc", "remarkPlugins", "rehypePlugins", "toc"];
-  const removed = removedOptions.filter((key) => typeof markdown[key] !== "undefined");
-  if (removed.length) {
-    throw new Error(`Removed markdown options: ${removed.map((option) => `content.markdown.${String(option)}`).join(", ")}. Use ordered \`content.markdown.plugins\` entries instead.`);
-  }
-}
-async function validateBuiltinMarkdownPlugins(plugins, resolvePath) {
-  for (const plugin of plugins) {
-    const peerDependency = BUILTIN_PLUGIN_PEER_DEPS[plugin.name];
-    if (!peerDependency) {
-      continue;
-    }
-    try {
-      await resolvePath(peerDependency);
-    } catch (error) {
-      throw new Error(`Markdown plugin "${plugin.name}" requires "${peerDependency}" to be installed.`, { cause: error });
-    }
-  }
-}
-const BUILTIN_PLUGIN_PEER_DEPS = {
-  highlight: "shiki",
-  math: "katex",
-  mermaid: "beautiful-mermaid"
-};
 
 export { module$1 as default };