@lupinum/ginko-content 0.1.0

package/dist/module.mjs

@@ -0,0 +1,1381 @@
+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 { hash } from 'ohash';
+import { resolve, join, relative, isAbsolute } from 'pathe';
+import { withTrailingSlash } from 'ufo';
+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 { resolveCollectionI18nConfig } from '../dist/features/localization/config';
+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 { normalizeCollectionSources, normalizeCollectionExcludes } from '../dist/core/content/sources';
+import { resolveCollectionI18n, prefixPathWithLocale } from '../dist/features/localization/path';
+import { resolveCollection } from '../dist/core/content/collection';
+export { defineCollection, defineContentConfig, reference } from '../dist/types/config';
+
+const name = "@lupinum/ginko-content";
+const version = "0.1.0";
+
+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 CONFIG_FILES = [
+  "content.config.ts",
+  "content.config.mts",
+  "content.config.js",
+  "content.config.mjs",
+  "content.config.cjs"
+];
+function resolveContentConfigPath(nuxt) {
+  return CONFIG_FILES.map((name) => join(nuxt.options.rootDir, name)).find((path) => existsSync(path));
+}
+async function loadContentConfig(nuxt) {
+  const configPath = resolveContentConfigPath(nuxt);
+  if (!configPath) {
+    return {};
+  }
+  const importer = jiti(nuxt.options.rootDir, { interopDefault: true });
+  const loaded = await importer.import(configPath);
+  return loaded?.default || loaded || {};
+}
+
+const require$1 = createRequire(import.meta.url);
+const jitiImportSpecifier = pathToFileURL(require$1.resolve("jiti")).href;
+const createVirtualContentTemplates = (contentContext, nuxt, contentConfigPath, addTemplateImpl) => {
+  const transformersTemplate = addTemplateImpl({
+    filename: "content/virtual-transformers.mjs",
+    write: true,
+    getContents: () => {
+      const transformers = contentContext.transformers.map((transformer) => {
+        const name = genSafeVariableName(relative(nuxt.options.rootDir, transformer)).replace(/_(45|46|47)/g, "_") + "_" + hash(transformer);
+        return { name, import: genImport(transformer, name) };
+      });
+      return [
+        ...transformers.map((transformer) => transformer.import),
+        `export const transformers = [${transformers.map((transformer) => transformer.name).join(", ")}]`,
+        'export const getParser = (ext) => transformers.find(p => ext.match(new RegExp(p.extensions.join("|"),  "i")) && p.parse)',
+        'export const getTransformers = (ext) => transformers.filter(p => ext.match(new RegExp(p.extensions.join("|"),  "i")) && p.transform)',
+        "export default () => {}"
+      ].join("\n");
+    }
+  }).dst;
+  const virtualConfigTemplate = addTemplateImpl({
+    filename: "content/virtual-config.mjs",
+    write: true,
+    getContents: () => contentConfigPath ? [
+      `import jiti from ${JSON.stringify(jitiImportSpecifier)}`,
+      `const importer = jiti(import.meta.url, { interopDefault: true })`,
+      `const config = await importer.import(${JSON.stringify(contentConfigPath)})`,
+      "export default config?.default || config || {}"
+    ].join("\n") : "export default {}"
+  }).dst;
+  const virtualProvidersTemplate = addTemplateImpl({
+    filename: "content/virtual-providers.mjs",
+    write: true,
+    getContents: () => {
+      const providers = Object.entries(contentContext.providers || {});
+      const cases = providers.map(([name, specifier]) => {
+        return `case ${JSON.stringify(name)}: return import(${JSON.stringify(specifier)}).then(resolveProviderModule)`;
+      });
+      return [
+        "const resolveProviderModule = (mod) => mod.default || mod.contentProvider || mod.provider",
+        "export const externalContentProviderNames = " + JSON.stringify(providers.map(([name]) => name)),
+        "export const loadExternalContentProvider = (name) => {",
+        "  switch (name) {",
+        ...cases.map((item) => `    ${item}`),
+        "    default: return undefined",
+        "  }",
+        "}",
+        "export default {}"
+      ].join("\n");
+    }
+  }).dst;
+  const virtualCacheAdapterTemplate = addTemplateImpl({
+    filename: "content/virtual-cache-adapter.mjs",
+    write: true,
+    getContents: () => {
+      const cache = contentContext.cache;
+      if (!cache || cache === false) {
+        return [
+          "export const loadContentCacheAdapter = () => undefined",
+          "export default {}"
+        ].join("\n");
+      }
+      return [
+        "const resolveCacheAdapterModule = (mod) => mod.default || mod.contentCacheAdapter || mod.cacheAdapter",
+        `export const loadContentCacheAdapter = () => import(${JSON.stringify(cache)}).then(resolveCacheAdapterModule)`,
+        "export default {}"
+      ].join("\n");
+    }
+  }).dst;
+  return {
+    transformersTemplate,
+    virtualConfigTemplate,
+    virtualProvidersTemplate,
+    virtualCacheAdapterTemplate
+  };
+};
+const registerVirtualContentAliases = (nuxt, transformersTemplate, virtualConfigTemplate, virtualProvidersTemplate, virtualCacheAdapterTemplate, resolveRuntimeModule) => {
+  nuxt.options.alias = nuxt.options.alias || {};
+  nuxt.options.alias["#content/virtual/transformers"] = transformersTemplate;
+  nuxt.options.alias["#content/virtual/config"] = virtualConfigTemplate;
+  nuxt.options.alias["#content/virtual/providers"] = virtualProvidersTemplate;
+  nuxt.options.alias["#content/virtual/cache-adapter"] = virtualCacheAdapterTemplate;
+  nuxt.hook("nitro:config", (nitroConfig) => {
+    nitroConfig.alias = nitroConfig.alias || {};
+    nitroConfig.alias["#content/server"] = resolveRuntimeModule("./server/index.js");
+    nitroConfig.alias["#content/virtual/transformers"] = transformersTemplate;
+    nitroConfig.alias["#content/virtual/config"] = virtualConfigTemplate;
+    nitroConfig.alias["#content/virtual/providers"] = virtualProvidersTemplate;
+    nitroConfig.alias["#content/virtual/cache-adapter"] = virtualCacheAdapterTemplate;
+  });
+};
+
+const registerContentDevRuntime = (nuxt, options, contentContext) => {
+  const isIgnored = makeIgnored(contentContext.ignores);
+  nuxt.hook("nitro:init", async (nitro) => {
+    if (!options.watch || !options.watch.ws) {
+      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;
+      }
+      key = key.substring(MOUNT_PREFIX.length);
+      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 });
+    });
+    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 registerRuntimeImports = (resolveRuntimeModule) => {
+  addImports([
+    // Unified query API (ADR-0016) — app wrappers bind the Nuxt content context explicitly.
+    { name: "one", as: "one", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "many", as: "many", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "paginate", as: "paginate", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "backlinks", as: "backlinks", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "resolveOne", as: "resolveOne", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "variants", as: "variants", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "tree", as: "tree", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "neighbors", as: "neighbors", from: resolveRuntimeModule("./app/composables/query-api.js") },
+    { name: "getCollectionPath", as: "getCollectionPath", from: resolveRuntimeModule("./query/routes.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: "useContentNeighbors", as: "useContentNeighbors", from: resolveRuntimeModule("./app/composables/use-content.js") },
+    { name: "useContentLocaleSwitch", as: "useContentLocaleSwitch", from: resolveRuntimeModule("./app/composables/use-content.js") },
+    // Search & site data — kept (out of scope for ADR-0016).
+    { 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") }
+  ]);
+};
+const registerRuntimeComponents = (resolve) => {
+  addComponentsDir({
+    path: resolve("./runtime/app/components"),
+    pathPrefix: false,
+    prefix: "",
+    global: true,
+    ignore: ["Prose/**", "internal/**"]
+  });
+};
+const registerContentI18nTemplate = (addTemplateImpl, hasNuxtI18nModule) => {
+  addTemplateImpl({
+    filename: "content-i18n.mjs",
+    write: true,
+    getContents: () => hasNuxtI18nModule ? [
+      "export { useRouteBaseName, useSetI18nParams, useSwitchLocalePath } from '#i18n'"
+    ].join("\n") : [
+      "const routeNameLocaleRE = /___([^_]+)$/",
+      "const resolveName = (value) => {",
+      "  if (typeof value === 'string') {",
+      "    return value",
+      "  }",
+      "  if (value && typeof value === 'object' && 'name' in value) {",
+      "    return value.name",
+      "  }",
+      "  return undefined",
+      "}",
+      "export const useRouteBaseName = () => (value) => {",
+      "  const name = resolveName(value)",
+      "  return typeof name === 'string' ? name.replace(routeNameLocaleRE, '') : undefined",
+      "}",
+      "export const useSetI18nParams = () => () => {}",
+      "export const useSwitchLocalePath = () => () => ''"
+    ].join("\n")
+  });
+  addTemplateImpl({
+    filename: "content-i18n.d.mts",
+    write: true,
+    getContents: () => [
+      "export function useRouteBaseName(): (route: { name?: unknown } | unknown) => string | undefined",
+      "export function useSetI18nParams(): (params: Record<string, unknown>) => void",
+      "export function useSwitchLocalePath(): (locale: string) => string"
+    ].join("\n")
+  });
+  addTypeTemplate({
+    filename: "types/content-i18n.d.ts",
+    getContents: () => [
+      "declare module '#build/content-i18n.mjs' {",
+      "  export function useRouteBaseName(): (route: { name?: unknown } | unknown) => string | undefined",
+      "  export function useSetI18nParams(): (params: Record<string, unknown>) => void",
+      "  export function useSwitchLocalePath(): (locale: string) => string",
+      "}"
+    ].join("\n")
+  });
+};
+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 dirStat = await fs.promises.stat(globalComponents).catch((error) => {
+      if (error.code === "ENOENT") {
+        return null;
+      }
+      throw error;
+    });
+    if (dirStat && dirStat.isDirectory()) {
+      nuxt.hook("components:dirs", (dirs) => {
+        dirs.unshift({
+          path: globalComponents,
+          global: false,
+          pathPrefix: false,
+          prefix: ""
+        });
+      });
+    }
+  }
+};
+const registerGeneratedTypes = (contentConfigPath, resolveRuntimeModuleRoot) => {
+  return addTypeTemplate({
+    filename: "types/content.d.ts",
+    getContents: () => [
+      contentConfigPath ? `import type contentConfig from ${JSON.stringify(contentConfigPath)}` : "type __ContentConfig = { collections?: {} }",
+      "import type { StrictParsedContent } from '@lupinum/ginko-content'",
+      "import type { CollectionSchema } from '@lupinum/ginko-content/config'",
+      contentConfigPath ? "type __ContentConfig = typeof contentConfig" : "",
+      "type __ContentCollections = NonNullable<__ContentConfig['collections']>",
+      "type __GeneratedContentCollectionMap = {",
+      "  [K in keyof __ContentCollections & string]: StrictParsedContent & CollectionSchema<__ContentCollections[K]>",
+      "}",
+      "type __GeneratedI18nCollectionNames = {",
+      "  [K in keyof __ContentCollections & string]: NonNullable<__ContentCollections[K]['i18n']> extends never ? never : K",
+      "}[keyof __ContentCollections & string]",
+      "declare module '@lupinum/ginko-content' {",
+      "  interface ContentCollectionMap extends __GeneratedContentCollectionMap {}",
+      "  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`,
+      "}"
+    ].filter(Boolean).join("\n")
+  });
+};
+const registerDevRuntimePlugin = (resolveRuntimeModule) => {
+  addPlugin(resolveRuntimeModule("./app/plugins/ws.js"));
+};
+
+const registerContentServerHandlers = (nuxt, options, resolveRuntimeModule, buildIntegrity) => {
+  addServerHandler({
+    method: "get",
+    route: `${options.api.baseURL}/query/**:params`,
+    handler: resolveRuntimeModule("./server/api/query.js")
+  });
+  addServerHandler({
+    method: "get",
+    route: `${options.api.baseURL}/query`,
+    handler: resolveRuntimeModule("./server/api/query.js")
+  });
+  addServerHandler({
+    method: "get",
+    route: `${options.api.baseURL}/locales/:collection`,
+    handler: resolveRuntimeModule("./server/api/locales.js")
+  });
+  addServerHandler({
+    method: "get",
+    route: `${options.api.baseURL}/site-data`,
+    handler: resolveRuntimeModule("./server/api/site-data.js")
+  });
+  if (options.revalidate && options.revalidate !== false && options.revalidate.token) {
+    addServerHandler({
+      method: "post",
+      route: `${options.api.baseURL}/revalidate`,
+      handler: resolveRuntimeModule("./server/api/revalidate.js")
+    });
+  }
+  addServerHandler({
+    method: "get",
+    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) {
+    addServerHandler({
+      method: "get",
+      route: `${options.api.baseURL}${options.sitemap.path || "/sitemap"}`,
+      handler: resolveRuntimeModule("./server/api/sitemap.js")
+    });
+  }
+  if (options.navigation) {
+    addServerHandler({
+      method: "get",
+      route: `${options.api.baseURL}/navigation/**:params`,
+      handler: resolveRuntimeModule("./server/api/navigation.js")
+    });
+    addServerHandler({
+      method: "get",
+      route: `${options.api.baseURL}/navigation`,
+      handler: resolveRuntimeModule("./server/api/navigation.js")
+    });
+  }
+};
+const registerContentSearchServerHandlers = (apiBaseURL, search, resolveRuntimeModule) => {
+  const searchBaseURL = search.apiBaseURL || `${apiBaseURL.replace(/\/$/, "")}/search`;
+  const indexURL = `${searchBaseURL.replace(/\/$/, "")}/index.json`;
+  addServerHandler({
+    method: "get",
+    route: searchBaseURL,
+    handler: resolveRuntimeModule("./server/api/search.js")
+  });
+  if (search.engine !== "cms") {
+    addServerHandler({
+      method: "get",
+      route: indexURL,
+      handler: resolveRuntimeModule("./server/api/search-index.js")
+    });
+  }
+};
+
+const SITEMAP_INDEX = "sitemap_index.xml";
+const assert = (condition, message) => {
+  if (!condition) {
+    throw new Error(message);
+  }
+};
+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]);
+};
+const toLocalPath = (value) => {
+  try {
+    return new URL(value).pathname;
+  } catch {
+    return value;
+  }
+};
+const discoverSitemapsFromDisk = async (outputPublicDir) => {
+  const indexPath = join$1(outputPublicDir, SITEMAP_INDEX);
+  try {
+    const sitemapIndex = await readFile(indexPath, "utf8");
+    const locValues = extractLocValues(sitemapIndex);
+    const discovered = locValues.map(toLocalPath).filter((path) => path.endsWith(".xml") && path !== "/sitemap.xml" && path !== "/sitemap_index.xml").map((path) => {
+      const normalizedPath = path.replace(/^\/+/, "");
+      return {
+        name: basename(normalizedPath, ".xml"),
+        path: join$1(outputPublicDir, normalizedPath)
+      };
+    });
+    if (discovered.length > 0) {
+      return Promise.all(discovered.map(async (target) => ({
+        ...target,
+        xml: await readFile(target.path, "utf8")
+      })));
+    }
+  } catch {
+  }
+  const children = [];
+  const sitemapDir = join$1(outputPublicDir, "__sitemap__");
+  try {
+    const sitemapFiles = (await readdir(sitemapDir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".xml")).map((entry) => ({
+      name: basename(entry.name, ".xml"),
+      path: join$1(sitemapDir, entry.name)
+    }));
+    children.push(...await Promise.all(sitemapFiles.map(async (target) => ({
+      ...target,
+      xml: await readFile(target.path, "utf8")
+    }))));
+  } catch {
+  }
+  if (children.length > 0) {
+    return children;
+  }
+  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.`
+  );
+  return [{
+    name: "sitemap",
+    path: rootSitemapPath,
+    xml: rootSitemapXml
+  }];
+};
+const normalizeContentSitemapAssertOptions = (options) => ({
+  enabled: options?.enabled ?? false,
+  mode: options?.mode ?? "generate",
+  allowEmpty: options?.allowEmpty ?? false,
+  minUrlsPerSitemap: options?.minUrlsPerSitemap ?? 1,
+  requireImages: options?.requireImages ?? false,
+  requiredCollections: options?.requiredCollections ?? [],
+  sitemaps: options?.sitemaps ?? {}
+});
+const shouldRunSitemapAssertionOnCompiled = (options, nitro) => {
+  const isStaticLikeBuild = nitro.options.static || nitro.options.preset === "static";
+  if (!options.enabled || isStaticLikeBuild) {
+    return false;
+  }
+  return options.mode === "build" || options.mode === "both";
+};
+const shouldRunSitemapAssertionOnPrerenderedSitemaps = (options) => options.enabled && options.mode !== "build";
+async function assertGeneratedSitemaps({
+  options,
+  collectionRouteCounts,
+  outputPublicDir,
+  targets,
+  logger
+}) {
+  const discoveredSitemaps = targets || (outputPublicDir ? await discoverSitemapsFromDisk(outputPublicDir) : []);
+  assert(discoveredSitemaps.length > 0, "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)) {
+    if (!targetMap.has(sitemapName)) {
+      const sourceDescription = outputPublicDir ? join$1(outputPublicDir, SITEMAP_INDEX) : "prerendered sitemap_index.xml";
+      failures.push(`- Missing sitemap "${sitemapName}" in ${sourceDescription}`);
+    }
+  }
+  for (const target of targetMap.values()) {
+    const overrides = options.sitemaps[target.name] || {};
+    const allowEmpty = overrides.allowEmpty ?? options.allowEmpty;
+    const minUrls = overrides.minUrls ?? options.minUrlsPerSitemap;
+    const requireImages = overrides.requireImages ?? options.requireImages;
+    const urlCount = countTag(target.xml, "url");
+    const imageCount = countTag(target.xml, "image:image");
+    if (!allowEmpty && urlCount < minUrls) {
+      failures.push(`- ${target.name}: ${urlCount} URLs, expected at least ${minUrls}`);
+    }
+    if (requireImages && imageCount === 0) {
+      failures.push(`- ${target.name}: expected image entries but found none`);
+    }
+  }
+  const missingCollections = options.requiredCollections.filter((collection) => (collectionRouteCounts[collection] || 0) === 0);
+  if (missingCollections.length) {
+    failures.push(`- Missing content sitemap routes for collections: ${missingCollections.join(", ")}`);
+  }
+  if (failures.length) {
+    throw new Error(`Content sitemap assertion failed:
+${failures.join("\n")}`);
+  }
+  logger?.info(`Content sitemap assertion passed for ${targetMap.size} sitemap${targetMap.size === 1 ? "" : "s"}.`);
+}
+const createSitemapAssertionTargetsFromPrerenderedSitemaps = (sitemaps) => {
+  const targets = sitemaps.map((sitemap) => {
+    const path = toLocalPath(sitemap.name);
+    const name = basename(path, ".xml");
+    return {
+      name,
+      path,
+      xml: sitemap.content
+    };
+  }).filter((target) => {
+    if (target.name === "sitemap_index") {
+      return false;
+    }
+    if (target.name === "sitemap") {
+      return target.xml.includes("<urlset");
+    }
+    return true;
+  });
+  assert(targets.length > 0, "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 resolveNuxtSitemapPrerenderRoutes(nuxt) {
+  if (!hasNuxtSitemapModule(nuxt.options.modules)) {
+    return [];
+  }
+  const nuxtI18n = nuxt.options.i18n || {};
+  if (!hasNuxtI18nModule(nuxt.options.modules) || !Array.isArray(nuxtI18n.locales) || nuxtI18n.locales.length === 0) {
+    return [];
+  }
+  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_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"],
+  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) {
+    return [];
+  }
+  const include = sitemap.include?.length ? sitemap.include : Object.keys(collections);
+  const excluded = new Set(sitemap.exclude || []);
+  return include.filter((collection) => !excluded.has(collection) && collections[collection]?.sitemap !== false);
+};
+const numericSlugSegmentPattern = /^(\d+)\.[^*?[\]{}()]+(.*)$/;
+const toTranslatedSlugSourcePattern = (source) => {
+  return source.split("/").map((segment) => {
+    const match = segment.match(numericSlugSegmentPattern);
+    return match ? `${match[1]}.*${match[2] || ""}` : segment;
+  }).join("/");
+};
+const parseCollectionFiles = async (rootDir, collections, collectionNames, contentContext) => {
+  const contentDir = resolve$1(rootDir, "content");
+  const patterns = Array.from(new Set(
+    collectionNames.flatMap((name) => {
+      const source = collections[name]?.source;
+      if (!source) {
+        return [];
+      }
+      const sources = normalizeCollectionSources(source);
+      const excludes = normalizeCollectionExcludes(collections[name]?.exclude);
+      const localeSources = contentContext.translatedSlugs ? Array.from(new Set(sources.flatMap((pattern) => [
+        pattern,
+        toTranslatedSlugSourcePattern(pattern)
+      ]))) : sources;
+      const localePatterns = (contentContext.locales || []).flatMap((locale) => localeSources.map((pattern) => `${locale}/${pattern}`));
+      const excludePatterns = excludes.flatMap((pattern) => [
+        `!${pattern}`,
+        ...(contentContext.locales || []).map((locale) => `!${locale}/${pattern}`)
+      ]);
+      return [...sources, ...localePatterns, ...excludePatterns];
+    }).filter(Boolean)
+  ));
+  const ids = await globby(patterns, {
+    cwd: contentDir,
+    onlyFiles: true,
+    dot: false
+  });
+  const documents = [];
+  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 parsed = await transformContent(normalizedId, content, {
+      markdown: contentContext.markdown,
+      yaml: contentContext.yaml,
+      csv: contentContext.csv,
+      pathMeta: {
+        locales: contentContext.locales,
+        defaultLocale: contentContext.defaultLocale,
+        translatedSlugs: contentContext.translatedSlugs,
+        respectPathCase: contentContext.respectPathCase,
+        collections,
+        collectionResolver: (filePath) => resolveCollection(filePath, collections, contentContext.locales || [])
+      }
+    });
+    const collection = parsed._collection ? collections[parsed._collection] : void 0;
+    documents.push(...expandDataLocaleVariants(parsed, collection?.i18n));
+  }
+  return documents;
+};
+const collectPrerenderRoutes = 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 documents = await parseCollectionFiles(rootDir, collections, includeCollections, contentContext);
+  const graph = buildContentGraph(documents, {
+    locales: contentContext.locales,
+    defaultLocale: contentContext.defaultLocale
+  });
+  const routes = /* @__PURE__ */ new Set();
+  for (const collection of includeCollections) {
+    const { defaultLocale } = resolveCollectionI18n(collection, contentContext);
+    const includeDrafts = contentContext.sitemap && contentContext.sitemap !== false ? Boolean(contentContext.sitemap.includeDrafts) : false;
+    const seenCanonicalKeys = /* @__PURE__ */ new Set();
+    for (const contentId of graph.byCollection[collection] || []) {
+      const document = graph.byId[contentId];
+      if (!document || !document._canonicalKey || document._partial || document._navigation) {
+        continue;
+      }
+      if (document._draft && !includeDrafts) {
+        continue;
+      }
+      if (seenCanonicalKeys.has(document._canonicalKey)) {
+        continue;
+      }
+      seenCanonicalKeys.add(document._canonicalKey);
+      const variants = graph.byCanonical[document._canonicalKey] || {};
+      for (const [locale, variant] of Object.entries(variants)) {
+        if (!variant.path) {
+          continue;
+        }
+        const routeLocale = (contentContext.locales || []).includes(locale) ? locale : void 0;
+        routes.add(prefixPathWithLocale(variant.path, routeLocale, defaultLocale));
+      }
+    }
+  }
+  return Array.from(routes).sort();
+};
+const collectSitemapCollectionRouteCounts = async (rootDir, contentContext) => {
+  const collections = contentContext.collections || {};
+  const includedCollections = resolveSitemapCollections(collections, contentContext.sitemap);
+  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;
+  for (const collection of includedCollections) {
+    const seenCanonicalKeys = /* @__PURE__ */ new Set();
+    for (const contentId of graph.byCollection[collection] || []) {
+      const document = graph.byId[contentId];
+      if (!document || !document._canonicalKey || document._partial || document._navigation) {
+        continue;
+      }
+      if (document._draft && !includeDrafts) {
+        continue;
+      }
+      if (seenCanonicalKeys.has(document._canonicalKey)) {
+        continue;
+      }
+      const variants = Object.values(graph.byCanonical[document._canonicalKey] || {});
+      if (!variants.some((variant) => variant.path)) {
+        continue;
+      }
+      seenCanonicalKeys.add(document._canonicalKey);
+      counts[collection] += 1;
+    }
+  }
+  return counts;
+};
+const registerContentNitroIntegrationHooks = (nitroConfig, options, contentContext) => {
+  if (contentContext.provider && contentContext.provider !== "filesystem") {
+    return;
+  }
+  nitroConfig.hooks ||= {};
+  if (contentContext.sitemap?.assert?.enabled) {
+    appendHook(nitroConfig.hooks, "compiled", async (nitro) => {
+      const assertOptions = contentContext.sitemap?.assert;
+      if (!assertOptions || !shouldRunSitemapAssertionOnCompiled(assertOptions, nitro)) {
+        return;
+      }
+      try {
+        await assertGeneratedSitemaps({
+          outputPublicDir: nitro.options.output.publicDir,
+          options: assertOptions,
+          collectionRouteCounts: await collectSitemapCollectionRouteCounts(options.rootDir, contentContext),
+          logger: nitro.logger
+        });
+      } catch (error) {
+        if (error?.code === "ENOENT") {
+          return;
+        }
+        throw error;
+      }
+    });
+  }
+  appendHook(nitroConfig.hooks, "prerender:routes", async (routes) => {
+    for (const route of await collectPrerenderRoutes(options.rootDir, contentContext)) {
+      routes.add(route);
+    }
+    for (const route of options.sitemapPrerenderRoutes || []) {
+      routes.add(route);
+    }
+  });
+};
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "content",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    }
+  },
+  moduleDependencies: {
+    "@nuxt/ui": {
+      optional: true,
+      defaults: {
+        content: true,
+        prose: true
+      }
+    }
+  },
+  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
+    }
+  },
+  async setup(options, nuxt) {
+    const { resolve, resolvePath } = createResolver(import.meta.url);
+    const logger = useLogger(name);
+    const resolveRuntimeModule = (path) => resolve("./runtime", path);
+    const runtimeInlineDependencies = ["comark", "@comark/vue"];
+    validateRemovedMarkdownOptions(options);
+    nuxt.options.build.transpile ||= [];
+    for (const dependency of runtimeInlineDependencies) {
+      if (!nuxt.options.build.transpile.includes(dependency)) {
+        nuxt.options.build.transpile.push(dependency);
+      }
+    }
+    nuxt.options.vite = nuxt.options.vite || {};
+    nuxt.options.vite.ssr = defu(nuxt.options.vite.ssr || {}, {
+      noExternal: runtimeInlineDependencies
+    });
+    const contentConfigPath = resolveContentConfigPath(nuxt);
+    const appContentConfig = await loadContentConfig(nuxt);
+    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: { ... } }).");
+    }
+    const resolvedI18n = resolveModuleI18nOptions(options, nuxt);
+    const resolvedSitemap = normalizeSitemapOptions(options);
+    const resolvedSearch = normalizeSearchOptions(options);
+    options.collections = Object.fromEntries(Object.entries(appContentConfig.collections).map(([name2, collection]) => [
+      name2,
+      {
+        ...collection,
+        i18n: resolveCollectionI18nConfig(
+          collection,
+          resolvedI18n.defaultLocale && resolvedI18n.locales.length ? { defaultLocale: resolvedI18n.defaultLocale, locales: resolvedI18n.locales } : void 0,
+          { warnMissingGlobal: true }
+        )
+      }
+    ]));
+    options.provider = appContentConfig.provider || options.provider || "filesystem";
+    options.providers = {
+      ...options.providers || {},
+      ...appContentConfig.providers || {}
+    };
+    const buildIntegrity = nuxt.options.dev ? void 0 : Date.now();
+    const contentContext = {
+      ...options,
+      transformers: [],
+      locales: resolvedI18n.locales,
+      defaultLocale: resolvedI18n.defaultLocale,
+      localeFallback: resolvedI18n.fallback,
+      translatedSlugs: resolvedI18n.translatedSlugs,
+      strictTranslatedSlugs: resolvedI18n.strictTranslatedSlugs,
+      sitemap: resolvedSitemap,
+      search: resolvedSearch
+    };
+    if (resolvedSitemap && resolvedSitemap.assert.enabled) {
+      nuxt.hook("sitemap:prerender:done", async ({ sitemaps }) => {
+        const assertOptions = contentContext.sitemap?.assert;
+        if (!assertOptions || !shouldRunSitemapAssertionOnPrerenderedSitemaps(assertOptions)) {
+          return;
+        }
+        await assertGeneratedSitemaps({
+          options: assertOptions,
+          targets: createSitemapAssertionTargetsFromPrerenderedSitemaps(sitemaps),
+          collectionRouteCounts: await collectSitemapCollectionRouteCounts(nuxt.options.rootDir, contentContext),
+          logger
+        });
+      });
+    }
+    const { transformersTemplate, virtualConfigTemplate, virtualProvidersTemplate, virtualCacheAdapterTemplate } = createVirtualContentTemplates(contentContext, nuxt, contentConfigPath, addTemplate);
+    registerVirtualContentAliases(nuxt, transformersTemplate, virtualConfigTemplate, virtualProvidersTemplate, virtualCacheAdapterTemplate, resolveRuntimeModule);
+    registerContentServerHandlers(nuxt, options, resolveRuntimeModule, buildIntegrity);
+    registerContentI18nTemplate(addTemplate, hasNuxtI18nModule(nuxt.options.modules));
+    registerRuntimeImports(resolveRuntimeModule);
+    registerRuntimeComponents(resolve);
+    registerContentComponentsTemplate(addTemplate);
+    registerGeneratedTypes(contentConfigPath, resolveRuntimeModule);
+    await registerUserContentComponents(nuxt, resolve);
+    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
+      });
+    });
+    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:context", contentContext);
+      if (contentContext.search !== false) {
+        registerContentSearchServerHandlers(options.api.baseURL, contentContext.search, resolveRuntimeModule);
+      }
+      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]) => [
+        name2,
+        {
+          ...collection.source ? { source: collection.source } : {},
+          ...collection.exclude ? { exclude: collection.exclude } : {},
+          strict: collection.strict ?? true,
+          ...collection.route ? { route: collection.route } : {},
+          ...typeof collection.sitemap === "boolean" ? { sitemap: collection.sitemap } : {},
+          ...collection.i18n && collection.i18n !== true ? { i18n: collection.i18n } : {}
+        }
+      ]));
+      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);
+      registerContentDevRuntime(nuxt, options, contentContext);
+    }
+  }
+});
+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 };