@onruntime/next-sitemap 0.6.2 → 0.8.0

package/dist/pages/index.d.ts

@@ -2,6 +2,7 @@ import { MetadataRoute, NextApiRequest, NextApiResponse } from 'next';
 export { MetadataRoute } from 'next';
 
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+
 interface SitemapConfig {
     /**
      * Base URL of the site (e.g., "https://example.com")
@@ -54,6 +55,16 @@ interface SitemapConfig {
      * @example additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"]
      */
     additionalSitemaps?: string[];
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * @default false
+     */
+    debug?: boolean;
+    /**
+     * Include "Powered by @onruntime/next-sitemap" comment in generated XML
+     * @default true
+     */
+    poweredBy?: boolean;
 }
 interface SitemapEntry {
     url: string;
@@ -65,39 +76,35 @@ interface SitemapEntry {
     };
 }
 
+interface RobotsConfig extends MetadataRoute.Robots {
+    /**
+     * Include "Powered by @onruntime/next-sitemap" comment
+     * @default true
+     */
+    poweredBy?: boolean;
+}
 /**
  * Generate robots.txt content from configuration
  * Compatible with Next.js MetadataRoute.Robots
  */
-declare function generateRobotsTxt(config: MetadataRoute.Robots): string;
+declare function generateRobotsTxt(config: RobotsConfig): string;
 
 interface CreateSitemapApiHandlerOptions extends SitemapConfig {
     /**
      * Path to the pages directory to scan for page files.
      * Can be absolute or relative to process.cwd().
      * If not provided, auto-detects src/pages or pages.
-     *
-     * Example:
-     * ```ts
-     * pagesDirectory: 'src/pages'
-     * ```
      */
     pagesDirectory?: string;
-    /**
-     * Enable debug logging to diagnose issues with route discovery
-     * Logs info about getStaticPaths calls and skipped routes
-     * @default false
-     */
-    debug?: boolean;
 }
 /**
  * Create API handler for sitemap index route
- * Use in: pages/api/sitemap.xml.ts or pages/sitemap.xml.ts (with rewrites)
+ * Use in: pages/api/sitemap.xml.ts
  */
 declare function createSitemapIndexApiHandler(options: CreateSitemapApiHandlerOptions): (_req: NextApiRequest, res: NextApiResponse) => Promise<void>;
 /**
  * Create API handler for individual sitemap routes
- * Use in: pages/api/sitemap/[id].ts or pages/sitemap-[id].xml.ts (with rewrites)
+ * Use in: pages/api/sitemap/[id].ts
  */
 declare function createSitemapApiHandler(options: CreateSitemapApiHandlerOptions): (req: NextApiRequest, res: NextApiResponse) => Promise<void>;
 /**
@@ -114,21 +121,8 @@ declare function getSitemapStaticPaths(options: CreateSitemapApiHandlerOptions):
 }>;
 /**
  * Create API handler for robots.txt
- * Use in: pages/api/robots.txt.ts or pages/robots.txt.ts (with rewrites)
- *
- * @example
- * // pages/api/robots.txt.ts
- * import { createRobotsApiHandler } from "@onruntime/next-sitemap/pages";
- *
- * export default createRobotsApiHandler({
- *   rules: {
- *     userAgent: "*",
- *     allow: "/",
- *     disallow: ["/admin", "/private"],
- *   },
- *   sitemap: "https://example.com/sitemap.xml",
- * });
+ * Use in: pages/api/robots.txt.ts
  */
-declare function createRobotsApiHandler(config: MetadataRoute.Robots): (_req: NextApiRequest, res: NextApiResponse) => void;
+declare function createRobotsApiHandler(config: RobotsConfig): (_req: NextApiRequest, res: NextApiResponse) => void;
 
-export { type ChangeFrequency, type CreateSitemapApiHandlerOptions, type SitemapConfig, type SitemapEntry, createRobotsApiHandler, createSitemapApiHandler, createSitemapIndexApiHandler, generateRobotsTxt, getSitemapStaticPaths };
+export { type ChangeFrequency, type CreateSitemapApiHandlerOptions, type RobotsConfig, type SitemapConfig, type SitemapEntry, createRobotsApiHandler, createSitemapApiHandler, createSitemapIndexApiHandler, generateRobotsTxt, getSitemapStaticPaths };

package/dist/pages/index.js

@@ -1,9 +1,168 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createJiti } from 'jiti';
-import stripJsonComments from 'strip-json-comments';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, join, isAbsolute, relative, delimiter } from 'path';
+import * as childProcess from 'child_process';
+import { fileURLToPath } from 'url';
 
 // src/pages/index.ts
