@nuxtjs/sitemap 8.3.4 → 8.5.0

package/dist/devtools/nuxt.config.ts

@@ -1,7 +1,10 @@
+import { fileURLToPath } from 'node:url'
 import { resolve } from 'pathe'
 
+const currentDir = fileURLToPath(new URL('.', import.meta.url))
+
 // Nuxt SEO devtools panel, shipped as a layer (Model C). Components flat-registered
 // so intra-panel references resolve by name.
 export default defineNuxtConfig({
-  components: [{ path: resolve(__dirname, './components'), pathPrefix: false }],
+  components: [{ path: resolve(currentDir, './components'), pathPrefix: false }],
 })

package/dist/module.json

@@ -4,7 +4,7 @@
     "nuxt": ">=3.9.0"
   },
   "configKey": "sitemap",
-  "version": "8.3.4",
+  "version": "8.5.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -2,15 +2,18 @@ import { useNuxt, hasNuxtModule, addTypeTemplate, addTemplate, defineNuxtModule,
 import { defu } from 'defu';
 import { withSiteUrl, installNuxtSiteConfig } from 'nuxt-site-config/kit';
 import { isPathFile } from 'nuxt-site-config/urls';
-import { isNuxtGenerate, renderNitroTypeAugmentations, useModuleLogger, setupNitroRuntimeCompatibility, getNuxtModuleOptions, resolveNitroPreset, resolveNuxtContentVersion, createPagesPromise, createNitroPromise } from 'nuxtseo-shared/kit';
+import { isNuxtGenerate, renderNitroTypeAugmentations, useModuleLogger, setupNitroRuntimeCompatibility, getNuxtModuleOptions, resolveNitroPreset, resolveContentProvider, setupContentRuntime, createPagesPromise, createNitroPromise } from 'nuxtseo-shared/kit';
 import { serializeFilters } from 'nuxtseo-shared/utils';
 import { dirname, extname } from 'pathe';
 import { readPackageJSON } from 'pkg-types';
 import { withBase, withHttps, withTrailingSlash, withoutLeadingSlash, joinURL, withLeadingSlash } from 'ufo';
 import { setupDevToolsUI as setupDevToolsUI$1 } from 'nuxtseo-shared/devtools';
