reroute-js 0.25.2 → 0.26.0

package/core/index.js

@@ -1,5 +1,5 @@
 /**
- * reroute-js v0.25.2
+ * reroute-js v0.26.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -36,6 +36,44 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// packages/core/src/bundler/hash.ts
+async function generateContentHash(content) {
+  const data = new TextEncoder().encode(content);
+  const buf = await crypto.subtle.digest("SHA-256", data);
+  let hex = "";
+  for (const b of new Uint8Array(buf))
+    hex += b.toString(16).padStart(2, "0");
+  return hex.slice(0, 8);
+}
+
+// packages/core/src/bundler/index.ts
+var init_bundler = () => {};
+
+// packages/core/src/config.ts
+import { pathToFileURL } from "node:url";
+function defineConfig(config) {
+  return config;
+}
+async function loadConfig(cwd) {
+  const bundledConfig = globalThis.__REROUTE_CONFIG__;
+  if (bundledConfig) {
+    return bundledConfig;
+  }
+  const configPath = `${cwd}/reroute.config.ts`;
+  const configFile = Bun.file(configPath);
+  if (!await configFile.exists()) {
+    return {};
+  }
+  try {
+    const mod = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
+    return mod.default || mod;
+  } catch (error) {
+    console.warn("[reroute] Failed to load reroute.config.ts:", error);
+    return {};
+  }
+}
+var init_config = () => {};
+
 // packages/core/src/ssr/lib/path.ts
 function join(...parts) {
   return parts.join("/").replace(/\/+/g, "/");
@@ -55,6 +93,61 @@ function stripEnd(p, ch) {
   return p.endsWith(ch) ? p.slice(0, -ch.length) : p;
 }
 
+// packages/core/src/content/discovery.ts
+import { readdir, stat } from "node:fs/promises";
+async function listContentFiles(dir, baseRel) {
+  const out = [];
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      const rel = join(baseRel, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await listContentFiles(full, rel);
+        out.push(...nested);
+      } else if (entry.isFile()) {
+        if (/\.(tsx|ts)$/.test(entry.name) && !entry.name.startsWith("_")) {
+          out.push(rel);
+        }
+      }
+    }
+  } catch {}
+  return out;
+}
+async function discoverCollections(clientDir) {
+  const collections = new Set;
+  const bundledCollectionsDir = join(clientDir, "collections");
+  try {
+    const bundledEntries = await readdir(bundledCollectionsDir, {
+      withFileTypes: true
+    });
+    for (const entry of bundledEntries) {
+      if (entry.isFile() && entry.name.endsWith(".js")) {
+        const collectionName = entry.name.replace(/\.js$/, "");
+        collections.add(collectionName);
+      }
+    }
+    if (collections.size > 0) {
+      return Array.from(collections);
+    }
+  } catch {}
+  const root = join(clientDir, "routes");
+  try {
+    const entries = await readdir(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const contentDir = join(root, entry.name, "content");
+        try {
+          await stat(contentDir);
+          collections.add(entry.name);
+        } catch {}
+      }
+    }
+  } catch {}
+  return Array.from(collections);
+}
+var init_discovery = () => {};
+
 // packages/core/src/content/metadata.ts
 import { stat as stat2 } from "node:fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
@@ -94,6 +187,159 @@ function escapeHtml(input) {
 }
 var init_metadata = () => {};
 
+// packages/core/src/content/index.ts
+var init_content = __esm(() => {
+  init_discovery();
+  init_metadata();
+});
+
+// packages/telemetry/src/server/instrumentation.ts
+import { context, SpanStatusCode, trace } from "@opentelemetry/api";
+function isOtelAvailable() {
+  if (otelAvailable !== undefined)
+    return otelAvailable;
+  try {
+    __require("@opentelemetry/api");
+    otelAvailable = true;
+    return true;
+  } catch {
+    otelAvailable = false;
+    return false;
+  }
+}
+
+class NoopSpan {
+  spanContext() {
+    return {
+      traceId: "",
+      spanId: "",
+      traceFlags: 0
+    };
+  }
+  setAttribute() {
+    return this;
+  }
+  setAttributes() {
+    return this;
+  }
+  addEvent() {
+    return this;
+  }
+  addLink() {
+    return this;
+  }
+  addLinks() {
+    return this;
+  }
+  setStatus() {
+    return this;
+  }
+  updateName() {
+    return this;
+  }
+  end() {}
+  isRecording() {
+    return false;
+  }
+  recordException() {}
+}
+async function withSpan(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+function withSpanSync(name, fn, attributes) {
+  if (!isOtelAvailable()) {
+    return fn(noopSpan);
+  }
+  const tracer = trace.getTracer("reroute");
+  return tracer.startActiveSpan(name, { attributes }, (span) => {
+    try {
+      const result = fn(span);
+      span.end();
+      return result;
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      span.end();
+      throw error;
+    }
+  });
+}
+async function withParentSpan(parentSpan, fn) {
+  if (!(isOtelAvailable() && parentSpan)) {
+    return fn();
+  }
+  const ctx = trace.setSpan(context.active(), parentSpan);
+  return context.with(ctx, fn);
+}
+var otelAvailable, noopSpan;
+var init_instrumentation = __esm(() => {
+  noopSpan = new NoopSpan;
+});
+
+// packages/telemetry/src/server/plugin.ts
+import {
+  metrics,
+  SpanStatusCode as SpanStatusCode2,
+  trace as trace2
+} from "@opentelemetry/api";
+import { logs, SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-proto";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-proto";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider
+} from "@opentelemetry/sdk-logs";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader
+} from "@opentelemetry/sdk-metrics";
+import {
+  BatchSpanProcessor,
+  NodeTracerProvider
+} from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION
+} from "@opentelemetry/semantic-conventions";
+import { ATTR_HOST_NAME } from "@opentelemetry/semantic-conventions/incubating";
+var init_plugin = __esm(() => {
+  init_core();
+});
+
+// packages/telemetry/src/server/index.ts
+var init_server = __esm(() => {
+  init_instrumentation();
+  init_plugin();
+});
+
+// packages/telemetry/server.ts
+var init_server2 = __esm(() => {
+  init_server();
+});
+
 // packages/core/src/ssr/lib/cache.ts
 class SSRDataCache {
   cache = new Map;
@@ -403,7 +649,7 @@ async function computeContentData(pathname, options, searchParams, sharedSsrData
   } catch {}
   return { data: ssrData, error, statusOverride, pendingTasks };
 }
-var init_content = __esm(() => {
+var init_content2 = __esm(() => {
   init_cache();
   init_imports();
 });
@@ -837,10 +1083,10 @@ function setGlobalSSRData(data) {
 }
 var init_compute = __esm(() => {
   init_imports();
-  init_content();
+  init_content2();
   init_layouts();
   init_routes();
-  init_content();
+  init_content2();
   init_layouts();
   init_routes();
 });
@@ -1400,7 +1646,7 @@ function extractParamsFromPath(pathname, ogPath, clientDir) {
   }
   return params;
 }
-var init_discovery = () => {};
+var init_discovery2 = () => {};
 
 // packages/core/src/og/meta.ts
 async function generateOGImageMetaTags(pathname, clientDir, ogConfig) {
@@ -1436,7 +1682,7 @@ async function generateOGImageMetaTags(pathname, clientDir, ogConfig) {
 <meta name="twitter:image" content="${ogImagePath}" />`;
 }
 var init_meta = __esm(() => {
-  init_discovery();
+  init_discovery2();
 });
 
 // packages/core/src/ssr/lib/metadata.ts
@@ -1910,12 +2156,25 @@ function createSSRExportsScript(pathname) {
     return "";
   }
 }
-function createDataScript(ssrData, errorMsg, pathname) {
+function createTelemetryConfigScript(browserTelemetryConfig) {
+  if (!browserTelemetryConfig || Object.keys(browserTelemetryConfig).length === 0) {
+    return "";
+  }
+  try {
+    const configJson = escapeJsonForScript(JSON.stringify(browserTelemetryConfig));
+    return `<script>(function(){try{var w=(typeof window!=='undefined'?window:globalThis);w.__REROUTE_TELEMETRY_BROWSER__=${configJson};}catch(e){}})();</script>`;
+  } catch (error) {
+    console.error("[reroute] Failed to serialize browser telemetry config:", error);
+    return "";
+  }
+}
+function createDataScript(ssrData, errorMsg, pathname, browserTelemetryConfig) {
   let script = "";
   script += createContentCaptureScript();
   if (pathname) {
     script += createSSRExportsScript(pathname);
   }
+  script += createTelemetryConfigScript(browserTelemetryConfig);
   if (ssrData && Object.keys(ssrData).length > 0) {
     try {
       const duplicatedData = duplicateQueryParamData(ssrData);
@@ -2016,7 +2275,7 @@ async function performSSRSetup(options, streaming = false) {
   });
   try {
     return await Promise.race([
-      performSSRSetupInternal(options, streaming),
+      withParentSpan(options.parentSpan, () => performSSRSetupInternal(options, streaming)),
       timeoutPromise
     ]);
   } catch (error) {
@@ -2047,34 +2306,70 @@ async function performSSRSetupInternal(options, streaming) {
     searchParams,
     ogConfig
   } = options;
-  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - seedModule: ${(performance.now() - t0).toFixed(2)}ms`);
+  await withSpan("ssr.seed", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("streaming", streaming);
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
+    if (debug)
+      console.log(`[Setup] ${pathname} - seedModule: ${(performance.now() - t0).toFixed(2)}ms`);
+  });
   resetSSRAccessTracking();
   const bundlePreload = createBundlePreload(bundleUrl);
-  const preloadResult = await preloadContentModule(pathname, clientDir, cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - preloadContent: ${(performance.now() - t0).toFixed(2)}ms`);
-  const computeResult = await computeSSRData(pathname, clientDir, cwd, isWatchMode, { streaming, maxAge }, searchParams);
-  if (debug)
-    console.log(`[Setup] ${pathname} - computeSSRData: ${(performance.now() - t0).toFixed(2)}ms`);
+  const preloadResult = await withSpan("ssr.preload", async (span) => {
+    span.setAttribute("pathname", pathname);
+    const result = await preloadContentModule(pathname, clientDir, cwd, isWatchMode);
+    span.setAttribute("has_module", !!result.modulePath);
+    if (debug)
+      console.log(`[Setup] ${pathname} - preloadContent: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
+  const computeResult = await withSpan("ssr.compute.data", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("streaming", streaming);
+    const result = await computeSSRData(pathname, clientDir, cwd, isWatchMode, { streaming, maxAge }, searchParams);
+    span.setAttribute("has_error", !!result.error);
+    span.setAttribute("has_data", Object.keys(result.data).length > 0);
+    if (debug)
+      console.log(`[Setup] ${pathname} - computeSSRData: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
   setGlobalSSRData(computeResult.data);
   const usingCachedCollections = !!options.cachedCollections;
-  const byCollectionForSSR = options.cachedCollections ? options.cachedCollections : await loadCollections(cwd, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - loadCollections (cached: ${usingCachedCollections}): ${(performance.now() - t0).toFixed(2)}ms`);
+  const byCollectionForSSR = await withSpan("ssr.load.collections", async (span) => {
+    span.setAttribute("pathname", pathname);
+    span.setAttribute("cached", usingCachedCollections);
+    const collections = options.cachedCollections ? options.cachedCollections : await loadCollections(cwd, isWatchMode);
+    span.setAttribute("collection_count", Object.keys(collections).length);
+    if (debug)
+      console.log(`[Setup] ${pathname} - loadCollections (cached: ${usingCachedCollections}): ${(performance.now() - t0).toFixed(2)}ms`);
+    return collections;
+  });
   setGlobalCollections(byCollectionForSSR);
   const usingCachedCSS = !!options.cachedTailwindCSS;
-  const inlineStyleTag = options.cachedTailwindCSS ? options.cachedTailwindCSS : await inlineTailwindCSS(clientDir, !streaming, isWatchMode);
-  if (debug)
-    console.log(`[Setup] ${pathname} - inlineTailwindCSS (cached: ${usingCachedCSS}): ${(performance.now() - t0).toFixed(2)}ms`);
+  const inlineStyleTag = await withSpan("ssr.inline.css", async (span) => {
+    const css = options.cachedTailwindCSS ? options.cachedTailwindCSS : await inlineTailwindCSS(clientDir, !streaming, isWatchMode);
+    span.setAttributes({
+      "reroute.cached": usingCachedCSS,
+      "reroute.css.size": css.length
+    });
+    if (debug)
+      console.log(`[Setup] ${pathname} - inlineTailwindCSS (cached: ${usingCachedCSS}): ${(performance.now() - t0).toFixed(2)}ms`);
+    return css;
+  });
   let statusOverride = preloadResult.statusOverride;
   if (computeResult.statusContainer.value) {
     statusOverride = computeResult.statusContainer.value;
   }
-  const metadataResult = await extractPageMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ogConfig);
-  if (debug)
-    console.log(`[Setup] ${pathname} - extractMetadata: ${(performance.now() - t0).toFixed(2)}ms`);
+  const metadataResult = await withSpan("ssr.extract.metadata", async (span) => {
+    const result = await extractPageMetadata(pathname, clientDir, cwd, isWatchMode, statusOverride, ogConfig);
+    span.setAttributes({
+      "reroute.pathname": pathname,
+      "reroute.metadata.exists": !!result.perPageHead
+    });
+    if (debug)
+      console.log(`[Setup] ${pathname} - extractMetadata: ${(performance.now() - t0).toFixed(2)}ms`);
+    return result;
+  });
   return {
     ssrData: computeResult.data,
     ssrError: computeResult.error,
@@ -2102,10 +2397,10 @@ function generateCollectionScripts(byCollectionForSSR) {
   } catch {}
   return "";
 }
-function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "") {
+function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScripts = "", preloadScript = "", bundleUrl = "", pathname = "", browserTelemetryConfig) {
   let scripts = preloadScript;
   scripts += collectionScripts;
-  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname);
+  scripts += createDataScript(ssrData, isWatchMode ? ssrError : undefined, pathname, browserTelemetryConfig);
   scripts += createFeedsScript();
   scripts += createLlmsScript();
   if (bundleUrl) {
@@ -2117,6 +2412,7 @@ function generateHydrationScripts(ssrData, isWatchMode, ssrError, collectionScri
   return scripts;
 }
 var init_setup = __esm(() => {
+  init_server2();
   init_collections();
   init_compute();
   init_metadata2();
@@ -2185,6 +2481,7 @@ async function renderSSRDocument(options) {
     clientDir,
     cwd,
     isWatchMode,
+    parentSpan: options.parentSpan,
     bundleUrl,
     maxAge,
     searchParams,
@@ -2194,14 +2491,29 @@ async function renderSSRDocument(options) {
   }, false);
   const duplicatedData = duplicateQueryParamData(setup2.ssrData);
   setGlobalSSRData(duplicatedData);
-  const componentWithPathname = cloneElement(rootComponent, {
-    pathname,
-    searchParams
+  const appHtml = await withSpan("ssr.render.react", async (span) => {
+    const componentWithPathname = cloneElement(rootComponent, {
+      pathname,
+      searchParams
+    });
+    span.setAttribute("reroute.pathname", pathname);
+    const html3 = renderToString(componentWithPathname);
+    span.setAttribute("reroute.html.final.size", html3.length);
+    return html3;
+  });
+  const baseTemplate = await withSpan("ssr.load.template", async (span) => {
+    const template2 = await loadIndexHtml(clientDir);
+    span.setAttribute("reroute.template.size", template2.length);
+    return template2;
   });
-  const appHtml = renderToString(componentWithPathname);
-  const baseTemplate = await loadIndexHtml(clientDir);
   const collectionScripts = generateCollectionScripts(setup2.byCollectionForSSR);
-  const hydrationScript = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname);
+  const config = await loadConfig(cwd);
+  const browserTelemetryConfig = config.telemetry?.browser;
+  const hydrationScript = await withSpan("ssr.generate.scripts", async (span) => {
+    const script = generateHydrationScripts(setup2.ssrData, isWatchMode, setup2.ssrError, collectionScripts, setup2.preloadHydrationScript, bundleUrl, pathname, browserTelemetryConfig);
+    span.setAttribute("reroute.scripts.size", script.length);
+    return script;
+  });
   let statusOverride = setup2.preloadStatusOverride;
   if (setup2.statusContainer.value) {
     statusOverride = setup2.statusContainer.value;
@@ -2216,12 +2528,19 @@ async function renderSSRDocument(options) {
     dedent(setup2.metadataResult.perPageHead)
   ].filter(Boolean).join(`
 `));
-  const html2 = applyIndexTemplate(baseTemplate, appHtml, {
-    head: [setup2.inlineStyleTag, combinedHead].filter(Boolean).join(`
+  const html2 = withSpanSync("ssr.apply.template", (span) => {
+    const result = applyIndexTemplate(baseTemplate, appHtml, {
+      head: [setup2.inlineStyleTag, combinedHead].filter(Boolean).join(`
 `),
-    hydrationScript,
-    lang: setup2.metadataResult.pageLang || lang,
-    appId
+      hydrationScript,
+      lang: setup2.metadataResult.pageLang || lang,
+      appId
+    });
+    span.setAttributes({
+      "reroute.html.final.size": result.length,
+      "reroute.html.original.size": appHtml.length
+    });
+    return result;
   });
   return {
     html: html2,
@@ -2229,6 +2548,8 @@ async function renderSSRDocument(options) {
   };
 }
 var init_render = __esm(() => {
+  init_server2();
+  init_config();
   init_lib();
   init_html();
 });
@@ -2857,366 +3178,44 @@ var init_index_generator = __esm(() => {
   init_extractor();
 });
 
-// packages/core/src/sitemap/discovery.ts
-var exports_discovery = {};
-__export(exports_discovery, {
-  discoverSitemapData: () => discoverSitemapData,
-  discoverSSRDataRoutes: () => discoverSSRDataRoutes2,
-  discoverRoutes: () => discoverRoutes,
-  discoverCollectionContent: () => discoverCollectionContent
-});
-async function loadRoutesModule2(cwd, isWatchMode) {
-  let routes = globalThis.__REROUTE_ROUTES__;
-  if (!routes) {
-    const routesPath = join(cwd, ".reroute", "routes.ts");
-    const url = Bun.pathToFileURL(routesPath).href;
-    const mod = await import(`${url}${isWatchMode ? `?t=${Date.now()}` : ""}`);
-    routes = mod?.routes;
+// packages/core/src/llms/full-generator.ts
+function buildHeader(baseUrl, llmsConfig) {
+  const parts = [];
+  if (llmsConfig?.siteName) {
+    parts.push(`# ${llmsConfig.siteName}`);
+    parts.push("");
   }
-  return routes;
-}
-function shouldSkipRoute(pattern) {
-  return pattern.includes("[404]") || pattern.includes("[layout]") || pattern.includes("[skeleton]");
-}
-function categorizeRoute(route, staticRoutes, dynamicRoutes) {
-  const pattern = String(route?.pattern || "");
-  const path2 = String(route?.path || "");
-  if (shouldSkipRoute(pattern))
-    return;
-  const isDynamic = pattern.includes(":");
-  const sitemapRoute = { path: path2, pattern, isDynamic };
-  if (isDynamic) {
-    dynamicRoutes.push(sitemapRoute);
-  } else {
-    staticRoutes.push(sitemapRoute);
+  if (llmsConfig?.siteDescription) {
+    parts.push(llmsConfig.siteDescription);
+    parts.push("");
+  }
+  if (parts.length > 0) {
+    parts.push(`${baseUrl}/index.txt`);
+    parts.push("");
+    parts.push("---");
+    parts.push("");
   }
+  return parts;
 }
-async function discoverRoutes(cwd, isWatchMode) {
-  const staticRoutes = [];
-  const dynamicRoutes = [];
-  try {
-    const routes = await loadRoutesModule2(cwd, isWatchMode);
-    if (Array.isArray(routes)) {
-      for (const route of routes) {
-        categorizeRoute(route, staticRoutes, dynamicRoutes);
-      }
-    }
-  } catch (error) {
-    console.error("[reroute] Failed to discover routes for sitemap:", error);
-  }
-  return { staticRoutes, dynamicRoutes };
-}
-async function discoverCollectionContent(cwd, collection, isWatchMode, baseUrl) {
-  const entries = [];
-  try {
-    const collectionFile = join(cwd, ".reroute", "collections", `${collection}.js`);
-    const exists = await Bun.file(collectionFile).exists();
-    if (!exists) {
-      return entries;
-    }
-    const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
-    const mod = await import(url);
-    const items = mod.items || [];
-    for (const item of items) {
-      const href = String(item.href || "");
-      const meta = item.meta || {};
-      if (href) {
-        const entry = {
-          loc: `${baseUrl}${href}`,
-          lastmod: meta.date ? new Date(meta.date).toISOString() : undefined,
-          changefreq: "weekly",
-          priority: 0.7
-        };
-        entries.push(entry);
-      }
-    }
-  } catch (error) {
-    console.error(`[reroute] Failed to discover collection ${collection}:`, error);
-  }
-  return entries;
-}
-async function discoverSSRDataRoutes2(_cwd, clientDir, staticRoutes, isWatchMode, baseUrl, sitemapConfig) {
-  const ssrDataRoutes = new Map;
-  for (const route of staticRoutes) {
-    if (sitemapConfig?.excludeDiscovery?.includes(route.pattern)) {
-      continue;
-    }
-    try {
-      const abs = join(clientDir, "routes", route.path);
-      const mod = await import(Bun.pathToFileURL(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
-      const ssr = mod?.ssr;
-      const dataFn = ssr?.data;
-      if (typeof dataFn === "function") {
-        const mockSet = { status: 200 };
-        const result = await dataFn({
-          pathname: route.pattern,
-          params: {},
-          set: mockSet
-        });
-        const entries = extractEntriesFromData(result, route.pattern, baseUrl, sitemapConfig);
-        if (entries.length > 0) {
-          ssrDataRoutes.set(route.pattern, entries);
-        }
-      }
-    } catch {}
-  }
-  return ssrDataRoutes;
-}
-function findArraysInObject(obj) {
-  const arrays = [];
-  for (const value of Object.values(obj)) {
-    if (Array.isArray(value)) {
-      arrays.push(value);
-    } else if (value && typeof value === "object") {
-      arrays.push(...findArraysInObject(value));
-    }
-  }
-  return arrays;
-}
-function processItemsToEntries(items, routePattern, baseUrl, sitemapConfig) {
-  const entries = [];
-  for (const item of items) {
-    if (typeof item !== "object" || item === null)
-      continue;
-    const entry = createEntryFromItem(item, routePattern, baseUrl, sitemapConfig);
-    if (entry) {
-      entries.push(entry);
-    }
-  }
-  return entries;
-}
-function extractWithCustomFunction(data, routePattern, baseUrl, sitemapConfig) {
-  try {
-    const items = sitemapConfig.extractUrls?.(data, routePattern);
-    if (!Array.isArray(items))
-      return [];
-    return processItemsToEntries(items, routePattern, baseUrl, sitemapConfig);
-  } catch (error) {
-    console.warn("[reroute/sitemap] extractUrls failed:", error);
-    return [];
-  }
-}
-function extractWithAutoDiscovery(data, routePattern, baseUrl, sitemapConfig) {
-  const entries = [];
-  const arrays = findArraysInObject(data);
-  for (const array of arrays) {
-    if (array.length > 0) {
-      const arrayEntries = processItemsToEntries(array, routePattern, baseUrl, sitemapConfig);
-      entries.push(...arrayEntries);
-    }
-  }
-  return entries;
-}
-function extractEntriesFromData(data, routePattern, baseUrl, sitemapConfig) {
-  if (!data || typeof data !== "object") {
-    return [];
-  }
-  if (sitemapConfig?.extractUrls) {
-    return extractWithCustomFunction(data, routePattern, baseUrl, sitemapConfig);
-  }
-  return extractWithAutoDiscovery(data, routePattern, baseUrl, sitemapConfig);
-}
-function extractIdentifierFromItem(item, routePattern, sitemapConfig) {
-  if (sitemapConfig?.extractUrl) {
-    try {
-      const identifier2 = sitemapConfig.extractUrl(item, routePattern);
-      if (identifier2)
-        return identifier2;
-    } catch (error) {
-      console.warn("[reroute/sitemap] extractUrl failed:", error);
-    }
-  }
-  const identifier = item.version || item.slug || item.id || item.name || item.key;
-  return identifier ? identifier : null;
-}
-function extractLastmodFromItem(item, sitemapConfig) {
-  if (sitemapConfig?.extractLastmod) {
-    try {
-      const lastmod = sitemapConfig.extractLastmod(item);
-      if (lastmod) {
-        return new Date(lastmod).toISOString();
-      }
-    } catch (error) {
-      console.warn("[reroute/sitemap] extractLastmod failed:", error);
-    }
-  }
-  if (item.publishedAt && typeof item.publishedAt === "string") {
-    return new Date(item.publishedAt).toISOString();
-  }
-  if (item.date && typeof item.date === "string") {
-    return new Date(item.date).toISOString();
-  }
-  if (item.updatedAt && typeof item.updatedAt === "string") {
-    return new Date(item.updatedAt).toISOString();
-  }
-  return;
-}
-function createEntryFromItem(item, routePattern, baseUrl, sitemapConfig) {
-  const identifier = extractIdentifierFromItem(item, routePattern, sitemapConfig);
-  if (!identifier) {
-    return null;
-  }
-  const url = `${baseUrl}${routePattern}/${identifier}`;
-  const entry = {
-    loc: url,
-    changefreq: sitemapConfig?.changefreq || "weekly",
-    priority: sitemapConfig?.priority !== undefined ? sitemapConfig.priority : 0.6
-  };
-  const lastmod = extractLastmodFromItem(item, sitemapConfig);
-  if (lastmod) {
-    entry.lastmod = lastmod;
-  }
-  return entry;
-}
-async function discoverSitemapData(cwd, clientDir, collections2, baseUrl, isWatchMode, sitemapConfig) {
-  const { staticRoutes, dynamicRoutes } = await discoverRoutes(cwd, isWatchMode);
-  const collectionsMap = new Map;
-  for (const collection of collections2) {
-    const entries = await discoverCollectionContent(cwd, collection, isWatchMode, baseUrl);
-    if (entries.length > 0) {
-      collectionsMap.set(collection, entries);
-    }
-  }
-  const ssrDataRoutes = await discoverSSRDataRoutes2(cwd, clientDir, staticRoutes, isWatchMode, baseUrl, sitemapConfig);
-  return {
-    staticRoutes,
-    dynamicRoutes,
-    collections: collectionsMap,
-    ssrDataRoutes
-  };
-}
-var init_discovery2 = () => {};
-
-// packages/core/src/bundler/hash.ts
-async function generateContentHash(content) {
-  const data = new TextEncoder().encode(content);
-  const buf = await crypto.subtle.digest("SHA-256", data);
-  let hex = "";
-  for (const b of new Uint8Array(buf))
-    hex += b.toString(16).padStart(2, "0");
-  return hex.slice(0, 8);
-}
-// packages/core/src/config.ts
-import { pathToFileURL } from "node:url";
-function defineConfig(config) {
-  return config;
-}
-async function loadConfig(cwd) {
-  const bundledConfig = globalThis.__REROUTE_CONFIG__;
-  if (bundledConfig) {
-    return bundledConfig;
-  }
-  const configPath = `${cwd}/reroute.config.ts`;
-  const configFile = Bun.file(configPath);
-  if (!await configFile.exists()) {
-    return {};
-  }
-  try {
-    const mod = await import(`${pathToFileURL(configPath).href}?t=${Date.now()}`);
-    return mod.default || mod;
-  } catch (error) {
-    console.warn("[reroute] Failed to load reroute.config.ts:", error);
-    return {};
-  }
-}
-// packages/core/src/content/discovery.ts
-import { readdir, stat } from "node:fs/promises";
-async function listContentFiles(dir, baseRel) {
-  const out = [];
-  try {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join(dir, entry.name);
-      const rel = join(baseRel, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await listContentFiles(full, rel);
-        out.push(...nested);
-      } else if (entry.isFile()) {
-        if (/\.(tsx|ts)$/.test(entry.name) && !entry.name.startsWith("_")) {
-          out.push(rel);
-        }
-      }
-    }
-  } catch {}
-  return out;
-}
-async function discoverCollections(clientDir) {
-  const collections = new Set;
-  const bundledCollectionsDir = join(clientDir, "collections");
-  try {
-    const bundledEntries = await readdir(bundledCollectionsDir, {
-      withFileTypes: true
-    });
-    for (const entry of bundledEntries) {
-      if (entry.isFile() && entry.name.endsWith(".js")) {
-        const collectionName = entry.name.replace(/\.js$/, "");
-        collections.add(collectionName);
-      }
-    }
-    if (collections.size > 0) {
-      return Array.from(collections);
-    }
-  } catch {}
-  const root = join(clientDir, "routes");
-  try {
-    const entries = await readdir(root, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const contentDir = join(root, entry.name, "content");
-        try {
-          await stat(contentDir);
-          collections.add(entry.name);
-        } catch {}
-      }
-    }
-  } catch {}
-  return Array.from(collections);
-}
-
-// packages/core/src/content/index.ts
-init_metadata();
-// packages/core/src/llms/index.ts
-init_extractor();
-
-// packages/core/src/llms/full-generator.ts
-init_extractor();
-function buildHeader(baseUrl, llmsConfig) {
-  const parts = [];
-  if (llmsConfig?.siteName) {
-    parts.push(`# ${llmsConfig.siteName}`);
-    parts.push("");
-  }
-  if (llmsConfig?.siteDescription) {
-    parts.push(llmsConfig.siteDescription);
-    parts.push("");
-  }
-  if (parts.length > 0) {
-    parts.push(`${baseUrl}/index.txt`);
-    parts.push("");
-    parts.push("---");
-    parts.push("");
-  }
-  return parts;
-}
-async function discoverAllRoutes(cwd, clientDir, collections2, isWatchMode, llmsConfig) {
-  const {
-    discoverStaticRoutes: discoverStaticRoutes2,
-    discoverCollectionRoutes: discoverCollectionRoutes2,
-    discoverSSRDataRoutes: discoverSSRDataRoutes2
-  } = await Promise.resolve().then(() => (init_index_generator(), exports_index_generator));
-  const staticRoutes = await discoverStaticRoutes2(cwd, isWatchMode);
-  const collectionsMap = await discoverCollectionRoutes2(cwd, collections2, isWatchMode, llmsConfig);
-  const ssrDataRoutes = await discoverSSRDataRoutes2(cwd, clientDir, staticRoutes, isWatchMode);
-  const allRoutes = [];
-  for (const route of staticRoutes) {
-    if (!shouldExcludeRoute(route.path, llmsConfig?.excludeRoutes)) {
-      allRoutes.push({ path: route.path });
-    }
-  }
-  for (const [_collection, routes] of collectionsMap.entries()) {
-    for (const route of routes) {
-      if (!shouldExcludeRoute(route.path, llmsConfig?.excludeRoutes)) {
-        allRoutes.push({ path: route.path });
+async function discoverAllRoutes(cwd, clientDir, collections2, isWatchMode, llmsConfig) {
+  const {
+    discoverStaticRoutes: discoverStaticRoutes2,
+    discoverCollectionRoutes: discoverCollectionRoutes2,
+    discoverSSRDataRoutes: discoverSSRDataRoutes2
+  } = await Promise.resolve().then(() => (init_index_generator(), exports_index_generator));
+  const staticRoutes = await discoverStaticRoutes2(cwd, isWatchMode);
+  const collectionsMap = await discoverCollectionRoutes2(cwd, collections2, isWatchMode, llmsConfig);
+  const ssrDataRoutes = await discoverSSRDataRoutes2(cwd, clientDir, staticRoutes, isWatchMode);
+  const allRoutes = [];
+  for (const route of staticRoutes) {
+    if (!shouldExcludeRoute(route.path, llmsConfig?.excludeRoutes)) {
+      allRoutes.push({ path: route.path });
+    }
+  }
+  for (const [_collection, routes] of collectionsMap.entries()) {
+    for (const route of routes) {
+      if (!shouldExcludeRoute(route.path, llmsConfig?.excludeRoutes)) {
+        allRoutes.push({ path: route.path });
       }
     }
   }
@@ -3312,12 +3311,16 @@ async function generateLLMsFullContent(options) {
     stats: { itemCount: extracted.itemCount, byteSize }
   };
 }
+var init_full_generator = __esm(() => {
+  init_extractor();
+});
 
 // packages/core/src/llms/index.ts
-init_index_generator();
-// packages/core/src/og/index.ts
-init_discovery();
-init_meta();
+var init_llms = __esm(() => {
+  init_extractor();
+  init_full_generator();
+  init_index_generator();
+});
 
 // packages/core/src/og/render.ts
 import { createElement } from "react";
@@ -3417,6 +3420,15 @@ function DefaultOGTemplate({
     }
   }))));
 }
+var init_render2 = () => {};
+
+// packages/core/src/og/index.ts
+var init_og = __esm(() => {
+  init_discovery2();
+  init_meta();
+  init_render2();
+});
+
 // packages/core/src/robots/discovery.ts
 async function discoverRoutesForRobots(cwd, isWatchMode) {
   const routes = [];
@@ -3467,6 +3479,8 @@ async function discoverRobotsData(cwd, isWatchMode, robotsConfig, sitemapConfig,
     redirectSourcePaths
   };
 }
+var init_discovery3 = () => {};
+
 // packages/core/src/robots/generator.ts
 function getEffectivePolicies(policies) {
   if (policies.length > 0)
@@ -3491,125 +3505,366 @@ function addAllowDirectives(lines, policy) {
     lines.push(`Allow: ${path2}`);
   }
 }
-function getDisallows(policy, autoDisallows) {
-  const disallows = new Set(policy.disallow || []);
-  if (policy.userAgent === "*") {
-    for (const path2 of autoDisallows) {
-      disallows.add(path2);
+function getDisallows(policy, autoDisallows) {
+  const disallows = new Set(policy.disallow || []);
+  if (policy.userAgent === "*") {
+    for (const path2 of autoDisallows) {
+      disallows.add(path2);
+    }
+  }
+  return disallows;
+}
+function addDisallowDirectives(lines, policy, autoDisallows) {
+  const disallows = getDisallows(policy, autoDisallows);
+  if (disallows.size > 0) {
+    for (const path2 of Array.from(disallows).sort()) {
+      lines.push(`Disallow: ${path2}`);
+    }
+  }
+}
+function addPolicyBlock(lines, policy, autoDisallows) {
+  lines.push(`User-agent: ${policy.userAgent}`);
+  addAllowDirectives(lines, policy);
+  addDisallowDirectives(lines, policy, autoDisallows);
+  if (policy.crawlDelay !== undefined) {
+    lines.push(`Crawl-delay: ${policy.crawlDelay}`);
+  }
+  lines.push("");
+}
+function addGlobalCrawlDelay(lines, crawlDelay, effectivePolicies) {
+  const hasWildcardCrawlDelay = effectivePolicies.some((p) => p.userAgent === "*" && p.crawlDelay !== undefined);
+  if (crawlDelay !== undefined && !hasWildcardCrawlDelay) {
+    lines.push(`Crawl-delay: ${crawlDelay}`);
+    lines.push("");
+  }
+}
+function addSitemapReference(lines, robotsConfig, sitemapEnabled) {
+  if (robotsConfig.referenceSitemap !== false && sitemapEnabled && robotsConfig.baseUrl) {
+    lines.push(`Sitemap: ${robotsConfig.baseUrl}/sitemap.xml`);
+  }
+}
+function generateRobots(discovery2, robotsConfig, sitemapEnabled) {
+  const lines = [];
+  const { policies = [], customRules, crawlDelay } = robotsConfig;
+  const effectivePolicies = getEffectivePolicies(policies);
+  const autoDisallows = getAutoDisallows(discovery2);
+  for (const policy of effectivePolicies) {
+    addPolicyBlock(lines, policy, autoDisallows);
+  }
+  addGlobalCrawlDelay(lines, crawlDelay, effectivePolicies);
+  if (customRules) {
+    lines.push(customRules.trim());
+    lines.push("");
+  }
+  addSitemapReference(lines, robotsConfig, sitemapEnabled);
+  return `${lines.join(`
+`).trim()}
+`;
+}
+
+// packages/core/src/robots/policies.ts
+function blockAICrawlers(crawlers) {
+  const agents = crawlers || Object.values(AI_CRAWLERS);
+  return agents.map((agent) => ({
+    userAgent: agent,
+    disallow: ["/"]
+  }));
+}
+function allowAICrawlers(crawlers) {
+  const agents = crawlers || Object.values(AI_CRAWLERS);
+  return agents.map((agent) => ({
+    userAgent: agent,
+    allow: ["/"]
+  }));
+}
+function blockAITrainingCrawlers() {
+  const trainingCrawlers = [
+    AI_CRAWLERS.GOOGLE_EXTENDED,
+    AI_CRAWLERS.COMMON_CRAWL,
+    AI_CRAWLERS.BYTEDANCE,
+    AI_CRAWLERS.OMGILI
+  ];
+  return trainingCrawlers.map((agent) => ({
+    userAgent: agent,
+    disallow: ["/"]
+  }));
+}
+function allowSearchCrawlers(crawlers) {
+  const agents = crawlers || Object.values(SEARCH_CRAWLERS);
+  return agents.map((agent) => ({
+    userAgent: agent,
+    allow: ["/"]
+  }));
+}
+function blockSearchCrawlers(crawlers) {
+  const agents = crawlers || Object.values(SEARCH_CRAWLERS);
+  return agents.map((agent) => ({
+    userAgent: agent,
+    disallow: ["/"]
+  }));
+}
+var AI_CRAWLERS, SEARCH_CRAWLERS;
+var init_policies = __esm(() => {
+  AI_CRAWLERS = {
+    GPT: "GPTBot",
+    CHATGPT: "ChatGPT-User",
+    CLAUDE: "Claude-Web",
+    ANTHROPIC: "anthropic-ai",
+    COHERE: "cohere-ai",
+    GOOGLE_EXTENDED: "Google-Extended",
+    FACEBOOK: "FacebookBot",
+    APPLE_EXTENDED: "Applebot-Extended",
+    PERPLEXITY: "PerplexityBot",
+    BYTEDANCE: "Bytespider",
+    COMMON_CRAWL: "CCBot",
+    OMGILI: "Omgilibot"
+  };
+  SEARCH_CRAWLERS = {
+    GOOGLEBOT: "Googlebot",
+    BINGBOT: "Bingbot",
+    SLURP: "Slurp",
+    DUCKDUCKBOT: "DuckDuckBot",
+    BAIDUSPIDER: "Baiduspider",
+    YANDEXBOT: "YandexBot"
+  };
+});
+
+// packages/core/src/robots/index.ts
+var init_robots = __esm(() => {
+  init_discovery3();
+  init_policies();
+});
+
+// packages/core/src/sitemap/discovery.ts
+var exports_discovery = {};
+__export(exports_discovery, {
+  discoverSitemapData: () => discoverSitemapData,
+  discoverSSRDataRoutes: () => discoverSSRDataRoutes2,
+  discoverRoutes: () => discoverRoutes,
+  discoverCollectionContent: () => discoverCollectionContent
+});
+async function loadRoutesModule2(cwd, isWatchMode) {
+  let routes = globalThis.__REROUTE_ROUTES__;
+  if (!routes) {
+    const routesPath = join(cwd, ".reroute", "routes.ts");
+    const url = Bun.pathToFileURL(routesPath).href;
+    const mod = await import(`${url}${isWatchMode ? `?t=${Date.now()}` : ""}`);
+    routes = mod?.routes;
+  }
+  return routes;
+}
+function shouldSkipRoute(pattern) {
+  return pattern.includes("[404]") || pattern.includes("[layout]") || pattern.includes("[skeleton]");
+}
+function categorizeRoute(route, staticRoutes, dynamicRoutes) {
+  const pattern = String(route?.pattern || "");
+  const path2 = String(route?.path || "");
+  if (shouldSkipRoute(pattern))
+    return;
+  const isDynamic = pattern.includes(":");
+  const sitemapRoute = { path: path2, pattern, isDynamic };
+  if (isDynamic) {
+    dynamicRoutes.push(sitemapRoute);
+  } else {
+    staticRoutes.push(sitemapRoute);
+  }
+}
+async function discoverRoutes(cwd, isWatchMode) {
+  const staticRoutes = [];
+  const dynamicRoutes = [];
+  try {
+    const routes = await loadRoutesModule2(cwd, isWatchMode);
+    if (Array.isArray(routes)) {
+      for (const route of routes) {
+        categorizeRoute(route, staticRoutes, dynamicRoutes);
+      }
+    }
+  } catch (error) {
+    console.error("[reroute] Failed to discover routes for sitemap:", error);
+  }
+  return { staticRoutes, dynamicRoutes };
+}
+async function discoverCollectionContent(cwd, collection, isWatchMode, baseUrl) {
+  const entries = [];
+  try {
+    const collectionFile = join(cwd, ".reroute", "collections", `${collection}.js`);
+    const exists = await Bun.file(collectionFile).exists();
+    if (!exists) {
+      return entries;
+    }
+    const url = `${Bun.pathToFileURL(collectionFile).href}${isWatchMode ? `?t=${Date.now()}` : ""}`;
+    const mod = await import(url);
+    const items = mod.items || [];
+    for (const item of items) {
+      const href = String(item.href || "");
+      const meta = item.meta || {};
+      if (href) {
+        const entry = {
+          loc: `${baseUrl}${href}`,
+          lastmod: meta.date ? new Date(meta.date).toISOString() : undefined,
+          changefreq: "weekly",
+          priority: 0.7
+        };
+        entries.push(entry);
+      }
+    }
+  } catch (error) {
+    console.error(`[reroute] Failed to discover collection ${collection}:`, error);
+  }
+  return entries;
+}
+async function discoverSSRDataRoutes2(_cwd, clientDir, staticRoutes, isWatchMode, baseUrl, sitemapConfig) {
+  const ssrDataRoutes = new Map;
+  for (const route of staticRoutes) {
+    if (sitemapConfig?.excludeDiscovery?.includes(route.pattern)) {
+      continue;
+    }
+    try {
+      const abs = join(clientDir, "routes", route.path);
+      const mod = await import(Bun.pathToFileURL(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
+      const ssr = mod?.ssr;
+      const dataFn = ssr?.data;
+      if (typeof dataFn === "function") {
+        const mockSet = { status: 200 };
+        const result = await dataFn({
+          pathname: route.pattern,
+          params: {},
+          set: mockSet
+        });
+        const entries = extractEntriesFromData(result, route.pattern, baseUrl, sitemapConfig);
+        if (entries.length > 0) {
+          ssrDataRoutes.set(route.pattern, entries);
+        }
+      }
+    } catch {}
+  }
+  return ssrDataRoutes;
+}
+function findArraysInObject(obj) {
+  const arrays = [];
+  for (const value of Object.values(obj)) {
+    if (Array.isArray(value)) {
+      arrays.push(value);
+    } else if (value && typeof value === "object") {
+      arrays.push(...findArraysInObject(value));
     }
   }
-  return disallows;
+  return arrays;
 }
-function addDisallowDirectives(lines, policy, autoDisallows) {
-  const disallows = getDisallows(policy, autoDisallows);
-  if (disallows.size > 0) {
-    for (const path2 of Array.from(disallows).sort()) {
-      lines.push(`Disallow: ${path2}`);
+function processItemsToEntries(items, routePattern, baseUrl, sitemapConfig) {
+  const entries = [];
+  for (const item of items) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const entry = createEntryFromItem(item, routePattern, baseUrl, sitemapConfig);
+    if (entry) {
+      entries.push(entry);
     }
   }
+  return entries;
 }
-function addPolicyBlock(lines, policy, autoDisallows) {
-  lines.push(`User-agent: ${policy.userAgent}`);
-  addAllowDirectives(lines, policy);
-  addDisallowDirectives(lines, policy, autoDisallows);
-  if (policy.crawlDelay !== undefined) {
-    lines.push(`Crawl-delay: ${policy.crawlDelay}`);
-  }
-  lines.push("");
-}
-function addGlobalCrawlDelay(lines, crawlDelay, effectivePolicies) {
-  const hasWildcardCrawlDelay = effectivePolicies.some((p) => p.userAgent === "*" && p.crawlDelay !== undefined);
-  if (crawlDelay !== undefined && !hasWildcardCrawlDelay) {
-    lines.push(`Crawl-delay: ${crawlDelay}`);
-    lines.push("");
+function extractWithCustomFunction(data, routePattern, baseUrl, sitemapConfig) {
+  try {
+    const items = sitemapConfig.extractUrls?.(data, routePattern);
+    if (!Array.isArray(items))
+      return [];
+    return processItemsToEntries(items, routePattern, baseUrl, sitemapConfig);
+  } catch (error) {
+    console.warn("[reroute/sitemap] extractUrls failed:", error);
+    return [];
   }
 }
-function addSitemapReference(lines, robotsConfig, sitemapEnabled) {
-  if (robotsConfig.referenceSitemap !== false && sitemapEnabled && robotsConfig.baseUrl) {
-    lines.push(`Sitemap: ${robotsConfig.baseUrl}/sitemap.xml`);
+function extractWithAutoDiscovery(data, routePattern, baseUrl, sitemapConfig) {
+  const entries = [];
+  const arrays = findArraysInObject(data);
+  for (const array of arrays) {
+    if (array.length > 0) {
+      const arrayEntries = processItemsToEntries(array, routePattern, baseUrl, sitemapConfig);
+      entries.push(...arrayEntries);
+    }
   }
+  return entries;
 }
-function generateRobots(discovery2, robotsConfig, sitemapEnabled) {
-  const lines = [];
-  const { policies = [], customRules, crawlDelay } = robotsConfig;
-  const effectivePolicies = getEffectivePolicies(policies);
-  const autoDisallows = getAutoDisallows(discovery2);
-  for (const policy of effectivePolicies) {
-    addPolicyBlock(lines, policy, autoDisallows);
+function extractEntriesFromData(data, routePattern, baseUrl, sitemapConfig) {
+  if (!data || typeof data !== "object") {
+    return [];
   }
-  addGlobalCrawlDelay(lines, crawlDelay, effectivePolicies);
-  if (customRules) {
-    lines.push(customRules.trim());
-    lines.push("");
+  if (sitemapConfig?.extractUrls) {
+    return extractWithCustomFunction(data, routePattern, baseUrl, sitemapConfig);
   }
-  addSitemapReference(lines, robotsConfig, sitemapEnabled);
-  return `${lines.join(`
-`).trim()}
-`;
-}
-// packages/core/src/robots/policies.ts
-var AI_CRAWLERS = {
-  GPT: "GPTBot",
-  CHATGPT: "ChatGPT-User",
-  CLAUDE: "Claude-Web",
-  ANTHROPIC: "anthropic-ai",
-  COHERE: "cohere-ai",
-  GOOGLE_EXTENDED: "Google-Extended",
-  FACEBOOK: "FacebookBot",
-  APPLE_EXTENDED: "Applebot-Extended",
-  PERPLEXITY: "PerplexityBot",
-  BYTEDANCE: "Bytespider",
-  COMMON_CRAWL: "CCBot",
-  OMGILI: "Omgilibot"
-};
-var SEARCH_CRAWLERS = {
-  GOOGLEBOT: "Googlebot",
-  BINGBOT: "Bingbot",
-  SLURP: "Slurp",
-  DUCKDUCKBOT: "DuckDuckBot",
-  BAIDUSPIDER: "Baiduspider",
-  YANDEXBOT: "YandexBot"
-};
-function blockAICrawlers(crawlers) {
-  const agents = crawlers || Object.values(AI_CRAWLERS);
-  return agents.map((agent) => ({
-    userAgent: agent,
-    disallow: ["/"]
-  }));
+  return extractWithAutoDiscovery(data, routePattern, baseUrl, sitemapConfig);
 }
-function allowAICrawlers(crawlers) {
-  const agents = crawlers || Object.values(AI_CRAWLERS);
-  return agents.map((agent) => ({
-    userAgent: agent,
-    allow: ["/"]
-  }));
+function extractIdentifierFromItem(item, routePattern, sitemapConfig) {
+  if (sitemapConfig?.extractUrl) {
+    try {
+      const identifier2 = sitemapConfig.extractUrl(item, routePattern);
+      if (identifier2)
+        return identifier2;
+    } catch (error) {
+      console.warn("[reroute/sitemap] extractUrl failed:", error);
+    }
+  }
+  const identifier = item.version || item.slug || item.id || item.name || item.key;
+  return identifier ? identifier : null;
 }
-function blockAITrainingCrawlers() {
-  const trainingCrawlers = [
-    AI_CRAWLERS.GOOGLE_EXTENDED,
-    AI_CRAWLERS.COMMON_CRAWL,
-    AI_CRAWLERS.BYTEDANCE,
-    AI_CRAWLERS.OMGILI
-  ];
-  return trainingCrawlers.map((agent) => ({
-    userAgent: agent,
-    disallow: ["/"]
-  }));
+function extractLastmodFromItem(item, sitemapConfig) {
+  if (sitemapConfig?.extractLastmod) {
+    try {
+      const lastmod = sitemapConfig.extractLastmod(item);
+      if (lastmod) {
+        return new Date(lastmod).toISOString();
+      }
+    } catch (error) {
+      console.warn("[reroute/sitemap] extractLastmod failed:", error);
+    }
+  }
+  if (item.publishedAt && typeof item.publishedAt === "string") {
+    return new Date(item.publishedAt).toISOString();
+  }
+  if (item.date && typeof item.date === "string") {
+    return new Date(item.date).toISOString();
+  }
+  if (item.updatedAt && typeof item.updatedAt === "string") {
+    return new Date(item.updatedAt).toISOString();
+  }
+  return;
 }
-function allowSearchCrawlers(crawlers) {
-  const agents = crawlers || Object.values(SEARCH_CRAWLERS);
-  return agents.map((agent) => ({
-    userAgent: agent,
-    allow: ["/"]
-  }));
+function createEntryFromItem(item, routePattern, baseUrl, sitemapConfig) {
+  const identifier = extractIdentifierFromItem(item, routePattern, sitemapConfig);
+  if (!identifier) {
+    return null;
+  }
+  const url = `${baseUrl}${routePattern}/${identifier}`;
+  const entry = {
+    loc: url,
+    changefreq: sitemapConfig?.changefreq || "weekly",
+    priority: sitemapConfig?.priority !== undefined ? sitemapConfig.priority : 0.6
+  };
+  const lastmod = extractLastmodFromItem(item, sitemapConfig);
+  if (lastmod) {
+    entry.lastmod = lastmod;
+  }
+  return entry;
 }
-function blockSearchCrawlers(crawlers) {
-  const agents = crawlers || Object.values(SEARCH_CRAWLERS);
-  return agents.map((agent) => ({
-    userAgent: agent,
-    disallow: ["/"]
-  }));
+async function discoverSitemapData(cwd, clientDir, collections2, baseUrl, isWatchMode, sitemapConfig) {
+  const { staticRoutes, dynamicRoutes } = await discoverRoutes(cwd, isWatchMode);
+  const collectionsMap = new Map;
+  for (const collection of collections2) {
+    const entries = await discoverCollectionContent(cwd, collection, isWatchMode, baseUrl);
+    if (entries.length > 0) {
+      collectionsMap.set(collection, entries);
+    }
+  }
+  const ssrDataRoutes = await discoverSSRDataRoutes2(cwd, clientDir, staticRoutes, isWatchMode, baseUrl, sitemapConfig);
+  return {
+    staticRoutes,
+    dynamicRoutes,
+    collections: collectionsMap,
+    ssrDataRoutes
+  };
 }
+var init_discovery4 = () => {};
+
 // packages/core/src/rss/discovery.ts
 import { pathToFileURL as pathToFileURL7 } from "node:url";
 function extractDescription(meta, rssConfig) {
@@ -3863,7 +4118,7 @@ async function discoverRSSData(cwd, clientDir, collections2, baseUrl, isWatchMod
     }
   }
   const ssrDataFeeds = new Map;
-  const { discoverRoutes: discoverRoutes2 } = await Promise.resolve().then(() => (init_discovery2(), exports_discovery));
+  const { discoverRoutes: discoverRoutes2 } = await Promise.resolve().then(() => (init_discovery4(), exports_discovery));
   const { staticRoutes } = await discoverRoutes2(cwd, isWatchMode);
   for (const route of staticRoutes) {
     if (rssConfig?.excludeDiscovery?.includes(route.pattern)) {
@@ -3937,6 +4192,8 @@ async function discoverLayoutFeedItems(cwd, clientDir, isWatchMode, baseUrl, rss
   }
   return layoutFeeds;
 }
+var init_discovery5 = () => {};
+
 // packages/core/src/rss/generator.ts
 function generateRSSXML(feed, options = {}) {
   const { limit } = options;
@@ -4045,11 +4302,13 @@ function generateFeed(feed, options = {}) {
 function escapeXml(unsafe) {
   return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-// packages/core/src/sitemap/index.ts
-init_discovery2();
+
+// packages/core/src/rss/index.ts
+var init_rss = __esm(() => {
+  init_discovery5();
+});
 
 // packages/core/src/sitemap/generator.ts
-var DEFAULT_MAX_URLS = 50000;
 function normalizeRouteLocation(loc) {
   if (loc === "/index") {
     return "/";
@@ -4182,14 +4441,16 @@ ${sitemapEntries}
 function escapeXml2(unsafe) {
   return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-// packages/core/src/ssr/index.ts
-init_lib();
-init_render();
+var DEFAULT_MAX_URLS = 50000;
+var init_generator = () => {};
+
+// packages/core/src/sitemap/index.ts
+var init_sitemap = __esm(() => {
+  init_discovery4();
+  init_generator();
+});
 
 // packages/core/src/ssr/stream.ts
-init_lib();
-init_html();
-init_imports();
 import { cloneElement as cloneElement2 } from "react";
 import { renderToReadableStream } from "react-dom/server";
 async function renderSSRDocumentStream(options) {
@@ -4216,6 +4477,7 @@ async function renderSSRDocumentStream(options) {
     clientDir,
     cwd,
     isWatchMode,
+    parentSpan: options.parentSpan,
     bundleUrl,
     maxAge,
     searchParams,
@@ -4237,14 +4499,19 @@ async function renderSSRDocumentStream(options) {
   const { readable, writable } = new TransformStream;
   const writer = writable.getWriter();
   const usingCache = !!options.cachedIndexHtml;
-  const tBeforeLoad = debug ? performance.now() : 0;
-  const baseTemplate = options.cachedIndexHtml ? options.cachedIndexHtml : await loadIndexHtml(clientDir);
-  if (debug)
-    console.log(`[renderStream] ${pathname} - loadIndexHtml (cached: ${usingCache}): ${(performance.now() - t0).toFixed(2)}ms (actual load: ${(performance.now() - tBeforeLoad).toFixed(2)}ms)`);
-  const tBeforeSplit = debug ? performance.now() : 0;
-  const { htmlHead, rootStart, rootEnd, htmlTail } = splitTemplate(baseTemplate, appId);
-  if (debug)
-    console.log(`[renderStream] ${pathname} - splitTemplate: ${(performance.now() - t0).toFixed(2)}ms (split took: ${(performance.now() - tBeforeSplit).toFixed(2)}ms)`);
+  const { htmlHead, rootStart, rootEnd, htmlTail } = await withSpan("ssr.load.template", async (span) => {
+    const template2 = options.cachedIndexHtml ? options.cachedIndexHtml : await loadIndexHtml(clientDir);
+    span.setAttribute("reroute.cached", usingCache);
+    span.setAttribute("reroute.template.size", template2.length);
+    if (debug)
+      console.log(`[renderStream] ${pathname} - loadIndexHtml (cached: ${usingCache}): ${(performance.now() - t0).toFixed(2)}ms`);
+    const parts = splitTemplate(template2, appId);
+    if (debug)
+      console.log(`[renderStream] ${pathname} - splitTemplate: ${(performance.now() - t0).toFixed(2)}ms`);
+    return {
+      ...parts
+    };
+  });
   const pageLang = setup2.metadataResult.pageLang || lang;
   let headWithLang = htmlHead.replace(/<html([^>]*)>/i, `<html$1 lang="${pageLang}">`);
   const extraHead = setup2.bundlePreload + setup2.preloadExtraHead + setup2.metadataResult.perPageHead;
@@ -4254,6 +4521,8 @@ async function renderSSRDocumentStream(options) {
   if (/<meta\s+name\s*=\s*['"]description['"][^>]*>/i.test(extraHead)) {
     headWithLang = headWithLang.replace(/<meta\s+name\s*=\s*['"]description['"][^>]*>/i, "");
   }
+  const config = await loadConfig(cwd);
+  const browserTelemetryConfig = config.telemetry?.browser;
   streamSSRContent(writer, encoder, {
     rootComponent,
     pathname,
@@ -4272,82 +4541,102 @@ async function renderSSRDocumentStream(options) {
     ssrData: setup2.ssrData,
     ssrError: setup2.ssrError,
     byCollectionForSSR: setup2.byCollectionForSSR,
-    preloadHydrationScript: setup2.preloadHydrationScript
+    preloadHydrationScript: setup2.preloadHydrationScript,
+    browserTelemetryConfig,
+    parentSpan: options.parentSpan
   });
   if (debug)
     console.log(`[renderStream] ${pathname} - returning stream: ${(performance.now() - t0).toFixed(2)}ms`);
   return { stream: readable, status: statusOverride || 200 };
 }
 async function streamSSRContent(writer, encoder, ctx) {
-  const t0 = ctx.debug ? performance.now() : 0;
-  const STREAM_TIMEOUT_MS = 60000;
-  let streamTimedOut = false;
-  let timeoutId = null;
-  const cleanup = () => {
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  try {
-    const combinedHead = deduplicateMetaTags([ctx.inlineStyleTag, ctx.head, ctx.extraHead].filter(Boolean).join(`
+  return withParentSpan(ctx.parentSpan, async () => {
+    const t0 = ctx.debug ? performance.now() : 0;
+    const STREAM_TIMEOUT_MS = 60000;
+    let streamTimedOut = false;
+    let timeoutId = null;
+    const cleanup = () => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    };
+    try {
+      const combinedHead = deduplicateMetaTags([ctx.inlineStyleTag, ctx.head, ctx.extraHead].filter(Boolean).join(`
 `));
-    const headWithLangAndContent = ctx.headWithLang.replace(/<html([^>]*)>/i, `<html$1 lang="${ctx.pageLang}">`).replace(/<\/head>/i, `${combinedHead ? `${combinedHead}
+      const headWithLangAndContent = ctx.headWithLang.replace(/<html([^>]*)>/i, `<html$1 lang="${ctx.pageLang}">`).replace(/<\/head>/i, `${combinedHead ? `${combinedHead}
 ` : ""}</head>`);
-    const headContent = `${headWithLangAndContent}<body>`;
-    await writer.write(encoder.encode(headContent));
-    if (ctx.debug)
-      console.log(`[Stream] ${ctx.pathname} - first byte written: ${(performance.now() - t0).toFixed(2)}ms`);
-    await writer.write(encoder.encode(ctx.rootStart));
-    const componentWithPathname = cloneElement2(ctx.rootComponent, {
-      pathname: ctx.pathname,
-      searchParams: ctx.searchParams
-    });
-    let streamError = null;
-    const streamPromise = renderToReadableStream(componentWithPathname, {
-      onError(error) {
-        console.error("[reroute] SSR stream error:", error);
-        streamError = error instanceof Error ? error : new Error(String(error));
-      }
-    }).catch((err) => {
-      streamError = err;
-      throw err;
-    });
-    const reactStream = await streamPromise;
-    if (streamError)
-      throw streamError;
-    const streamTimeoutPromise = new Promise((resolve) => {
-      timeoutId = setTimeout(() => {
-        console.warn(`[reroute] Stream timeout after ${STREAM_TIMEOUT_MS}ms for ${ctx.pathname}, forcing close`);
-        streamTimedOut = true;
-        resolve({ done: true, value: undefined });
-      }, STREAM_TIMEOUT_MS);
-    });
-    const reader = reactStream.getReader();
-    while (true) {
-      const result = await Promise.race([reader.read(), streamTimeoutPromise]);
-      if (result.done || streamTimedOut) {
-        try {
-          reader.releaseLock();
-        } catch {}
-        break;
-      }
-      if (result.value) {
-        await writer.write(result.value);
-      }
+      const headContent = `${headWithLangAndContent}<body>`;
+      await writer.write(encoder.encode(headContent));
+      if (ctx.debug)
+        console.log(`[Stream] ${ctx.pathname} - first byte written: ${(performance.now() - t0).toFixed(2)}ms`);
+      await writer.write(encoder.encode(ctx.rootStart));
+      await withSpan("ssr.document.stream", async (span) => {
+        const componentWithPathname = cloneElement2(ctx.rootComponent, {
+          pathname: ctx.pathname,
+          searchParams: ctx.searchParams
+        });
+        span.setAttribute("reroute.pathname", ctx.pathname);
+        let streamError = null;
+        const streamPromise = renderToReadableStream(componentWithPathname, {
+          onError(error) {
+            console.error("[reroute] SSR stream error:", error);
+            streamError = error instanceof Error ? error : new Error(String(error));
+          }
+        }).catch((err) => {
+          streamError = err;
+          throw err;
+        });
+        const reactStream = await streamPromise;
+        if (streamError)
+          throw streamError;
+        const streamTimeoutPromise = new Promise((resolve) => {
+          timeoutId = setTimeout(() => {
+            console.warn(`[reroute] Stream timeout after ${STREAM_TIMEOUT_MS}ms for ${ctx.pathname}, forcing close`);
+            streamTimedOut = true;
+            resolve({ done: true, value: undefined });
+          }, STREAM_TIMEOUT_MS);
+        });
+        const reader = reactStream.getReader();
+        let chunkCount = 0;
+        while (true) {
+          const result = await Promise.race([
+            reader.read(),
+            streamTimeoutPromise
+          ]);
+          if (result.done || streamTimedOut) {
+            try {
+              reader.releaseLock();
+            } catch {}
+            break;
+          }
+          if (result.value) {
+            await writer.write(result.value);
+            chunkCount++;
+          }
+        }
+        cleanup();
+        span.setAttributes({
+          "reroute.stream.chunks": chunkCount,
+          "reroute.stream.timedOut": streamTimedOut
+        });
+      });
+      await writer.write(encoder.encode(ctx.rootEnd));
+      const allScripts = await withSpan("ssr.generate.scripts", async (span) => {
+        const scripts2 = buildStreamingScripts(ctx);
+        span.setAttribute("reroute.script_size", scripts2.length);
+        return scripts2;
+      });
+      await writer.write(encoder.encode(allScripts + ctx.htmlTail));
+      await writer.close();
+    } catch (error) {
+      cleanup();
+      console.error("[reroute] Stream error:", error);
+      try {
+        await writer.abort(error);
+      } catch {}
     }
-    cleanup();
-    await writer.write(encoder.encode(ctx.rootEnd));
-    const allScripts = buildStreamingScripts(ctx);
-    await writer.write(encoder.encode(allScripts + ctx.htmlTail));
-    await writer.close();
-  } catch (error) {
-    cleanup();
-    console.error("[reroute] Stream error:", error);
-    try {
-      await writer.abort(error);
-    } catch {}
-  }
+  });
 }
 function buildStreamingScripts(ctx) {
   const collectionScripts = generateCollectionScripts(ctx.byCollectionForSSR);
@@ -4358,7 +4647,7 @@ function buildStreamingScripts(ctx) {
       ssrDataSnapshot[key] = value;
     }
   }
-  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname);
+  const dataScript = createDataScript(ssrDataSnapshot, ctx.isWatchMode ? ctx.ssrError : undefined, ctx.pathname, ctx.browserTelemetryConfig);
   const feedsScript = createFeedsScript();
   const llmsScript = createLlmsScript();
   let allScripts = dataScript + feedsScript + llmsScript + collectionScripts + ctx.preloadHydrationScript;
@@ -4368,6 +4657,40 @@ function buildStreamingScripts(ctx) {
   }
   return allScripts;
 }
+var init_stream = __esm(() => {
+  init_server2();
+  init_config();
+  init_lib();
+  init_html();
+  init_imports();
+});
+
+// packages/core/src/ssr/index.ts
+var init_ssr = __esm(() => {
+  init_lib();
+  init_render();
+  init_stream();
+});
+
+// packages/core/src/index.ts
+var init_src = __esm(() => {
+  init_bundler();
+  init_config();
+  init_content();
+  init_llms();
+  init_og();
+  init_robots();
+  init_rss();
+  init_sitemap();
+  init_ssr();
+});
+
+// packages/core/index.ts
+var init_core = __esm(() => {
+  init_src();
+});
+init_core();
+
 export {
   toPromise,
   toBytes,
@@ -4475,4 +4798,4 @@ export {
   AI_CRAWLERS
 };
 
-//# debugId=32CE37F51F53B15F64756E2164756E21
+//# debugId=3D165410A6034F1E64756E2164756E21