+var NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+var spawnProcess = childProcess.spawn;
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+var paramsCache = /* @__PURE__ */ new Map();
+var isDev = process.env.NODE_ENV === "development";
+async function executeWorker(directory, fileKey, debug) {
+  const absolutePath = join(directory, fileKey.replace("./", ""));
+  const projectRoot = process.cwd();
+  const distRoot = join(__dirname$1, "..");
+  const workerPath = join(distRoot, "worker.cjs");
+  const loaderPath = join(distRoot, "loader.js");
+  if (debug) {
+    console.log(`[next-sitemap] Worker path: ${workerPath}`);
+    console.log(`[next-sitemap] Worker exists: ${existsSync(workerPath)}`);
+    console.log(`[next-sitemap] Loader path: ${loaderPath}`);
+    console.log(`[next-sitemap] Loader exists: ${existsSync(loaderPath)}`);
+  }
+  return new Promise((resolve) => {
+    const nodePath = [
+      join(projectRoot, "node_modules"),
+      join(__dirname$1, "..", "node_modules")
+    ].join(delimiter);
+    const importFlag = ["--import", loaderPath];
+    const args = [...importFlag, workerPath, absolutePath, projectRoot];
+    const child = spawnProcess("node", args, {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NODE_PATH: nodePath }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (debug && stderr) {
+        console.warn(`[next-sitemap] Worker stderr: ${stderr}`);
+      }
+      if (code !== 0 && code !== null) {
+        if (debug) console.warn(`[next-sitemap] Worker exited with code ${code}`);
+        resolve(null);
+        return;
+      }
+      try {
+        const lines = stdout.trim().split("\n");
+        const result = JSON.parse(lines[lines.length - 1]);
+        if (result.success) {
+          resolve(result.params);
+        } else {
+          if (result.error !== NO_STATIC_PARAMS && debug) {
+            console.warn(`[next-sitemap] Worker error: ${result.error}`);
+          }
+          resolve(null);
+        }
+      } catch {
+        if (debug) console.warn(`[next-sitemap] Failed to parse worker output: ${stdout}`);
+        resolve(null);
+      }
+    });
+    child.on("error", (err) => {
+      if (debug) console.warn(`[next-sitemap] Failed to spawn worker: ${err.message}`);
+      resolve(null);
+    });
+  });
+}
+async function getRouteParams(route, directory, debug) {
+  const cacheKey = route.fileKey;
+  if (paramsCache.has(cacheKey)) {
+    return paramsCache.get(cacheKey);
+  }
+  if (debug) {
+    console.log(`[next-sitemap] ${route.pathname}: executing static params via worker`);
+  }
+  const params = await executeWorker(directory, route.fileKey, debug);
+  paramsCache.set(cacheKey, params);
+  if (debug && params) {
+    console.log(`[next-sitemap] ${route.pathname}: got ${params.length} params`);
+  }
+  return params;
+}
+async function generateAllPaths(routes, directory, debug) {
+  const staticPaths = ["/"];
+  const dynamicRoutes = [];
+  for (const route of routes) {
+    if (route.dynamicSegments.length === 0) {
+      if (route.pathname !== "/") {
+        staticPaths.push(route.pathname);
+      }
+    } else {
+      dynamicRoutes.push(route);
+    }
+  }
+  const startTime = isDev ? Date.now() : 0;
+  if (isDev && dynamicRoutes.length > 0) {
+    console.log(`[next-sitemap] Generating sitemap for ${dynamicRoutes.length} dynamic routes (dev only, instant in production)...`);
+  }
+  const dynamicResults = await Promise.all(
+    dynamicRoutes.map(async (route) => {
+      const params = await getRouteParams(route, directory, debug);
+      if (!params || params.length === 0) {
+        if (debug) {
+          console.warn(`[next-sitemap] Skipping dynamic route ${route.pathname}: no static params or empty result.`);
+        }
+        return [];
+      }
+      const paths = [];
+      for (const param of params) {
+        let path = route.pathname;
+        let valid = true;
+        for (const segment of route.dynamicSegments) {
+          const value = param[segment];
+          if (value === void 0) {
+            if (debug) {
+              console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+            }
+            valid = false;
+            break;
+          }
+          path = path.replace(`[${segment}]`, value);
+        }
+        if (valid) paths.push(path);
+      }
+      return paths;
+    })
+  );
+  const allPaths = new Set(staticPaths);
+  for (const paths of dynamicResults) {
+    for (const path of paths) {
+      allPaths.add(path);
+    }
+  }
+  if (isDev && dynamicRoutes.length > 0) {
+    const elapsed = Date.now() - startTime;
+    console.log(`[next-sitemap] Done! Found ${allPaths.size} total URLs in ${elapsed}ms.`);
+  }
+  return Array.from(allPaths);
+}
+function pathsToEntries(paths, config) {
+  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
+  return paths.filter((pathname) => !shouldExclude(pathname, exclude)).map((pathname) => {
+    const entry = {
+      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
+      lastModified: /* @__PURE__ */ new Date(),
+      changeFrequency: getChangeFreq(pathname, changeFreq),
+      priority: getPriority(pathname, priority)
+    };
+    if (locales.length > 0) {
+      entry.alternates = {
+        languages: Object.fromEntries(
+          locales.map((locale) => [locale, buildUrl(baseUrl, pathname, locale, defaultLocale)])
+        )
+      };
+    }
+    return entry;
+  });
+}
 
 // src/index.ts
 function calculateDepthPriority(pathname) {
@@ -52,7 +211,8 @@ function buildUrl(baseUrl, pathname, locale, defaultLocale) {
   }
   return `${baseUrl}/${locale}${normalizedPath}`;
 }