+import { once } from 'node:events';
 import { readFileSync, statSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { rm, mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { Worker, MessageChannel } from 'node:worker_threads';
 import { colors } from 'consola/utils';
 import { splitForLocales, createPathFilter } from '../dist/runtime/utils-pure.js';
 import { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.BoMnWHOt.mjs';
@@ -18,6 +21,9 @@ import { normaliseDate } from '../dist/runtime/server/sitemap/urlset/normalise.j
 import { mapPathForI18nPages, splitPathForI18nLocales as splitPathForI18nLocales$1, expandCompactLocaleRoute, normalizeLocales, generatePathForI18nPages } from 'nuxtseo-shared/i18n';
 import 'ultrahtml';
 
+const COMARK_CONTENT_SOURCE = "@harlan-zw/comark-content:urls";
+const COMARK_CONTENT_SITEMAP_ROUTE = "/__sitemap__/comark-content-urls.json";
+
 function setupDevToolsUI(_options, resolve, nuxt = useNuxt()) {
   setupDevToolsUI$1(
     { route: "/__nuxt-sitemap", name: "sitemap", title: "Sitemap", icon: "carbon:load-balancer-application" },
@@ -72,6 +78,14 @@ export async function readSourcesFromFilesystem(filename) {
 `;
   });
   nuxt.hooks.hook("nitro:init", async (nitro) => {
+    let prerendererNitro = nitro;
+    nitro.hooks.hook("prerender:init", (prerenderer) => {
+      prerendererNitro = prerenderer;
+    });
+    await Promise.all([
+      rm(join(runtimeAssetsPath, "global-sources.json"), { force: true }),
+      rm(join(runtimeAssetsPath, "child-sources.json"), { force: true })
+    ]);
     nitro.hooks.hook("prerender:generate", async (route) => {
       const html = route.contents;
       if (!route.fileName?.endsWith(".html") || !html || ["/200.html", "/404.html"].includes(route.route))
@@ -121,12 +135,101 @@ export async function readSourcesFromFilesystem(filename) {
       await writeFile(join(runtimeAssetsPath, "global-sources.json"), JSON.stringify(globalSources));
       await writeFile(join(runtimeAssetsPath, "child-sources.json"), JSON.stringify(childSources));
       const sitemapEntry = options.isMultiSitemap ? "/sitemap_index.xml" : `/${Object.keys(options.sitemaps)[0]}`;
-      const sitemaps = await prerenderSitemapsFromEntry(nitro, sitemapEntry);
-      await nuxt.hooks.callHook("sitemap:prerender:done", { options, sitemaps });
+      const prerenderServer = await loadPrerenderServer(prerendererNitro);
+      await prerenderSitemapsFromEntry(nitro, prerenderServer.fetch, sitemapEntry).then((sitemaps) => nuxt.hooks.callHook("sitemap:prerender:done", { options, sitemaps })).finally(prerenderServer.close);
     });
   });
 }
-async function prerenderSitemapsFromEntry(nitro, entry) {
+const PrerenderWorkerCode = `
+const { parentPort, workerData } = require('node:worker_threads')
+
+;(async () => {
+  const serverEntry = await import(workerData.entry)
+  const server = serverEntry.default
+  const localFetch = serverEntry.localFetch
+  const fetch = typeof server?.fetch === 'function'
+    ? (input, headers) => server.fetch(new Request(new URL(input, 'http://localhost'), { headers }))
+    : typeof localFetch === 'function'
+      // older nitropack exposes an ofetch instance: a bare call returns parsed data, .raw returns the response
+      ? (input, headers) => (localFetch.raw ?? localFetch)(input, { headers })
+      : undefined
+  const close = typeof server?.close === 'function'
+    ? () => server.close()
+    : typeof serverEntry.closePrerenderer === 'function'
+      ? () => serverEntry.closePrerenderer()
+      : async () => {}
+
+  parentPort.postMessage(fetch ? { _tag: 'Ready' } : { _tag: 'Err', message: 'Nitro prerender server does not expose a fetch handler' })
+  parentPort.on('message', ({ _tag, input, headers, port }) => {
+    const task = _tag === 'Fetch'
+      ? fetch(input, headers).then(async response => ({
+          _tag: 'Ok',
+          status: response.status,
+          statusText: response.statusText,
+          headers: [...response.headers],
+          body: await response.arrayBuffer(),
+        }))
+      : close().then(() => ({ _tag: 'Ok' }))
+    task.catch(error => ({ _tag: 'Err', message: error instanceof Error ? error.message : String(error) }))
+      .then(result => port.postMessage(result, result.body ? [result.body] : []))
+  })
+})().catch(error => parentPort.postMessage({ _tag: 'Err', message: error instanceof Error ? error.message : String(error) }))
+`;
+function raceWithTimeout(promises, ms, message) {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), ms);
+  });
+  return Promise.race([...promises, timeout]).finally(() => clearTimeout(timer));
+}
+async function loadPrerenderServer(nitro) {
+  const entryFileNames = nitro.options.rollupConfig?.output?.entryFileNames;
+  const serverFilename = typeof entryFileNames === "string" ? entryFileNames : "index.mjs";
+  const worker = new Worker(PrerenderWorkerCode, {
+    eval: true,
+    workerData: { entry: pathToFileURL(resolve(nitro.options.output.serverDir, serverFilename)).href }
+  });
+  const workerDead = new Promise((_, reject) => {
+    worker.once("exit", (code) => reject(new Error(`The Nitro prerender server worker exited unexpectedly (code ${code})`)));
+    worker.once("error", (error) => reject(error));
+  });
+  workerDead.catch(() => {
+  });
+  try {
+    const [ready] = await raceWithTimeout([once(worker, "message"), workerDead], 6e4, "The Nitro prerender server did not become ready in time");
+    if (ready._tag === "Err")
+      throw new Error(ready.message);
+  } catch (error) {
+    await worker.terminate();
+    throw error;
+  }
+  const callWorker = async (message) => {
+    const { port1, port2 } = new MessageChannel();
+    worker.postMessage({ ...message, port: port2 }, [port2]);
+    try {
+      const [result] = await Promise.race([once(port1, "message"), workerDead]);
+      if (result._tag === "Err")
+        throw new Error(result.message);
+      return result;
+    } finally {
+      port1.close();
+    }
+  };
+  return {
+    async fetch(input, headers) {
+      const { _tag, body, ...responseInit } = await callWorker({ _tag: "Fetch", input, headers });
+      return new Response(body, responseInit);
+    },
+    async close() {
+      try {
+        await raceWithTimeout([callWorker({ _tag: "Close" })], 3e3, "The Nitro prerender server did not close in time");
+      } catch {
+      }
+      await worker.terminate();
+    }
+  };
+}
+async function prerenderSitemapsFromEntry(nitro, fetch, entry) {
   const sitemaps = [];
   const queue = [entry];
   const processed = /* @__PURE__ */ new Set();
@@ -135,7 +238,7 @@ async function prerenderSitemapsFromEntry(nitro, entry) {
     if (processed.has(route))
       continue;
     processed.add(route);
-    const { filePath, prerenderUrls } = await prerenderRoute(nitro, route);
+    const { filePath, prerenderUrls } = await prerenderRoute(nitro, fetch, route);
     sitemaps.push({
       name: route,
       get content() {
@@ -146,27 +249,19 @@ async function prerenderSitemapsFromEntry(nitro, entry) {
   }
   return sitemaps;
 }
-async function prerenderRoute(nitro, route) {
+async function prerenderRoute(nitro, fetch, route) {
   const start = Date.now();
   const _route = { route, fileName: route };
   const encodedRoute = encodeURI(route);
   const fetchUrl = withBase(encodedRoute, nitro.options.baseURL);
-  const res = await globalThis.$fetch.raw(
-    fetchUrl,
-    {
-      headers: { "x-nitro-prerender": encodedRoute },
-      retry: nitro.options.prerender.retry,
-      retryDelay: nitro.options.prerender.retryDelay
-    }
-  );
+  const res = await fetch(fetchUrl, { "x-nitro-prerender": encodedRoute });
+  if (!res.ok)
+    throw new Error(`Failed to prerender '${fetchUrl}': ${res.status} ${res.statusText}`);
   const header = res.headers.get("x-nitro-prerender") || "";
   const prerenderUrls = header.split(",").map((i) => decodeURIComponent(i.trim())).filter(Boolean);
   const filePath = join(nitro.options.output.publicDir, _route.fileName);
   await mkdir(dirname(filePath), { recursive: true });
-  const data = res._data;
-  if (data === void 0)
-    throw new Error(`No data returned from '${fetchUrl}'`);
-  const content = filePath.endsWith("json") || typeof data === "object" ? JSON.stringify(data) : data;
+  const content = await res.text();
   await writeFile(filePath, content, "utf8");
   _route.generateTimeMS = Date.now() - start;
   nitro._prerenderedRoutes.push(_route);
@@ -185,7 +280,8 @@ function registerTypeTemplates(nitroCompatibility) {
 'sitemap:input': (ctx: SitemapInputCtx<${nitroCompatibility.eventType}>) => void | Promise<void>
 'sitemap:resolved': (ctx: SitemapRenderCtx<${nitroCompatibility.eventType}>) => void | Promise<void>
 'sitemap:output': (ctx: SitemapOutputHookCtx<${nitroCompatibility.eventType}>) => void | Promise<void>
-'sitemap:sources': (ctx: SitemapSourcesHookCtx<${nitroCompatibility.eventType}>) => void | Promise<void>`;
+'sitemap:sources': (ctx: SitemapSourcesHookCtx<${nitroCompatibility.eventType}>) => void | Promise<void>
+'sitemap:sitemaps-resolved': (ctx: SitemapsResolvedCtx<${nitroCompatibility.eventType}>) => void | Promise<void>`;
       const nitroTypes = renderNitroTypeAugmentations(nitroCompatibility, {
         nitroInterfaces: {
           PrerenderRoute: "_sitemap?: SitemapUrl"
@@ -196,7 +292,7 @@ function registerTypeTemplates(nitroCompatibility) {
       });
       return `// Generated by @nuxtjs/sitemap
 /// <reference path="./nuxt-sitemap-virtual.d.ts" />
-import type { SitemapUrl, SitemapItemDefaults, SitemapIndexRenderCtx, SitemapInputCtx, SitemapRenderCtx, SitemapOutputHookCtx, SitemapSourcesHookCtx } from '@nuxtjs/sitemap'
+import type { SitemapUrl, SitemapItemDefaults, SitemapIndexRenderCtx, SitemapInputCtx, SitemapRenderCtx, SitemapOutputHookCtx, SitemapSourcesHookCtx, SitemapsResolvedCtx } from '@nuxtjs/sitemap'
 
 ${nitroTypes}
 
@@ -455,7 +551,34 @@ function generateExtraRoutesFromNuxtConfig(nuxt = useNuxt()) {
   }).map(([k]) => k).filter(filterForValidPage);
   return { routeRules };
 }
+function resolveExcludedAppSources(resolved, authored) {
+  if (resolved === true || authored === true)
+    return true;
+  if (!Array.isArray(authored))
+    return resolved;
+  const excluded = [...resolved];
+  for (const source of authored) {
+    if (typeof source === "string" && !excluded.includes(source))
+      excluded.push(source);
+  }
+  return excluded;
+}
 
+const IMAGE_TAGS = /* @__PURE__ */ new Set(["image", "img", "nuxtimg", "nuxt-img"]);
+function discoverContentImages(body) {
+  const images = [];
+  const walk = (nodes) => {
+    for (const node of nodes || []) {
+      if (!Array.isArray(node) || typeof node[0] !== "string")
+        continue;
+      if (IMAGE_TAGS.has(node[0]) && node[1]?.src)
+        images.push({ loc: node[1].src });
+      walk(node.slice(2));
+    }
+  };
+  walk(body?.value ?? body?.nodes);
+  return images;
+}
 const module$1 = defineNuxtModule({
   meta: {
     name: "@nuxtjs/sitemap",
@@ -480,6 +603,10 @@ const module$1 = defineNuxtModule({
       version: ">=2",
       optional: true
     },
+    "@harlan-zw/comark-content": {
+      version: ">=0.1.2",
+      optional: true
+    },
     "@nuxtjs/robots": {
       version: ">=4",
       optional: true
@@ -673,11 +800,11 @@ const module$1 = defineNuxtModule({
         const hasCustomI18nSitemaps = i18nSitemaps.length > 0;
         if (hasCustomI18nSitemaps) {
           for (const { name: name2, cfg } of i18nSitemaps) {
+            const { sitemapName: _sitemapName, _route, _isChunking, _chunkSize, _chunkCount, ...inheritedConfig } = cfg;
             for (const locale of resolvedAutoI18n.locales) {
               newSitemaps[`${locale._sitemap}-${name2}`] = {
-                includeAppSources: true,
-                ...cfg.exclude?.length && { exclude: cfg.exclude },
-                ...cfg.include?.length && { include: cfg.include }
+                ...inheritedConfig,
+                includeAppSources: true
               };
             }
           }
@@ -770,20 +897,13 @@ const module$1 = defineNuxtModule({
         addServerPlugin(resolve("./runtime/server/plugins/stream-transport"));
     }
     const isNuxtContentDocumentDriven = !!nuxt.options.content?.documentDriven || config.strictNuxtContentPaths;
-    const contentVersion = await resolveNuxtContentVersion();
-    const isNuxtContentV3 = contentVersion && contentVersion.version === 3;
+    const contentProvider = await resolveContentProvider(nuxt);
+    const isNuxtContentV3 = contentProvider._tag === "NuxtContent" && contentProvider.version === 3;
+    const isNuxtContentV2 = contentProvider._tag === "NuxtContent" && contentProvider.version === 2;
+    const isComarkContent = contentProvider._tag === "Comark";
     const nuxtV3Collections = /* @__PURE__ */ new Set();
-    const isNuxtContentV2 = contentVersion && contentVersion.version === 2;
-    if (isNuxtContentV3) {
-      if (nuxt.options._installedModules.some((m) => m.meta.name === "Content")) {
-        logger.warn("You have loaded `@nuxt/content` before `@nuxtjs/sitemap`, this may cause issues with the integration. Please ensure `@nuxtjs/sitemap` is loaded first.");
-      }
-      config.exclude.push("/__nuxt_content/**");
-      const needsCustomAlias = await hasNuxtModuleCompatibility("@nuxt/content", "<3.6.0");
-      if (needsCustomAlias) {
-        nuxt.options.alias["#sitemap/content-v3-nitro-path"] = resolve(dirname(resolveModule("@nuxt/content")), "runtime/nitro");
-        nuxt.options.alias["@nuxt/content/nitro"] = resolve("./runtime/server/content-compat");
-      }
+    setupContentRuntime(contentProvider, nuxt);
+    const registerContentSitemapHook = (options) => {
       nuxt.hooks.hook("content:file:afterParse", (ctx) => {
         try {
           const content = ctx.content;
@@ -792,7 +912,7 @@ const module$1 = defineNuxtModule({
             ctx.content.sitemap = null;
             return;
           }
-          if (!ctx.collection.fields || !("sitemap" in ctx.collection.fields)) {
+          if (options.requireCollectionField && (!ctx.collection.fields || !("sitemap" in ctx.collection.fields))) {
             ctx.content.sitemap = null;
             return;
           }
@@ -805,13 +925,8 @@ const module$1 = defineNuxtModule({
             return;
           }
           const images = [];
-          if (config.discoverImages) {
-            images.push(
-              ...content.body?.value?.filter(
-                (c) => ["image", "img", "nuxtimg", "nuxt-img"].includes(c[0])
-              ).filter((c) => c[1]?.src).map((c) => ({ loc: c[1].src })) || []
-            );
-          }
+          if (config.discoverImages)
+            images.push(...discoverContentImages(content.body));
           const lastmod = content.seo?.articleModifiedTime || content.updatedAt;
           const defaults = {
             loc: content.path
@@ -825,6 +940,8 @@ const module$1 = defineNuxtModule({
           logger.warn(`Failed to process sitemap data for content file (collection: ${ctx.collection?.name}, path: ${ctx.content?.path}), skipping.`, e);
         }
       });
+    };
+    const addContentCallbackVirtuals = () => {
       nuxt.hook("nitro:config", (nitroConfig) => {
         const filterEntries = [];
         if (globalThis.__sitemapCollectionFilters) {
@@ -842,9 +959,22 @@ ${filterEntries.join("\n")}`;
         nitroConfig.virtual["#sitemap/content-on-url"] = `export const onUrlFns = new Map()
 ${onUrlEntries.join("\n")}`;
       });
+    };
+    if (isNuxtContentV3) {
+      if (nuxt.options._installedModules.some((m) => m.meta.name === "Content")) {
+        logger.warn("You have loaded `@nuxt/content` before `@nuxtjs/sitemap`, this may cause issues with the integration. Please ensure `@nuxtjs/sitemap` is loaded first.");
+      }
+      config.exclude.push("/__nuxt_content/**");
+      const needsCustomAlias = await hasNuxtModuleCompatibility("@nuxt/content", "<3.6.0");
+      if (needsCustomAlias) {
+        nuxt.options.alias["#sitemap/content-v3-nitro-path"] = resolve(dirname(resolveModule("@nuxt/content")), "runtime/nitro");
+        nuxt.options.alias["@nuxt/content/nitro"] = resolve("./runtime/server/content-compat");
+      }
+      registerContentSitemapHook({ requireCollectionField: true });
+      addContentCallbackVirtuals();
       addServerHandler({
         route: "/__sitemap__/nuxt-content-urls.json",
-        handler: resolve("./runtime/server/routes/__sitemap__/nuxt-content-urls-v3")
+        handler: resolve("./runtime/server/routes/__sitemap__/content-urls")
       });
       if (config.strictNuxtContentPaths) {
         logger.warn("You have set `strictNuxtContentPaths: true` but are using @nuxt/content v3. This is not required, please remove it.");
@@ -857,6 +987,24 @@ ${onUrlEntries.join("\n")}`;
         },
         fetch: "/__sitemap__/nuxt-content-urls.json"
       });
+    } else if (isComarkContent) {
+      registerContentSitemapHook({ requireCollectionField: false });
+      addContentCallbackVirtuals();
+      addServerHandler({
+        route: COMARK_CONTENT_SITEMAP_ROUTE,
+        handler: resolve("./runtime/server/routes/__sitemap__/content-urls")
+      });
+      if (config.strictNuxtContentPaths) {
+        logger.warn("You have set `strictNuxtContentPaths: true` but are using comark-content. This is not required, please remove it.");
+      }
+      appGlobalSources.push({
+        context: {
+          name: COMARK_CONTENT_SOURCE,
+          description: "Generated from your markdown files.",
+          tips: nuxtV3Collections.size ? [`Parsing the following collections: ${Array.from(nuxtV3Collections).join(", ")}`] : ["No collections found. Set `sitemap: false` on a collection to keep it out."]
+        },
+        fetch: COMARK_CONTENT_SITEMAP_ROUTE
+      });
     } else if (isNuxtContentV2) {
       addServerPlugin(resolve("./runtime/server/plugins/nuxt-content-v2"));
       addServerHandler({
@@ -1097,6 +1245,10 @@ ${onUrlEntries.join("\n")}`;
       return r.contentType?.includes("text/html");
     };
     const generateGlobalSources = async () => {
+      const excludedAppSources = resolveExcludedAppSources(
+        config.excludeAppSources,
+        nuxt.options.sitemap?.excludeAppSources
+      );
       const { routeRules: routeRules2 } = generateExtraRoutesFromNuxtConfig();
       const nitro = await nitroPromise;
       const prerenderedRoutes2 = nitro._prerenderedRoutes || [];
@@ -1173,7 +1325,7 @@ ${onUrlEntries.join("\n")}`;
           s.sourceType = "user";
           return s;
         }),
-        ...(config.excludeAppSources === true ? [] : [
+        ...(excludedAppSources === true ? [] : [
           ...appGlobalSources,
           {
             context: {
@@ -1205,7 +1357,7 @@ ${onUrlEntries.join("\n")}`;
             },
             urls: prerenderUrlsFinal
           }
-        ]).filter((s) => !config.excludeAppSources.includes(s.context.name) && (!!s.urls?.length || !!s.fetch)).map((s) => {
+        ]).filter((s) => !excludedAppSources.includes(s.context.name) && (!!s.urls?.length || !!s.fetch)).map((s) => {
           s.sourceType = "app";
           return s;
         })

package/dist/runtime/server/routes/__sitemap__/content-urls.d.ts

@@ -0,0 +1,9 @@
+/**
+ * URLs from the installed content module's page collections.
+ *
+ * One route for every provider. `#nuxtseo/content` normalizes the manifest shape
+ * and the query builder; the `sitemap` field on each entry is written by the
+ * module's `content:file:afterParse` hook.
+ */
+declare const _default: any;
+export default _default;

package/dist/runtime/server/routes/__sitemap__/content-urls.js

@@ -0,0 +1,34 @@
+import * as contentRuntime from "#nuxtseo/content";
+import { defineEventHandler } from "#nuxtseo/h3";
+import { filters } from "#sitemap/content-filters";
+import { onUrlFns } from "#sitemap/content-on-url";
+const { listPageCollections, provider, queryPages } = contentRuntime;
+export default defineEventHandler(async (e) => {
+  const collections = (await listPageCollections(e)).filter((collection) => collection.inSitemap && collection.hasField("sitemap")).map((collection) => collection.name);
+  const results = await Promise.all(collections.map(async (collection) => {
+    const needsAllFields = filters?.has(collection) || onUrlFns?.has(collection);
+    const query = queryPages(e, collection).where("path", "IS NOT NULL").where("sitemap", "IS NOT NULL");
+    if (!needsAllFields)
+      query.select("path", "sitemap");
+    try {
+      const entries = await query.all();
+      const filter = filters?.get(collection);
+      return { collection, entries: filter ? entries.filter(filter) : entries };
+    } catch (err) {
+      const hint = provider === "nuxt-content-v3" ? " On serverless the content DB is restored from a prerendered sql_dump.txt that isn't readable inside the function (nuxt/content#3805). Fix: prerender the sitemap so content URLs resolve at build, or configure a runtime database (D1/Turso/Postgres)." : "";
+      console.error(`[@nuxtjs/sitemap] Couldn't query content collection "${collection}" for the sitemap, so its URLs will be missing.${hint}`, err);
+      return { collection, entries: [] };
+    }
+  }));
+  return results.flatMap(({ collection, entries }) => {
+    const onUrl = onUrlFns?.get(collection);
+    return entries.filter((entry) => entry.sitemap !== false && entry.path && !entry.path.endsWith(".navigation")).map((entry) => {
+      const url = {
+        loc: entry.path,
+        ...typeof entry.sitemap === "object" && entry.sitemap ? entry.sitemap : {}
+      };
+      onUrl?.(url, entry, collection);
+      return url;
+    });
+  });
+});

package/dist/runtime/server/routes/__sitemap__/debug.js

@@ -6,7 +6,7 @@ import {
   globalSitemapSources,
   resolveSitemapSources
 } from "../../sitemap/urlset/sources.js";
-import { useSitemapRuntimeConfig } from "../../utils.js";
+import { useResolvedSitemapRuntimeConfig } from "../../utils.js";
 function attachUrlWarnings(sources) {
   for (const source of sources) {
     if (!source.urls?.length)
@@ -26,7 +26,7 @@ function attachUrlWarnings(sources) {
   return sources;
 }
 export default defineEventHandler(async (e) => {
-  const _runtimeConfig = useSitemapRuntimeConfig();
+  const _runtimeConfig = await useResolvedSitemapRuntimeConfig(e);
   const siteConfig = getSiteConfig(e);
   const { sitemaps: _sitemaps } = _runtimeConfig;
   const runtimeConfig = { ..._runtimeConfig };

package/dist/runtime/server/sitemap/builder/sitemap-index.js

@@ -3,6 +3,7 @@ import { getHeader } from "#nuxtseo/h3";
 import { defineCachedFunction } from "#nuxtseo/nitro";
 import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { normaliseDate } from "../urlset/normalise.js";
+import { parseChunkInfo } from "../utils/chunk.js";
 import { getResolvedSitemapUrls } from "./sitemap.js";
 const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
 const buildSitemapIndexCached = defineCachedFunction(
@@ -43,7 +44,9 @@ async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
       sitemapConfig._isChunking = true;
       sitemapConfig._chunkSize = sitemapConfig.chunkSize || (typeof sitemapConfig.chunks === "number" ? sitemapConfig.chunks : defaultSitemapsChunkSize || 1e3);
     } else {
-      nonChunkedNames.push(sitemapName);
+      const chunkInfo = parseChunkInfo(sitemapName, sitemaps, defaultSitemapsChunkSize || void 0);
+      if (!chunkInfo.isChunked)
+        nonChunkedNames.push(sitemapName);
     }
   }
   const indexLastmod = autoLastmod ? normaliseDate(/* @__PURE__ */ new Date()) : void 0;

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

@@ -50,7 +50,7 @@ export async function buildResolvedSitemapUrls(effectiveSitemap, matchName, isCh
       if (typeof e._sitemap === "string" && !hasMatchingSitemap) {
         if (!warnedSitemaps.has(e._sitemap)) {
           warnedSitemaps.add(e._sitemap);
-          logger.error(`Sitemap \`${e._sitemap}\` not found in sitemap config. Available sitemaps: ${sitemapNames.join(", ")}. Entry \`${e.loc}\` will be omitted.`);
+          logger.error(`Sitemap \`${e._sitemap}\` not found in sitemap config. Available sitemaps: ${sitemapNames.join(", ")}. Either add it to the sitemap config or register it with the sitemap:sitemaps-resolved hook. Entry \`${e.loc}\` will be omitted.`);
         }
       }
     }
@@ -88,7 +88,13 @@ export const buildResolvedSitemapUrlsCached = defineCachedFunction(
       const proto = getHeader(event, "x-forwarded-proto") || "https";
       return `resolved-${isChunked ? "chunked-" : ""}${matchName}-${proto}-${host}`;
     },
-    swr: true
+    swr: true,
+    // A build with failed sources is never cached: one outage must not pin an empty sitemap
+    // for a whole cache window. The next request retries the sources instead.
+    validate: (entry) => {
+      const value = entry.value;
+      return value !== void 0 && !value.failedSources?.length;
+    }
   }
 );
 export async function getResolvedSitemapUrls(effectiveSitemap, matchName, isChunked, resolvers, runtimeConfig, nitro) {

package/dist/runtime/server/sitemap/event-handlers.js

@@ -1,20 +1,20 @@
 import { joinURL, withBase, withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
 import { appendHeader, createError, getRequestURL, getRouterParam, sendRedirect } from "#nuxtseo/h3";
 import { useNitroApp, useRuntimeConfig } from "#nuxtseo/nitro";
-import { useSitemapRuntimeConfig } from "../utils.js";
+import { useResolvedSitemapRuntimeConfig } from "../utils.js";
 import { urlsToIndexXml, urlsToIndexXmlStream } from "./builder/index-xml.js";
 import { buildSitemapIndex } from "./builder/sitemap-index.js";
 import { createSitemap, renderSitemapOutput, setSitemapResponseHeaders, useNitroUrlResolvers } from "./nitro.js";
 import { getSitemapConfig, parseChunkInfo } from "./utils/chunk.js";
 export async function sitemapXmlEventHandler(e) {
-  const runtimeConfig = useSitemapRuntimeConfig();
+  const runtimeConfig = await useResolvedSitemapRuntimeConfig(e);
   const { sitemaps } = runtimeConfig;
   if ("index" in sitemaps)
     return sendRedirect(e, withBase("/sitemap_index.xml", useRuntimeConfig().app.baseURL), import.meta.dev ? 302 : 301);
   return createSitemap(e, Object.values(sitemaps)[0], runtimeConfig);
 }
 export async function sitemapIndexXmlEventHandler(e) {
-  const runtimeConfig = useSitemapRuntimeConfig();
+  const runtimeConfig = await useResolvedSitemapRuntimeConfig(e);
   const nitro = useNitroApp();
   const resolvers = useNitroUrlResolvers(e);
   const { entries: sitemaps, failedSources } = await buildSitemapIndex(resolvers, runtimeConfig, nitro);
@@ -44,7 +44,7 @@ export async function sitemapChildXmlEventHandler(e) {
   const pathname = getRequestURL(e).pathname;
   if (!pathname.endsWith(".xml"))
     return;
-  const runtimeConfig = useSitemapRuntimeConfig(e);
+  const runtimeConfig = await useResolvedSitemapRuntimeConfig(e);
   const { sitemaps } = runtimeConfig;
   let sitemapName = getRouterParam(e, "sitemap");
   if (!sitemapName) {
@@ -66,7 +66,7 @@ export async function sitemapChildXmlEventHandler(e) {
   sitemapName = withoutLeadingSlash(withoutTrailingSlash(sitemapName));
   const chunkInfo = parseChunkInfo(sitemapName, sitemaps, runtimeConfig.defaultSitemapsChunkSize);
   const isAutoChunked = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
-  const sitemapExists = sitemapName in sitemaps || chunkInfo.baseSitemapName in sitemaps || isAutoChunked;
+  const sitemapExists = Object.hasOwn(sitemaps, sitemapName) || Object.hasOwn(sitemaps, chunkInfo.baseSitemapName) || isAutoChunked;
   if (!sitemapExists)
     throw createError({ statusCode: 404, message: `Sitemap "${sitemapName}" not found.` });
   if (chunkInfo.isChunked && chunkInfo.chunkIndex !== void 0) {

package/dist/runtime/server/sitemap/urlset/sources.js

@@ -2,8 +2,9 @@ import { defu } from "defu";
 import { $fetch } from "ofetch";
 import { collectSitemap } from "sitemapd/parse";
 import { parseURL } from "ufo";
-import { getRequestHost } from "#nuxtseo/h3";
-import { fetchWithEvent } from "#nuxtseo/nitro";
+import { getHeader, getRequestHost } from "#nuxtseo/h3";
+import { defineCachedFunction, fetchWithEvent } from "#nuxtseo/nitro";
+import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { logger } from "../../../utils-pure.js";
 const changeFrequencies = /* @__PURE__ */ new Set([
   "always",
@@ -69,10 +70,78 @@ async function tryFetchWithFallback(url, options, event) {
   }
   return event ? await fetchWithEvent(event, url, options) : await globalThis.$fetch(url, options);
 }
+const SOURCE_FETCH_MEMO_KEY = "_sitemapSourceFetches";
+const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
+const prerenderSourceFetches = import.meta.prerender ? /* @__PURE__ */ new Map() : void 0;
+function useSourceFetchMemo(event) {
+  if (import.meta.prerender)
+    return prerenderSourceFetches;
+  const context = event?.context;
+  if (!context)
+    return void 0;
+  const existing = context[SOURCE_FETCH_MEMO_KEY];
+  if (existing)
+    return existing;
+  const memo = /* @__PURE__ */ new Map();
+  context[SOURCE_FETCH_MEMO_KEY] = memo;
+  return memo;
+}
+function hashCacheKey(key) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < key.length; i++) {
+    const ch = key.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(36);
+}
+const fetchSourceUrlsCached = defineCachedFunction(
+  (event, _key, url, options) => fetchSourceUrls(url, options, event),
+  {
+    name: "sitemap:source-urls",
+    group: "sitemap",
+    base: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    getKey: (event, key) => {
+      const host = getHeader(event, "host") || getHeader(event, "x-forwarded-host") || "";
+      const proto = getHeader(event, "x-forwarded-proto") || "https";
+      return `source-${proto}-${host}-${hashCacheKey(key)}`;
+    },
+    swr: true,
+    // A failed fetch must never be served again, otherwise one outage empties the sitemap for a
+    // whole cache window.
+    validate: (entry) => {
+      const value = entry.value;
+      return value !== void 0 && !value._isFailure;
+    }
+  }
+);
+function isSourceCacheEnabled() {
+  if (import.meta.dev || import.meta.prerender)
+    return false;
+  const cacheMaxAgeSeconds = staticConfig.cacheMaxAgeSeconds;
+  return typeof cacheMaxAgeSeconds === "number" && cacheMaxAgeSeconds > 0;
+}
 export async function fetchDataSource(input, event) {
   const context = typeof input.context === "string" ? { name: input.context } : input.context || { name: "fetch" };
   const url = typeof input.fetch === "string" ? input.fetch : input.fetch[0];
   const options = typeof input.fetch === "string" ? {} : input.fetch[1];
+  const memo = useSourceFetchMemo(event);
+  const key = `${url}::${JSON.stringify(options || {})}`;
+  let request = memo?.get(key);
+  if (!request) {
+    request = event && isSourceCacheEnabled() ? fetchSourceUrlsCached(event, key, url, options) : fetchSourceUrls(url, options, event);
+    memo?.set(key, request);
+  }
+  const result = await request;
+  if (result._isFailure)
+    memo?.delete(key);
+  return { ...input, context, ...result };
+}
+async function fetchSourceUrls(url, options, event) {
   const start = Date.now();
   const isExternalUrl = !url.startsWith("/");
   const timeout = isExternalUrl ? 1e4 : options.timeout || 5e3;
@@ -113,11 +182,12 @@ export async function fetchDataSource(input, event) {
     const timeTakenMs = Date.now() - start;
     if (isMaybeErrorResponse) {
       return {
-        ...input,
-        context,
         urls: [],
         timeTakenMs,
-        error: "Received HTML response instead of JSON"
+        error: "Received HTML response instead of JSON",
+        // An HTML page is usually an outage or an auth wall, both transient. Treat it like a
+        // failed fetch so the empty result is never cached.
+        _isFailure: true
       };
     }
     let urls = [];
@@ -133,8 +203,6 @@ export async function fetchDataSource(input, event) {
       urls = res.urls || res;
     }
     return {
-      ...input,
-      context,
       timeTakenMs,
       urls
     };
@@ -154,8 +222,6 @@ export async function fetchDataSource(input, event) {
       logger.error("Failed to fetch source.", { url, error: error.message });
     }
     return {
-      ...input,
-      context,
       urls: [],
       error: error.message,
       _isFailure: true
@@ -179,6 +245,15 @@ export async function globalSitemapSources() {
   return [...m.sources];
 }
 export async function childSitemapSources(definition) {
+  if (definition?.sources?.length)
+    return [...definition.sources];
+  if (definition?.urls) {
+    const urls = typeof definition.urls === "function" ? await definition.urls() : definition.urls;
+    return [{
+      context: { name: `sitemaps:${definition.sitemapName}:urls`, description: "Set with the sitemap definition `urls`." },
+      urls
+    }];
+  }
   if (!definition?._hasSourceChunk)
     return [];
   if (import.meta.prerender) {

package/dist/runtime/server/utils.d.ts

@@ -2,3 +2,4 @@ import type { H3Event } from '#nuxtseo/h3';
 import type { ModuleRuntimeConfig } from '../types.js';
 export * from '../utils-pure.js';
 export declare function useSitemapRuntimeConfig(e?: H3Event): ModuleRuntimeConfig;
+export declare function useResolvedSitemapRuntimeConfig(e: H3Event): Promise<ModuleRuntimeConfig>;

package/dist/runtime/server/utils.js

@@ -1,18 +1,74 @@
-import { useRuntimeConfig } from "#nuxtseo/nitro";
+import { getHeader } from "#nuxtseo/h3";
+import { defineCachedFunction, useNitroApp, useRuntimeConfig } from "#nuxtseo/nitro";
 import staticConfig from "#sitemap-virtual/static-config.mjs";
 import { normalizeRuntimeFilters } from "../utils-pure.js";
 export * from "../utils-pure.js";
-export function useSitemapRuntimeConfig(e) {
-  const sitemaps = Object.fromEntries(
+const SERVER_CACHE_MAX_AGE = staticConfig.cacheMaxAgeSeconds || 60 * 10;
+function dynamicRuntimeConfig(e) {
+  return useRuntimeConfig(e).sitemap;
+}
+function copyStaticSitemaps() {
+  return Object.fromEntries(
     Object.entries(staticConfig.sitemaps).map(([name, sitemap]) => [name, {
       ...sitemap,
       include: normalizeRuntimeFilters("include" in sitemap ? sitemap.include : void 0),
       exclude: normalizeRuntimeFilters("exclude" in sitemap ? sitemap.exclude : void 0)
     }])
   );
+}
+export function useSitemapRuntimeConfig(e) {
+  return Object.freeze({
+    ...staticConfig,
+    sitemaps: copyStaticSitemaps(),
+    ...dynamicRuntimeConfig(e)
+  });
+}
+function serializeFilters(filters) {
+  if (!filters?.length)
+    return void 0;
+  return filters.map((f) => {
+    if (f instanceof RegExp)
+      return { regex: `/${f.source}/${f.flags}` };
+    return f;
+  });
+}
+async function resolveSitemapSitemaps(e, nitro) {
+  const ctx = { sitemaps: copyStaticSitemaps(), event: e };
+  await nitro.hooks.callHook("sitemap:sitemaps-resolved", ctx);
+  const sitemaps = { ...ctx.sitemaps };
+  for (const name of Object.keys(sitemaps)) {
+    const sitemap = { ...sitemaps[name] };
+    if (typeof sitemap.urls === "function")
+      sitemap.urls = await sitemap.urls();
+    sitemap.include = serializeFilters(sitemap.include);
+    sitemap.exclude = serializeFilters(sitemap.exclude);
+    sitemaps[name] = sitemap;
+  }
+  return sitemaps;
+}
+const resolveSitemapSitemapsCached = defineCachedFunction(
+  resolveSitemapSitemaps,
+  {
+    name: "sitemap:runtime-sitemaps",
+    group: "sitemap",
+    maxAge: SERVER_CACHE_MAX_AGE,
+    base: "sitemap",
+    // nitro calls getKey with the full fn args (event, nitro)
+    getKey: (e) => {
+      const host = e && (getHeader(e, "host") || getHeader(e, "x-forwarded-host")) || "";
+      const proto = e && getHeader(e, "x-forwarded-proto") || "https";
+      return `runtime-sitemaps-${proto}-${host}`;
+    },
+    swr: true
+  }
+);
+export async function useResolvedSitemapRuntimeConfig(e) {
+  const maxAge = dynamicRuntimeConfig(e)?.cacheMaxAgeSeconds ?? staticConfig.cacheMaxAgeSeconds;
+  const shouldCache = !import.meta.dev && !import.meta.prerender && typeof maxAge === "number" && maxAge > 0;
+  const sitemaps = shouldCache ? await resolveSitemapSitemapsCached(e, useNitroApp()) : await resolveSitemapSitemaps(e, useNitroApp());
   return Object.freeze({
     ...staticConfig,
     sitemaps,
-    ...useRuntimeConfig(e).sitemap
+    ...dynamicRuntimeConfig(e)
   });
 }

package/dist/runtime/types.d.ts

@@ -204,7 +204,7 @@ export interface SitemapSourceResolved extends Omit<SitemapSourceBase, 'urls'> {
         message: string;
     }[];
 }
-export type AppSourceContext = 'nuxt:pages' | 'nuxt:prerender' | 'nuxt:route-rules' | '@nuxtjs/i18n:pages' | 'nuxt-i18n-micro:pages' | '@nuxt/content@v2:urls' | '@nuxt/content@v3:urls';
+export type AppSourceContext = 'nuxt:pages' | 'nuxt:prerender' | 'nuxt:route-rules' | '@nuxtjs/i18n:pages' | 'nuxt-i18n-micro:pages' | '@nuxt/content@v2:urls' | '@nuxt/content@v3:urls' | '@harlan-zw/comark-content:urls';
 export type SitemapSourceInput = string | [string, FetchOptions] | SitemapSourceBase | SitemapSourceResolved;
 interface LocaleObject extends Record<string, any> {
     code: string;
@@ -245,7 +245,7 @@ export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPr
         index?: Pick<SitemapDefinition, 'sitemapName' | '_route'> & {
             sitemaps: SitemapIndexEntry[];
         };
-    } & Record<string, Omit<SitemapDefinition, 'urls'> & {
+    } & Record<string, SitemapDefinition & {
         _hasSourceChunk?: boolean;
     }>;
     autoI18n?: AutoI18nConfig;
@@ -398,6 +398,20 @@ export interface SitemapSourcesHookCtx<Event = H3Event> extends NitroBaseHook<Ev
     sitemapName: string;
     sources: SitemapSourceInput[];
 }
+export interface SitemapsResolvedCtx<Event = H3Event> extends NitroBaseHook<Event> {
+    /**
+     * The sitemaps config about to be used to build the sitemap index and serve child
+     * sitemaps. Static definitions from nuxt.config are already present.
+     *
+     * Push definitions here to register sitemaps at runtime, for example when the data set
+     * grows while the server is running. Delete a key to remove its sitemap from the index
+     * and stop serving it. Registered sitemaps accept the same fields as nuxt.config
+     * definitions (`sources`, `urls`, `include`, `exclude`, `defaults`, `chunks`) and are
+     * served, listed in the sitemap index, and passed the `sitemap:sources` hook like
+     * static ones.
+     */
+    sitemaps: ModuleRuntimeConfig['sitemaps'];
+}
 export type Changefreq = 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never';
 export interface SitemapUrl {
     loc: string;
@@ -413,6 +427,10 @@ export interface SitemapUrl {
     images?: Array<ImageEntry>;
     videos?: Array<VideoEntry>;
     _i18nTransform?: boolean;
+    /**
+     * Route this URL to a specific sitemap. The name must exist in the sitemap config,
+     * either set in `nuxt.config` or registered with the `sitemap:sitemaps-resolved` hook.
+     */
     _sitemap?: string | false;
     /**
      * Mark the URL as already encoded.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nuxtjs/sitemap",
   "type": "module",
-  "version": "8.3.4",
+  "version": "8.5.0",
   "description": "Powerfully flexible XML Sitemaps that integrate seamlessly, for Nuxt.",
   "author": {
     "name": "Harlan Wilton",
@@ -58,42 +58,43 @@
     "@nuxt/kit": "^4.5.2",
     "consola": "^3.4.2",
     "defu": "^6.1.7",
-    "nuxt-site-config": "^4.2.0",
-    "nuxtseo-shared": "^5.3.11",
+    "nuxt-site-config": "^4.2.3",
+    "nuxtseo-shared": "^5.3.14",
     "ofetch": "^1.5.1",
     "pathe": "^2.0.3",
     "pkg-types": "^2.3.1",
     "radix3": "^1.1.2",
     "ufo": "^1.6.4",
     "ultrahtml": "^1.7.0",
-    "sitemapd": "^0.2.1"
+    "sitemapd": "^0.2.2"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^9.3.0",
     "@arethetypeswrong/cli": "^0.18.5",
+    "@harlan-zw/comark-content": "^0.1.3",
     "@nuxt/content": "^3.15.2",
-    "@nuxt/devtools-kit": "4.0.0-alpha.9",
+    "@nuxt/devtools-kit": "4.0.0-alpha.12",
     "@nuxt/module-builder": "^1.0.3",
     "@nuxt/test-utils": "^4.1.0",
     "@nuxt/ui": "^4.10.0",
     "@nuxtjs/i18n": "^10.6.0",
-    "@nuxtjs/robots": "^6.1.4",
+    "@nuxtjs/robots": "^6.1.5",
     "@vue/test-utils": "^2.4.11",
     "better-sqlite3": "^13.0.3",
-    "bumpp": "^12.2.0",
+    "bumpp": "^12.2.1",
     "eslint": "^10.8.1",
-    "eslint-plugin-harlanzw": "^0.17.1",
-    "happy-dom": "^20.11.2",
+    "eslint-plugin-harlanzw": "^0.20.0",
+    "happy-dom": "^20.11.6",
     "nuxt": "^4.5.2",
     "nuxt-i18n-micro": "^3.28.0",
-    "nuxtseo-layer-devtools": "^5.3.11",
+    "nuxtseo-layer-devtools": "^5.3.14",
     "std-env": "^4.2.0",
     "typescript": "6.0.3",
     "unbuild": "^3.6.1",
-    "vitest": "^4.1.10",
-    "vue-tsc": "^3.3.9",
+    "vitest": "^4.1.11",
+    "vue-tsc": "^3.3.10",
     "zod": "^4.4.3",
-    "@nuxtjs/sitemap": "8.3.4"
+    "@nuxtjs/sitemap": "8.5.0"
   },
   "scripts": {
     "lint": "eslint .",

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v3.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/server/routes/__sitemap__/nuxt-content-urls-v3.js

@@ -1,40 +0,0 @@
-import { queryCollection } from "@nuxt/content/server";
-import manifest from "#content/manifest";
-import { defineEventHandler } from "#nuxtseo/h3";
-import { filters } from "#sitemap/content-filters";
-import { onUrlFns } from "#sitemap/content-on-url";
-export default defineEventHandler(async (e) => {
-  const collections = [];
-  for (const collection in manifest) {
-    if (manifest[collection].fields.sitemap)
-      collections.push(collection);
-  }
-  const contentList = [];
-  for (const collection of collections) {
-    const needsAllFields = filters?.has(collection) || onUrlFns?.has(collection);
-    const query = queryCollection(e, collection).where("path", "IS NOT NULL").where("sitemap", "IS NOT NULL");
-    if (!needsAllFields)
-      query.select("path", "sitemap");
-    contentList.push(
-      query.all().then((results2) => {
-        const filter = filters?.get(collection);
-        return { collection, entries: filter ? results2.filter(filter) : results2 };
-      }).catch((err) => {
-        console.error(`[@nuxtjs/sitemap] Couldn't query @nuxt/content collection "${collection}" for the sitemap, so its URLs will be missing. On serverless the content DB is restored from a prerendered sql_dump.txt that isn't readable inside the function (nuxt/content#3805). Fix: prerender the sitemap so content URLs resolve at build, or configure a runtime database (D1/Turso/Postgres).`, err);
-        return { collection, entries: [] };
-      })
-    );
-  }
-  const results = await Promise.all(contentList);
-  return results.flatMap(({ collection, entries }) => {
-    const onUrl = onUrlFns?.get(collection);
-    return entries.filter((c) => c.sitemap !== false && c.path && !c.path.endsWith(".navigation")).map((c) => {
-      const url = {
-        loc: c.path,
-        ...typeof c.sitemap === "object" ? c.sitemap : {}
-      };
-      onUrl?.(url, c, collection);
-      return url;
-    });
-  }).filter(Boolean);
-});