@onruntime/next-sitemap 0.6.2 → 0.8.0

package/README.md

@@ -9,6 +9,14 @@ Dynamic sitemap generation for Next.js with automatic route discovery.
 - [Next.js Pages Router](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/pages)
 - [Next.js Pages Router with i18n](https://github.com/onRuntime/onruntime/tree/master/examples/next-sitemap/pages-with-locales)
 
+## Used by
+
+- [onruntime.com](https://onruntime.com/sitemap.xml) - Creative development studio
+- [trendstack.news](https://trendstack.news/sitemap.xml) - News site
+- [tonightpass.com](https://tonightpass.com/sitemap.xml) - Nightlife platform
+
+Want to be listed here? Open a PR! Just make sure `poweredBy` is enabled (default).
+
 ## Features
 
 - **App Router** and **Pages Router** support
@@ -185,6 +193,7 @@ export default createSitemapIndexApiHandler({
 | `changeFreq` | `ChangeFrequency` or `function` | `"weekly"` | Change frequency for entries |
 | `additionalSitemaps` | `string[]` | `[]` | Additional sitemaps to include in index |
 | `debug` | `boolean` | `false` | Enable debug logging to diagnose route discovery issues |
+| `poweredBy` | `boolean` | `true` | Include "Powered by @onruntime/next-sitemap" comment in XML |
 
 #### Exclude Routes
 
@@ -303,6 +312,7 @@ export async function GET() {
 **Sitemap Index** (`/sitemap.xml`):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- Powered by @onruntime/next-sitemap -->
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <sitemap>
     <loc>https://example.com/sitemap-0.xml</loc>
@@ -314,6 +324,7 @@ export async function GET() {
 **Individual Sitemap** (`/sitemap-0.xml`):
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
+<!-- Powered by @onruntime/next-sitemap -->
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
     <loc>https://example.com/</loc>
@@ -345,6 +356,7 @@ export default createRobotsApiHandler({
     disallow: ["/admin", "/private"],
   },
   sitemap: "https://example.com/sitemap.xml",
+  // poweredBy: false, // Disable "Powered by" comment
 });
 ```
 

package/dist/app/index.cjs

@@ -2,12 +2,10 @@
 
 var fs = require('fs');
 var path = require('path');
-var jiti = require('jiti');
-var stripJsonComments = require('strip-json-comments');
+var childProcess = require('child_process');
+var url = require('url');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -26,11 +24,168 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
-var path__namespace = /*#__PURE__*/_interopNamespace(path);
-var stripJsonComments__default = /*#__PURE__*/_interopDefault(stripJsonComments);
+var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
 
 // src/app/index.ts
+var NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+var spawnProcess = childProcess__namespace.spawn;
+var __dirname$1 = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+var paramsCache = /* @__PURE__ */ new Map();
+var isDev = process.env.NODE_ENV === "development";
+async function executeWorker(directory, fileKey, debug) {
+  const absolutePath = path.join(directory, fileKey.replace("./", ""));
+  const projectRoot = process.cwd();
+  const distRoot = path.join(__dirname$1, "..");
+  const workerPath = path.join(distRoot, "worker.cjs");
+  const loaderPath = path.join(distRoot, "loader.js");
+  if (debug) {
+    console.log(`[next-sitemap] Worker path: ${workerPath}`);
+    console.log(`[next-sitemap] Worker exists: ${fs.existsSync(workerPath)}`);
+    console.log(`[next-sitemap] Loader path: ${loaderPath}`);
+    console.log(`[next-sitemap] Loader exists: ${fs.existsSync(loaderPath)}`);
+  }
+  return new Promise((resolve) => {
+    const nodePath = [
+      path.join(projectRoot, "node_modules"),
+      path.join(__dirname$1, "..", "node_modules")
+    ].join(path.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) {
@@ -79,7 +234,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) => {
@@ -103,13 +259,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))}`;
@@ -126,24 +283,24 @@ 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>`;
 }
 
 // src/app/index.ts
-var joinPath = (...segments) => path__namespace.join(...segments);
 function findPageFiles(dir, baseDir = dir) {
   const files = [];
   try {
-    const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path__namespace.join(dir, entry.name);
+      const fullPath = path.join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...findPageFiles(fullPath, baseDir));
       } else if (/^page\.(tsx?|jsx?)$/.test(entry.name)) {
-        const relativePath = "./" + path__namespace.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = "./" + path.relative(baseDir, fullPath).replace(/\\/g, "/");
         files.push(relativePath);
       }
     }
@@ -151,83 +308,12 @@ function findPageFiles(dir, baseDir = dir) {
   }
   return files;
 }
-function detectAppDirectory() {
-  const srcApp = path__namespace.join(process.cwd(), "src/app");
-  if (fs__namespace.existsSync(srcApp)) {
-    return srcApp;
-  }
-  return path__namespace.join(process.cwd(), "app");
-}
-function resolveAppDirectory(options) {
-  if (options.appDirectory) {
-    return path__namespace.isAbsolute(options.appDirectory) ? options.appDirectory : path__namespace.join(process.cwd(), options.appDirectory);
+function resolveAppDirectory(appDirectory) {
+  if (appDirectory) {
+    return path.isAbsolute(appDirectory) ? appDirectory : path.join(process.cwd(), appDirectory);
   }
-  return detectAppDirectory();
-}
-function getPageKeys(options) {
-  return findPageFiles(resolveAppDirectory(options));
-}
-var jitiCache = /* @__PURE__ */ new Map();
-function getTsconfigPaths(projectRoot, debug = false) {
-  const alias = {};
-  try {
-    const tsconfigPath = path__namespace.join(projectRoot, "tsconfig.json");
-    if (debug) {
-      console.log("[next-sitemap] Looking for tsconfig at:", tsconfigPath);
-      console.log("[next-sitemap] tsconfig exists:", fs__namespace.existsSync(tsconfigPath));
-    }
-    if (fs__namespace.existsSync(tsconfigPath)) {
-      const content = fs__namespace.readFileSync(tsconfigPath, "utf-8");
-      const withoutComments = stripJsonComments__default.default(content);
-      const cleaned = withoutComments.replace(/,(\s*[}\]])/g, "$1");
-      if (debug) {
-        console.log("[next-sitemap] Cleaned tsconfig (first 500 chars):", cleaned.slice(0, 500));
-      }
-      const tsconfig = JSON.parse(cleaned);
-      if (debug) {
-        console.log("[next-sitemap] Parsed tsconfig paths:", tsconfig.compilerOptions?.paths);
-      }
-      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 (error) {
-    if (debug) {
-      console.error("[next-sitemap] Error parsing tsconfig:", error);
-    }
-  }
-  return alias;
-}
-function getJiti(projectRoot, debug = false) {
-  if (jitiCache.has(projectRoot)) {
-    return jitiCache.get(projectRoot);
-  }
-  const alias = getTsconfigPaths(projectRoot, debug);
-  if (debug) {
-    console.log("[next-sitemap] Final alias config:", JSON.stringify(alias));
-  }
-  const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)), {
-    moduleCache: false,
-    interopDefault: true,
-    jsx: true,
-    alias
-  });
-  jitiCache.set(projectRoot, jiti$1);
-  return jiti$1;
-}
-async function importPage(appDirectory, key, debug = false) {
-  const relativePath = key.replace("./", "");
-  const absolutePath = path__namespace.join(appDirectory, relativePath);
-  const projectRoot = process.cwd();
-  const jiti = getJiti(projectRoot, debug);
-  const module = await jiti.import(absolutePath);
-  return module.default || module;
+  const srcApp = path.join(process.cwd(), "src/app");
+  return fs.existsSync(srcApp) ? srcApp : path.join(process.cwd(), "app");
 }
 function extractRoutes(pageKeys, localeSegment) {
   const routes = [];
@@ -235,163 +321,64 @@ function extractRoutes(pageKeys, localeSegment) {
     if (key.includes("[...")) continue;
     let pathname = key.replace("./", "/").replace(/\/page\.(tsx?|jsx?)$/, "");
     if (localeSegment) {
-      pathname = pathname.replace(
-        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
-        ""
-      );
+      const escapedSegment = localeSegment.replace(/[[\]]/g, "\\$&");
+      pathname = pathname.replace(new RegExp(`^/${escapedSegment}`), "");
     }
     pathname = pathname.replace(/\/\([^)]+\)/g, "");
     if (/(?:^|\/)(src|app)(?:\/|$)/.test(pathname)) continue;
-    if (!pathname || pathname === "") {
-      pathname = "/";
-    } else if (!pathname.startsWith("/")) {
+    pathname = pathname || "/";
+    if (pathname !== "/" && !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, appDirectory, 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(appDirectory, route.key, debug);
-        getParams = module.generateStaticParams || null;
-      } 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}: generateStaticParams 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 generateStaticParams for ${route.pathname}:`, error);
-        }
-      } else {
-        if (debug) {
-          console.warn(
-            `[next-sitemap] Skipping dynamic route ${route.pathname}: no generateStaticParams 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 createSitemapIndexHandler(options) {
   const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
-  const appDir = resolveAppDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const appDir = resolveAppDirectory(options.appDirectory);
+  const pageKeys = findPageFiles(appDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   return {
     GET: async () => {
       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)" : ""}`);
-        });
+        console.log(`[next-sitemap] Found ${routes.length} routes`);
       }
-      const allPaths = await getAllPaths(routes, appDir, debug);
-      const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+      const allPaths = await generateAllPaths(routes, appDir, 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
-      });
-      return new Response(xml, {
-        headers: { "Content-Type": "application/xml" }
-      });
+      return new Response(
+        generateSitemapIndexXml(options.baseUrl, sitemapCount, { additionalSitemaps, poweredBy: options.poweredBy }),
+        { headers: { "Content-Type": "application/xml" } }
+      );
     }
   };
 }
 function createSitemapHandler(options) {
   const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
-  const appDir = resolveAppDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const appDir = resolveAppDirectory(options.appDirectory);
+  const pageKeys = findPageFiles(appDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes, appDir, debug);
-    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const allPaths = await generateAllPaths(routes, appDir, debug);
+    return allPaths.filter((p) => !shouldExclude(p, exclude));
   };
   return {
     generateStaticParams: async () => {
       const filteredPaths = await getFilteredPaths();
-      const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
-      return Array.from({ length: sitemapCount }, (_, i) => ({ id: String(i) }));
+      const count = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+      return Array.from({ length: count }, (_, i) => ({ id: String(i) }));
     },
     GET: async (_request, { params }) => {
       const { id } = await params;
       const sitemapId = parseInt(id, 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);
-      return new Response(xml, {
+      return new Response(generateSitemapXml(entries, { poweredBy: options.poweredBy }), {
         headers: { "Content-Type": "application/xml" }
       });
     }

package/dist/app/index.d.cts

@@ -1,4 +1,5 @@
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+
 interface SitemapConfig {
     /**
      * Base URL of the site (e.g., "https://example.com")
@@ -51,6 +52,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;
@@ -67,19 +78,8 @@ interface CreateSitemapHandlerOptions extends SitemapConfig {
      * Path to the app directory to scan for page.tsx files.
      * Can be absolute or relative to process.cwd().
      * If not provided, auto-detects src/app or app.
-     *
-     * Example:
-     * ```ts
-     * appDirectory: 'src/app/(frontend)'
-     * ```
      */
     appDirectory?: string;
-    /**
-     * Enable debug logging to diagnose issues with route discovery
-     * Logs info about generateStaticParams calls and skipped routes
-     * @default false
-     */
-    debug?: boolean;
 }
 /**
  * Create handlers for sitemap index route

package/dist/app/index.d.ts

@@ -1,4 +1,5 @@
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+
 interface SitemapConfig {
     /**
      * Base URL of the site (e.g., "https://example.com")
@@ -51,6 +52,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;
@@ -67,19 +78,8 @@ interface CreateSitemapHandlerOptions extends SitemapConfig {
      * Path to the app directory to scan for page.tsx files.
      * Can be absolute or relative to process.cwd().
      * If not provided, auto-detects src/app or app.
-     *
-     * Example:
-     * ```ts
-     * appDirectory: 'src/app/(frontend)'
-     * ```
      */
     appDirectory?: string;
-    /**
-     * Enable debug logging to diagnose issues with route discovery
-     * Logs info about generateStaticParams calls and skipped routes
-     * @default false
-     */
-    debug?: boolean;
 }
 /**
  * Create handlers for sitemap index route