Generate a sitemap on every build, with CMS support

I need you to set up automatic sitemap generation that runs on every build. Follow these steps exactly.

Step 0: Investigate my codebase silently before doing anything.
- Find my routes file (check App.tsx, router.tsx, routes.tsx, main.tsx)
- Detect my production domain from canonical links, meta tags, env vars, CNAME, or config files. Determine if it uses www or non-www.
- Search for any existing pattern that fetches dynamic content by slug from a CMS, database, or API (Supabase, Firebase, Sanity, Strapi, Contentful, Convex, Prisma, or raw fetch calls). Trace the client, endpoint, auth method, and response shape from the existing code.
- Identify private/protected routes (behind auth guards, inside dashboard or admin layouts)
- Only ask me if you cannot determine the domain or if a CMS/API key is not already in env vars.

Step 1: Run this command:
bun add -d @babel/parser @babel/traverse @types/babel__traverse

Step 2: Create the file src/lib/generate-sitemap.ts with exactly this code:

```ts
// Sitemap generation script
import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";
import * as parser from "@babel/parser";
import traverse, { NodePath } from "@babel/traverse";
import { JSXAttribute, JSXIdentifier, JSXOpeningElement } from "@babel/types";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// ———————————————
// CONFIGURATION
// ———————————————

const BASE_URL = "https://YOURDOMAIN.com";
const ROUTER_FILE_PATH = path.resolve(__dirname, "../App.tsx");
const OUTPUT_DIR = path.resolve(__dirname, "../../public");
const IGNORE_PATHS: string[] = ["/dashboard/*"];

// ———————————————
// SITEMAP SCRIPT
// ———————————————

const SITEMAP_PATH = path.join(OUTPUT_DIR, "sitemap.xml");

function getAttributeValue(
  astPath: NodePath<JSXOpeningElement>,
  attributeName: string
): string | null {
  const attribute = astPath.node.attributes.find(
    (attr): attr is JSXAttribute =>
      attr.type === "JSXAttribute" && attr.name.name === attributeName
  );
  if (!attribute) return null;
  const value = attribute.value;
  if (value?.type === "StringLiteral") return value.value;
  return null;
}

function joinPaths(paths: string[]): string {
  if (paths.length === 0) return "/";
  const joined = paths.join("/");
  const cleaned = ("/" + joined).replace(/\/+/g, "/");
  if (cleaned.length > 1 && cleaned.endsWith("/")) return cleaned.slice(0, -1);
  return cleaned;
}

function shouldIgnoreRoute(route: string): boolean {
  for (const ignorePattern of IGNORE_PATHS) {
    if (ignorePattern === route) return true;
    if (ignorePattern.endsWith("/*")) {
      const prefix = ignorePattern.slice(0, -2);
      if (route.startsWith(prefix + "/") || route === prefix) return true;
    }
  }
  return false;
}

function createSitemapXml(routes: string[]): string {
  const today = new Date().toISOString().split("T")[0];
  const urls = routes
    .map((route) => {
      const fullUrl = new URL(route, BASE_URL).href;
      return `
    <url>
      <loc>${fullUrl}</loc>
      <lastmod>${today}</lastmod>
      <changefreq>weekly</changefreq>
      <priority>0.8</priority>
    </url>`;
    })
    .join("");
  return `<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">${urls}
</urlset>
`;
}

async function generateSitemap() {
  console.log("Generating sitemap...");
  if (!BASE_URL.startsWith("http")) {
    console.error('Error: BASE_URL must be a full URL (e.g., "https://example.com")');
    process.exit(1);
  }
  const content = fs.readFileSync(ROUTER_FILE_PATH, "utf-8");
  const ast = parser.parse(content, {
    sourceType: "module",
    plugins: ["jsx", "typescript"],
  });
  const pathStack: string[] = [];
  const foundRoutes: string[] = [];
  traverse(ast, {
    JSXOpeningElement: {
      enter(astPath) {
        const nodeName = astPath.node.name as JSXIdentifier;
        if (nodeName.name !== "Route") return;
        const pathProp = getAttributeValue(astPath, "path");
        const hasElement = astPath.node.attributes.some(
          (attr) => attr.type === "JSXAttribute" && attr.name.name === "element"
        );
        if (pathProp) pathStack.push(pathProp);
        if (hasElement && pathProp) {
          const fullRoute = joinPaths(pathStack);
          foundRoutes.push(fullRoute);
        }
      },
      exit(astPath) {
        const nodeName = astPath.node.name as JSXIdentifier;
        if (nodeName.name !== "Route") return;
        const pathProp = getAttributeValue(astPath, "path");
        if (pathProp) pathStack.pop();
      },
    },
  });
  const staticRoutes = foundRoutes.filter(
    (route) => !route.includes(":") && !route.includes("*")
  );
  const filteredRoutes = staticRoutes.filter(
    (route) => !shouldIgnoreRoute(route)
  );
  console.log(`Found ${foundRoutes.length} total routes.`);
  console.log(`Filtered ${staticRoutes.length - filteredRoutes.length} ignored routes.`);
  console.log(`Final ${filteredRoutes.length} routes in sitemap.`);
  if (filteredRoutes.length > 0) console.log("Routes:", filteredRoutes.join(", "));
  const sitemapXml = createSitemapXml(filteredRoutes);
  if (!fs.existsSync(OUTPUT_DIR)) fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  fs.writeFileSync(SITEMAP_PATH, sitemapXml);
  console.log(`Sitemap successfully generated at ${SITEMAP_PATH}`);
}

generateSitemap().catch(console.error);
```

Now adapt ONLY the CONFIGURATION section at the top of this file:
- Set BASE_URL to the production domain you detected (with www or non-www based on what the codebase already uses). If you could not determine it, ask me.
- Set ROUTER_FILE_PATH to point to the routes file you found (e.g. "../router.tsx" or "../App.tsx").
- Set IGNORE_PATHS to include all private/protected routes you identified (e.g. "/dashboard/*", "/admin/*", "/settings/*", "/auth/*").
- If you found a CMS, database, or API integration that fetches dynamic content by slug, add a function called fetchDynamicRoutes() that reuses the same client/endpoint/auth pattern from the codebase to fetch all published slugs at build time. Call it in generateSitemap() between the "Filter out ignored paths" step and the "Generate the XML" step, prepend the correct URL prefix to each slug, and concat them into filteredRoutes.

Step 3: Add the following Vite plugin to vite.config.ts. Add the import at the top and sitemapPlugin() to the plugins array. Do not remove or change any existing plugins or config:

```ts
import { execSync } from "child_process";

function sitemapPlugin() {
  return {
    name: "sitemap-generator",
    buildEnd: () => {
      console.log("Running sitemap generator...");
      try {
        execSync("bun run src/lib/generate-sitemap.ts", { stdio: "inherit" });
      } catch (error) {
        console.error("Failed to generate sitemap:", error);
      }
    },
  };
}
```

Add sitemapPlugin() to the plugins array in defineConfig.

Step 4: Run bun run build and confirm the sitemap was generated at public/sitemap.xml. Show me its contents.