-function generateSitemapXml(entries) {
+function generateSitemapXml(entries, options) {
+  const { poweredBy = true } = options || {};
   const hasAlternates = entries.some((e) => e.alternates?.languages);
   const xmlns = hasAlternates ? 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"' : 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
   const urlEntries = entries.map((entry) => {
@@ -76,13 +236,14 @@ function generateSitemapXml(entries) {
 ${parts.join("\n")}
   </url>`;
   }).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
+  const comment = poweredBy ? "\n<!-- Powered by @onruntime/next-sitemap -->" : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>${comment}
 <urlset ${xmlns}>
 ${urlEntries}
 </urlset>`;
 }
 function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
-  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [] } = options || {};
+  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [], poweredBy = true } = options || {};
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paginatedEntries = Array.from({ length: sitemapCount }, (_, i) => {
     const loc = `${baseUrl}${sitemapPattern.replace("{id}", String(i))}`;
@@ -99,7 +260,8 @@ function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
   </sitemap>`;
   });
   const allEntries = [...paginatedEntries, ...additionalEntries].join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
+  const comment = poweredBy ? "\n<!-- Powered by @onruntime/next-sitemap -->" : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>${comment}
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${allEntries}
 </sitemapindex>`;
@@ -107,7 +269,12 @@ ${allEntries}
 
 // src/pages/robots.ts
 function generateRobotsTxt(config) {
+  const { poweredBy = true } = config;
   const lines = [];
+  if (poweredBy) {
+    lines.push("# Powered by @onruntime/next-sitemap");
+    lines.push("");
+  }
   const rules = Array.isArray(config.rules) ? config.rules : [config.rules];
   for (const rule of rules) {
     const userAgents = Array.isArray(rule.userAgent) ? rule.userAgent : [rule.userAgent];
@@ -144,18 +311,17 @@ function generateRobotsTxt(config) {
 }
 
 // src/pages/index.ts
-var joinPath = (...segments) => path.join(...segments);
 function findPageFiles(dir, baseDir = dir) {
   const files = [];
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "api") continue;
         files.push(...findPageFiles(fullPath, baseDir));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.startsWith("_")) {
-        const relativePath = "./" + path.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = "./" + relative(baseDir, fullPath).replace(/\\/g, "/");
         files.push(relativePath);
       }
     }
@@ -163,67 +329,12 @@ function findPageFiles(dir, baseDir = dir) {
   }
   return files;
 }
-function detectPagesDirectory() {
-  const srcPages = path.join(process.cwd(), "src/pages");
-  if (fs.existsSync(srcPages)) {
-    return srcPages;
-  }
-  return path.join(process.cwd(), "pages");
-}
-function resolvePagesDirectory(options) {
-  if (options.pagesDirectory) {
-    return path.isAbsolute(options.pagesDirectory) ? options.pagesDirectory : path.join(process.cwd(), options.pagesDirectory);
+function resolvePagesDirectory(pagesDirectory) {
+  if (pagesDirectory) {
+    return isAbsolute(pagesDirectory) ? pagesDirectory : join(process.cwd(), pagesDirectory);
   }
-  return detectPagesDirectory();
-}
-function getPageKeys(options) {
-  return findPageFiles(resolvePagesDirectory(options));
-}
-var jitiCache = /* @__PURE__ */ new Map();
-function getTsconfigPaths(projectRoot) {
-  const alias = {};
-  try {
-    const tsconfigPath = path.join(projectRoot, "tsconfig.json");
-    if (fs.existsSync(tsconfigPath)) {
-      const content = fs.readFileSync(tsconfigPath, "utf-8");
-      const withoutComments = stripJsonComments(content);
-      const cleaned = withoutComments.replace(/,(\s*[}\]])/g, "$1");
-      const tsconfig = JSON.parse(cleaned);
-      const baseUrl = tsconfig.compilerOptions?.baseUrl || ".";
-      const paths = tsconfig.compilerOptions?.paths || {};
-      for (const [key, values] of Object.entries(paths)) {
-        if (values.length > 0) {
-          const aliasKey = key.replace(/\*$/, "");
-          const aliasValue = joinPath(projectRoot, baseUrl, values[0].replace(/\*$/, ""));
-          alias[aliasKey] = aliasValue;
-        }
-      }
-    }
-  } catch {
-  }
-  return alias;
-}
-function getJiti(projectRoot) {
-  if (jitiCache.has(projectRoot)) {
-    return jitiCache.get(projectRoot);
-  }
-  const alias = getTsconfigPaths(projectRoot);
-  const jiti = createJiti(import.meta.url, {
-    moduleCache: false,
-    interopDefault: true,
-    jsx: true,
-    alias
-  });
-  jitiCache.set(projectRoot, jiti);
-  return jiti;
-}
-async function importPage(pagesDirectory, key) {
-  const relativePath = key.replace("./", "");
-  const absolutePath = path.join(pagesDirectory, relativePath);
-  const projectRoot = process.cwd();
-  const jiti = getJiti(projectRoot);
-  const module = await jiti.import(absolutePath);
-  return module.default || module;
+  const srcPages = join(process.cwd(), "src/pages");
+  return existsSync(srcPages) ? srcPages : join(process.cwd(), "pages");
 }
 function extractRoutes(pageKeys, localeSegment) {
   const routes = [];
@@ -232,10 +343,8 @@ function extractRoutes(pageKeys, localeSegment) {
     let pathname = key.replace(/^\.\//, "/").replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "/");
     if (pathname === "") pathname = "/";
     if (localeSegment) {
-      pathname = pathname.replace(
-        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
-        ""
-      );
+      const escapedSegment = localeSegment.replace(/[[\]]/g, "\\$&");
+      pathname = pathname.replace(new RegExp(`^/${escapedSegment}`), "");
     }
     if (/(?:^|\/)(src|pages)(?:\/|$)/.test(pathname)) continue;
     if (!pathname || pathname === "") {
@@ -243,160 +352,57 @@ function extractRoutes(pageKeys, localeSegment) {
     } else if (!pathname.startsWith("/")) {
       pathname = "/" + pathname;
     }
-    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
-    routes.push({
-      pathname,
-      dynamicSegments,
-      key
-    });
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) ?? [];
+    routes.push({ pathname, dynamicSegments, fileKey: key });
   }
   return routes;
 }
-async function getAllPaths(routes, pagesDirectory, debug = false) {
-  const allPaths = ["/"];
-  const seenPaths = /* @__PURE__ */ new Set(["/"]);
-  for (const route of routes) {
-    if (route.dynamicSegments.length === 0) {
-      if (route.pathname !== "/" && !seenPaths.has(route.pathname)) {
-        allPaths.push(route.pathname);
-        seenPaths.add(route.pathname);
-      }
-    } else {
-      let getParams = null;
-      try {
-        if (debug) {
-          console.log(`[next-sitemap] ${route.pathname}: importing ${route.key}`);
-        }
-        const module = await importPage(pagesDirectory, route.key);
-        const getStaticPaths = module.getStaticPaths;
-        if (getStaticPaths) {
-          getParams = async () => {
-            const result = await getStaticPaths();
-            return result.paths.map((p) => p.params);
-          };
-        } else if (module.generateStaticParams) {
-          getParams = module.generateStaticParams;
-        }
-      } catch (error) {
-        if (debug) {
-          console.warn(`[next-sitemap] ${route.pathname}: import failed:`, error);
-        }
-      }
-      if (getParams) {
-        try {
-          const params = await getParams();
-          if (debug) {
-            console.log(`[next-sitemap] ${route.pathname}: getStaticPaths returned ${params.length} params`);
-          }
-          for (const param of params) {
-            let dynamicPath = route.pathname;
-            for (const segment of route.dynamicSegments) {
-              const value = param[segment];
-              if (value === void 0) {
-                if (debug) {
-                  console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
-                }
-                continue;
-              }
-              dynamicPath = dynamicPath.replace(`[${segment}]`, value);
-            }
-            if (!seenPaths.has(dynamicPath)) {
-              allPaths.push(dynamicPath);
-              seenPaths.add(dynamicPath);
-            }
-          }
-        } catch (error) {
-          console.error(`[next-sitemap] Error calling getStaticPaths for ${route.pathname}:`, error);
-        }
-      } else {
-        if (debug) {
-          console.warn(
-            `[next-sitemap] Skipping dynamic route ${route.pathname}: no getStaticPaths exported. Use additionalSitemaps for routes that fetch data at runtime.`
-          );
-        }
-      }
-    }
-  }
-  return allPaths;
-}
-function pathsToEntries(paths, config) {
-  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
-  const filteredPaths = paths.filter((pathname) => !shouldExclude(pathname, exclude));
-  return filteredPaths.map((pathname) => {
-    const entry = {
-      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
-      lastModified: /* @__PURE__ */ new Date(),
-      changeFrequency: getChangeFreq(pathname, changeFreq),
-      priority: getPriority(pathname, priority)
-    };
-    if (locales.length > 0) {
-      entry.alternates = {
-        languages: Object.fromEntries(
-          locales.map((locale) => [
-            locale,
-            buildUrl(baseUrl, pathname, locale, defaultLocale)
-          ])
-        )
-      };
-    }
-    return entry;
-  });
-}
 function createSitemapIndexApiHandler(options) {
   const { urlsPerSitemap = 5e3, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
-  if (debug) {
-    console.log(`[next-sitemap] Found ${routes.length} routes:`);
-    routes.forEach((r) => {
-      const isDynamic = r.dynamicSegments.length > 0;
-      const segments = isDynamic ? ` [${r.dynamicSegments.join(", ")}]` : "";
-      console.log(`  ${r.pathname}${segments}${isDynamic ? " (dynamic)" : ""}`);
-    });
-  }
   return async function handler(_req, res) {
-    const allPaths = await getAllPaths(routes, pagesDir, debug);
-    const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    if (debug) {
+      console.log(`[next-sitemap] Found ${routes.length} routes`);
+    }
+    const allPaths = await generateAllPaths(routes, pagesDir, debug);
+    const filteredPaths = allPaths.filter((p) => !shouldExclude(p, exclude));
     const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
-    const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
-      additionalSitemaps
-    });
     res.setHeader("Content-Type", "application/xml");
-    res.status(200).send(xml);
+    res.status(200).send(
+      generateSitemapIndexXml(options.baseUrl, sitemapCount, { additionalSitemaps, poweredBy: options.poweredBy })
+    );
   };
 }
 function createSitemapApiHandler(options) {
   const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes, pagesDir, debug);
-    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const allPaths = await generateAllPaths(routes, pagesDir, debug);
+    return allPaths.filter((p) => !shouldExclude(p, exclude));
   };
   return async function handler(req, res) {
     const { id } = req.query;
     const sitemapId = parseInt(Array.isArray(id) ? id[0] : id || "0", 10);
     const filteredPaths = await getFilteredPaths();
-    const start = sitemapId * urlsPerSitemap;
-    const end = start + urlsPerSitemap;
-    const paths = filteredPaths.slice(start, end);
+    const paths = filteredPaths.slice(sitemapId * urlsPerSitemap, (sitemapId + 1) * urlsPerSitemap);
     const entries = pathsToEntries(paths, { ...options, exclude: void 0 });
-    const xml = generateSitemapXml(entries);
     res.setHeader("Content-Type", "application/xml");
-    res.status(200).send(xml);
+    res.status(200).send(generateSitemapXml(entries, { poweredBy: options.poweredBy }));
   };
 }
 async function getSitemapStaticPaths(options) {
   const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
-  const allPaths = await getAllPaths(routes, pagesDir, debug);
+  const allPaths = await generateAllPaths(routes, pagesDir, debug);
   const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
   const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
   return {
@@ -408,9 +414,8 @@ async function getSitemapStaticPaths(options) {
 }
 function createRobotsApiHandler(config) {
   return function handler(_req, res) {
-    const robotsTxt = generateRobotsTxt(config);
     res.setHeader("Content-Type", "text/plain");
-    res.status(200).send(robotsTxt);
+    res.status(200).send(generateRobotsTxt(config));
   };
 }