reroute-js 0.9.0 → 0.9.2

package/cli/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v0.9.0
+ * reroute-js v0.9.2
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -47,7 +47,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "0.9.0";
+    return "0.9.2";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -65,7 +65,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "a5db82d";
+    return "07fb920";
   }
   return "dev";
 }
@@ -77,7 +77,7 @@ __export(exports_init, {
   default: () => init
 });
 import { existsSync } from "node:fs";
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir } from "node:fs/promises";
 import { join } from "node:path";
 async function init(args) {
   const options = parseArgs(args);
@@ -199,13 +199,13 @@ async function copyTemplateFiles(templatePath, targetPath, variables) {
       await mkdir(destPath, { recursive: true });
       await copyTemplateFiles(sourcePath, destPath, variables);
     } else if (entry.isFile()) {
-      const content = await readFile(sourcePath, "utf-8");
+      const content = await Bun.file(sourcePath).text();
       let processedContent = content;
       for (const [key, value] of Object.entries(variables)) {
         const placeholder = `{{${key}}}`;
         processedContent = processedContent.split(placeholder).join(value);
       }
-      await writeFile(destPath, processedContent);
+      await Bun.write(destPath, processedContent);
     }
   }
 }
@@ -231,9 +231,9 @@ async function copySourceFiles(sourcePath, targetPath, variables) {
     if (entry.isDirectory()) {
       await copySourceFiles(sourceEntryPath, targetEntryPath, variables);
     } else if (entry.isFile()) {
-      const content = await readFile(sourceEntryPath, "utf-8");
+      const content = await Bun.file(sourceEntryPath).text();
       const processedContent = variables ? applyVariableReplacements(content, entry.name, variables) : content;
-      await writeFile(targetEntryPath, processedContent);
+      await Bun.write(targetEntryPath, processedContent);
     }
   }
 }
@@ -532,14 +532,27 @@ async function compileMdx(content, cwd, options = {}) {
     });
     return String(result);
   } catch (error) {
-    console.error("[reroute/mdx] Compilation failed:", error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const errorLocation = error && typeof error === "object" && "place" in error && error.place && typeof error.place === "object" ? `at line ${error.place.line || "?"}, column ${error.place.column || "?"}` : "";
+    const fileInfo = options.filename ? ` in ${options.filename}` : "";
+    console.warn(`[reroute/mdx] Compilation failed${fileInfo}${errorLocation ? ` ${errorLocation}` : ""}: ${errorMessage}`);
+    console.warn("[reroute/mdx] Falling back to react-markdown");
     return null;
   }
 }
 async function generateMarkdownModule(processed, cwd, options = {}) {
   const { frontmatter, content } = processed;
-  const { enableGfm = true, theme = "github-dark", isMdx = false } = options;
-  const compiledMdx = await compileMdx(content, cwd, { enableGfm, theme });
+  const {
+    enableGfm = true,
+    theme = "github-dark",
+    isMdx = false,
+    filename
+  } = options;
+  const compiledMdx = await compileMdx(content, cwd, {
+    enableGfm,
+    theme,
+    filename
+  });
   if (compiledMdx) {
     return `// Generated from ${isMdx ? "MDX" : "Markdown"} file with @mdx-js/mdx
 
@@ -557,7 +570,6 @@ export const ssr = {
 };
 `;
   }
-  console.warn("[reroute/mdx] MDX compile unavailable; falling back to react-markdown");
   const escapedContent = content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   const pluginImports = [];
   const remarkPluginsList = [];
@@ -659,20 +671,28 @@ import { spawn } from "node:child_process";
 import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
 import { join as join4 } from "node:path";
 function isTailwindAvailable(cwd) {
-  const packageJsonPath = join4(cwd, "package.json");
-  if (!existsSync4(packageJsonPath)) {
-    return false;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
-    const deps = {
-      ...packageJson.dependencies,
-      ...packageJson.devDependencies
-    };
-    return "@tailwindcss/cli" in deps;
-  } catch {
-    return false;
+  const pathsToTry = [
+    join4(cwd, "package.json"),
+    join4(cwd, "../package.json"),
+    join4(cwd, "../../package.json"),
+    join4(cwd, "../../../package.json")
+  ];
+  for (const packageJsonPath of pathsToTry) {
+    if (!existsSync4(packageJsonPath)) {
+      continue;
+    }
+    try {
+      const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if ("@tailwindcss/cli" in deps) {
+        return true;
+      }
+    } catch {}
   }
+  return false;
 }
 function getTailwindPaths(cwd) {
   const input = join4(cwd, "src/client/theme.css");
@@ -704,12 +724,16 @@ function resolveTailwindBin(cwd) {
   }
   return join4(cwd, "node_modules/.bin/tailwindcss");
 }
-async function buildTailwind(cwd) {
+async function buildTailwind(cwd, minify = false) {
   const { input, output } = getTailwindPaths(cwd);
   return new Promise((resolve, reject) => {
     const tailwindBin = resolveTailwindBin(cwd);
     const args = ["-i", input, "-o", output];
-    console.log(`[reroute/tailwind] build start: -i ${input} -o ${output}`);
+    if (minify) {
+      args.push("--minify");
+    }
+    const argsStr = args.join(" ");
+    console.log(`[reroute/tailwind] build start: ${argsStr}`);
     const tailwind = spawn(tailwindBin, args, {
       cwd,
       stdio: "pipe"
@@ -739,10 +763,10 @@ async function buildTailwind(cwd) {
     });
   });
 }
-async function buildTailwindIfConfigured(cwd) {
+async function buildTailwindIfConfigured(cwd, minify = false) {
   try {
     if (isTailwindAvailable(cwd) && hasTailwindInput(cwd)) {
-      await buildTailwind(cwd);
+      await buildTailwind(cwd, minify);
       return true;
     }
     return false;
@@ -759,16 +783,69 @@ __export(exports_gen, {
   default: () => gen
 });
 import { watch } from "node:fs";
-import { mkdir as mkdir2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir2, readdir as readdir2, rm } from "node:fs/promises";
 import { join as join5 } from "node:path";
 import { pathToFileURL } from "node:url";
-async function cleanupOutputDir(cwd) {
+async function ensureOutputDir(cwd) {
   try {
-    await rm(join5(cwd, OUTPUT_DIR), { force: true });
-    await mkdir2(join5(cwd, OUTPUT_DIR), { recursive: true });
-    console.log("[reroute/gen] Cleaned up generated artifacts in .reroute");
+    const outputPath = join5(cwd, OUTPUT_DIR);
+    let needsCleanup = false;
+    try {
+      const entries = await readdir2(outputPath);
+      needsCleanup = entries.length > 0;
+    } catch {}
+    if (needsCleanup) {
+      await rm(outputPath, { force: true, recursive: true });
+      console.log("[reroute/gen] Cleaned up generated artifacts in .reroute");
+    }
+    await mkdir2(outputPath, { recursive: true });
+    await mkdir2(join5(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+    await mkdir2(join5(cwd, ".reroute/bundles"), { recursive: true });
   } catch {}
 }
+async function writeStubFiles(cwd) {
+  const STUB_ROUTES = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
+// This will be replaced by actual routes
+/* eslint-disable */
+// @ts-nocheck
+
+export const layouts: any[] = [];
+export const notFoundRoutes: any[] = [];
+
+export function matchRoute(pathname: string): any {
+  return null;
+}
+
+export type RouteParams = Record<string, never>;
+`;
+  const STUB_CONTENT = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
+// This will be replaced by actual content
+/* eslint-disable */
+// @ts-nocheck
+
+export const contentRegistry: Record<string, any> = {};
+`;
+  const STUB_INDEX = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
+// This will be replaced by actual artifacts
+/* eslint-disable */
+// @ts-nocheck
+
+import { layouts, matchRoute, notFoundRoutes } from './routes';
+
+export const artifacts = {
+  layouts,
+  matchRoute,
+  notFoundRoutes,
+  contentBaseUrl: '/.reroute/collections'
+} as const;
+
+export type RerouteArtifacts = typeof artifacts;
+`;
+  await Bun.write(join5(cwd, OUTPUT_ROUTES), STUB_ROUTES);
+  await Bun.write(join5(cwd, OUTPUT_CONTENT_TS), STUB_CONTENT);
+  await Bun.write(join5(cwd, OUTPUT_INDEX), STUB_INDEX);
+  console.log("[reroute/gen] Initialized stub files");
+}
 async function scanDirectory(dir, base = "") {
   const files = [];
   const entries = await readdir2(dir, { withFileTypes: true });
@@ -880,10 +957,26 @@ function getImportPath(filePath) {
   return `../src/client/routes/${pathWithoutExt}`;
 }
 function generateTypeScript(tree) {
-  const imports = [
-    ...tree.routes.map((r, i) => `import Route${i} from '${getImportPath(r.filePath)}';`),
-    ...tree.layouts.map((l, i) => `import Layout${i} from '${getImportPath(l.filePath)}';`),
-    ...tree.notFoundRoutes.map((nf, i) => `import NotFound${i} from '${getImportPath(nf.filePath)}';`)
+  const helperImport = "import { createLazyRoute } from 'reroute-js/react';";
+  const eagerImports = [
+    ...tree.routes.map((r, i) => `import Route${i}Eager from '${getImportPath(r.filePath)}';`),
+    ...tree.layouts.map((l, i) => `import Layout${i}Eager from '${getImportPath(l.filePath)}';`),
+    ...tree.notFoundRoutes.map((nf, i) => `import NotFound${i}Eager from '${getImportPath(nf.filePath)}';`)
+  ].join(`
+`);
+  const lazyWrappers = [
+    ...tree.routes.map((r, i) => {
+      const importPath = getImportPath(r.filePath);
+      return `const Route${i} = createLazyRoute(Route${i}Eager, () => import('${importPath}'), "${r.pattern}");`;
+    }),
+    ...tree.layouts.map((l, i) => {
+      const importPath = getImportPath(l.filePath);
+      return `const Layout${i} = createLazyRoute(Layout${i}Eager, () => import('${importPath}'), "${l.pattern}");`;
+    }),
+    ...tree.notFoundRoutes.map((nf, i) => {
+      const importPath = getImportPath(nf.filePath);
+      return `const NotFound${i} = createLazyRoute(NotFound${i}Eager, () => import('${importPath}'), "${nf.notFoundBasePattern || "/"}");`;
+    })
   ].join(`
 `);
   const routesArray = tree.routes.map((r, i) => {
@@ -923,7 +1016,11 @@ function generateTypeScript(tree) {
 /* eslint-disable */
 // @ts-nocheck
 
-${imports}
+${helperImport}
+
+${eagerImports}
+
+${lazyWrappers}
 
 export const routes: RouteInfo = [
 ${routesArray}
@@ -1003,7 +1100,7 @@ async function sha8(text) {
     hex += b.toString(16).padStart(2, "0");
   return hex.slice(0, 8);
 }
-async function buildContentChunks(cwd) {
+async function buildContentChunks(cwd, args = []) {
   const routesRoot = join5(cwd, ROUTES_DIR);
   console.log(`[reroute/content] scan ${routesRoot}`);
   const collections = await readdir2(routesRoot, { withFileTypes: true });
@@ -1015,7 +1112,7 @@ async function buildContentChunks(cwd) {
     const contentDir = join5(routesRoot, collection, "content");
     console.log(`[reroute/content] collection ${collection} dir ${contentDir}`);
     const files = await listContentFiles(contentDir);
-    console.log(`[reroute/content] files ${files.join(",")}`);
+    console.log(`[reroute/content] files ${files.length}`);
     if (!files.length)
       continue;
     for (const file of files) {
@@ -1034,8 +1131,7 @@ async function buildContentChunks(cwd) {
       }
       let code = "";
       try {
-        console.log(`[reroute/content] build ${buildSrc}`);
-        const isProd = isProductionMode();
+        const isProd = isProductionMode(args);
         const result = await Bun.build({
           entrypoints: [buildSrc],
           target: "browser",
@@ -1055,19 +1151,17 @@ async function buildContentChunks(cwd) {
         continue;
       }
       const hash = await sha8(code);
-      const chunkRelDir = join5(".reroute", "chunks", collection);
+      const chunkRelDir = join5(".reroute", "bundles");
       const chunkAbsDir = join5(cwd, chunkRelDir);
-      const outFile = `${name}.${hash}.js`;
+      const outFile = `${collection}-${name}.${hash}.js`;
       const absOut = join5(chunkAbsDir, outFile);
-      await mkdir2(chunkAbsDir, { recursive: true });
       try {
         const exists = await Bun.file(absOut).exists();
         if (!exists)
-          await writeFile2(absOut, code, "utf-8");
+          await Bun.write(absOut, code);
       } catch {}
       let meta = {};
       try {
-        console.log(`[reroute/content] meta ${buildSrc}`);
         const url = `${pathToFileURL(buildSrc).href}?t=${Date.now()}`;
         const m = await import(url);
         meta = m.meta || {};
@@ -1077,7 +1171,7 @@ async function buildContentChunks(cwd) {
         name,
         slug: name,
         href: `/${collection}/${name}`,
-        moduleUrl: ("/" + chunkRelDir.replace(/\\/g, "/") + "/" + outFile).replace(/\\+/g, "/"),
+        moduleUrl: `/bundles/${outFile}`,
         meta
       });
     }
@@ -1108,12 +1202,10 @@ async function buildContentChunks(cwd) {
   lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
   lines.push("}");
   lines.push("");
-  await mkdir2(join5(cwd, ".reroute"), { recursive: true });
-  await writeFile2(join5(cwd, OUTPUT_CONTENT_TS), lines.join(`
-`), "utf-8");
+  await Bun.write(join5(cwd, OUTPUT_CONTENT_TS), lines.join(`
+`));
   console.log(`[reroute/content] wrote ${join5(cwd, OUTPUT_CONTENT_TS)}`);
   const collectionsSet = new Set(results.map((r) => r.collection));
-  await mkdir2(join5(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
   for (const collection of collectionsSet) {
     const items = results.filter((r) => r.collection === collection);
     const js = [];
@@ -1133,8 +1225,8 @@ async function buildContentChunks(cwd) {
     js.push("  return byName[name];");
     js.push("}");
     js.push("");
-    await writeFile2(join5(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
-`), "utf-8");
+    await Bun.write(join5(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
+`));
     console.log(`[reroute/content] wrote ${join5(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
   }
 }
@@ -1147,9 +1239,6 @@ async function preprocessMarkdownFiles(cwd) {
   } catch {}
   const markdownConfig = getMarkdownConfig(cwd);
   console.log("[reroute/markdown] Config:", markdownConfig);
-  try {
-    await mkdir2(markdownDir, { recursive: true });
-  } catch {}
   async function scanMarkdown(dir, base = "") {
     const files = [];
     try {
@@ -1161,7 +1250,6 @@ async function preprocessMarkdownFiles(cwd) {
           const nested = await scanMarkdown(fullPath, relativePath);
           files.push(...nested);
         } else if (entry.isFile() && isMarkdownFile(entry.name)) {
-          console.log(`[reroute/markdown] Found markdown file: ${relativePath}`);
           files.push(relativePath);
         }
       }
@@ -1172,13 +1260,12 @@ async function preprocessMarkdownFiles(cwd) {
   }
   console.log(`[reroute/markdown] Scanning ${routesPath} for markdown files...`);
   const markdownFiles = await scanMarkdown(routesPath);
-  console.log(`[reroute/markdown] Scan complete. Found files:`, markdownFiles);
+  console.log(`[reroute/markdown] Scan complete. Found files:`, markdownFiles.length);
   if (markdownFiles.length === 0) {
     console.log("[reroute/markdown] No markdown files found, skipping preprocessing");
     return;
   }
   console.log(`[reroute/markdown] Found ${markdownFiles.length} markdown file(s)`);
-  await mkdir2(markdownDir, { recursive: true });
   for (const file of markdownFiles) {
     const sourcePath = join5(routesPath, file);
     const targetPath = join5(markdownDir, file.replace(/\.mdx?$/, ".tsx"));
@@ -1190,25 +1277,94 @@ async function preprocessMarkdownFiles(cwd) {
         moduleCode = await generateMarkdownModule(processed, cwd, {
           enableGfm: markdownConfig.hasRemarkGfm,
           theme: "github-dark",
-          isMdx
+          isMdx,
+          filename: file
         });
       } else {
         moduleCode = generatePlainMarkdownModule(processed);
       }
-      const targetDir = join5(markdownDir, file.split("/").slice(0, -1).join("/"));
-      if (targetDir !== markdownDir) {
-        await mkdir2(targetDir, { recursive: true });
-      }
-      await writeFile2(targetPath, moduleCode, "utf-8");
-      console.log(`[reroute/markdown] Processed ${file} -> ${targetPath}`);
+      await Bun.write(targetPath, moduleCode);
     } catch (error) {
       console.error(`[reroute/markdown] Failed to process ${file}:`, error);
     }
   }
 }
-async function generate(cwd) {
+async function buildEntrypointBundle(cwd, args = []) {
+  const clientDir = join5(cwd, "src", "client");
+  const entrypoint = join5(clientDir, "index.tsx");
+  const exists = await Bun.file(entrypoint).exists();
+  if (!exists) {
+    console.log("[reroute/gen] No index.tsx found, skipping bundle build");
+    return;
+  }
+  console.log("[reroute/gen] Building entrypoint bundle with code splitting...");
+  const isProd = isProductionMode(args);
+  const result = await Bun.build({
+    entrypoints: [entrypoint],
+    target: "browser",
+    format: "esm",
+    splitting: true,
+    sourcemap: isProd ? "linked" : "external",
+    minify: isProd,
+    naming: {
+      entry: "[name].[hash].[ext]",
+      chunk: "chunk.[hash].[ext]",
+      asset: "[name].[hash].[ext]"
+    },
+    jsx: {
+      runtime: "automatic",
+      importSource: "react",
+      development: !isProd
+    },
+    define: {
+      "process.env.NODE_ENV": isProd ? '"production"' : '"development"',
+      __DEV__: isProd ? "false" : "true",
+      "import.meta.env.MODE": isProd ? '"production"' : '"development"'
+    },
+    ...isProd ? { drop: ["console", "debugger"] } : {}
+  });
+  if (!result.success) {
+    console.error("[reroute/gen] Entrypoint build failed:");
+    for (const log of result.logs)
+      console.error(log);
+    throw new Error("Failed to build entrypoint");
+  }
+  const bundlesDir = join5(cwd, ".reroute", "bundles");
+  try {
+    const existingFiles = await readdir2(bundlesDir);
+    for (const file of existingFiles) {
+      if (/^(index|chunk)\.[a-z0-9]+\.(js|js\.map)$/i.test(file)) {
+        await rm(join5(bundlesDir, file), { force: true });
+      }
+    }
+  } catch {}
+  const outputs = [];
+  let entryFile = "";
+  for (const output of result.outputs) {
+    const content = await output.text();
+    const fileName = output.path.split("/").pop() || output.path.split("\\").pop() || "unknown";
+    const destPath = join5(bundlesDir, fileName);
+    await Bun.write(destPath, content);
+    const isEntry = fileName.startsWith("index.") && fileName.endsWith(".js") && !fileName.endsWith(".map");
+    if (isEntry)
+      entryFile = fileName;
+    outputs.push({
+      fileName,
+      size: content.length,
+      isEntry
+    });
+  }
+  const totalSize = outputs.reduce((sum, o) => sum + o.size, 0);
+  const gzipped = Bun.gzipSync(new TextEncoder().encode(outputs.find((o) => o.isEntry)?.fileName ? await Bun.file(join5(bundlesDir, entryFile)).text() : "")).length;
+  console.log(`[reroute/gen] Built ${outputs.length} files (${(totalSize / 1024).toFixed(2)}KB, ${(gzipped / 1024).toFixed(2)}KB gzipped)`);
+  console.log(`[reroute/gen] Entry: ${entryFile}`);
+  console.log(`[reroute/gen] Chunks: ${outputs.filter((o) => !o.isEntry && o.fileName.endsWith(".js")).length}`);
+}
+async function generate(cwd, args = []) {
+  const startTime = performance.now();
   console.log("[reroute/gen] Starting generation...");
-  await cleanupOutputDir(cwd);
+  await ensureOutputDir(cwd);
+  await writeStubFiles(cwd);
   await preprocessMarkdownFiles(cwd);
   const routesPath = join5(cwd, ROUTES_DIR);
   try {
@@ -1217,15 +1373,14 @@ async function generate(cwd) {
     const all = Array.from(new Set([...files, ...nfFiles]));
     const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
     const ts = generateTypeScript(tree);
-    await mkdir2(join5(cwd, ".reroute"), { recursive: true });
-    await writeFile2(join5(cwd, OUTPUT_ROUTES), ts, "utf-8");
+    await Bun.write(join5(cwd, OUTPUT_ROUTES), ts);
     console.log(`[reroute/gen] Generated routes: ${join5(cwd, OUTPUT_ROUTES)}`);
   } catch (error) {
     console.error("[reroute/gen] Failed to generate routes:", error);
     throw error;
   }
   try {
-    await buildContentChunks(cwd);
+    await buildContentChunks(cwd, args);
     console.log(`[reroute/gen] Generated content: ${join5(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
   } catch (error) {
     console.error("[reroute/gen] Failed to generate content:", error);
@@ -1246,25 +1401,34 @@ async function generate(cwd) {
   indexLines.push("} as const;");
   indexLines.push("");
   indexLines.push("export type RerouteArtifacts = typeof artifacts;");
-  await writeFile2(join5(cwd, OUTPUT_INDEX), indexLines.join(`
-`), "utf-8");
+  await Bun.write(join5(cwd, OUTPUT_INDEX), indexLines.join(`
+`));
   console.log(`[reroute/gen] Generated index: ${join5(cwd, OUTPUT_INDEX)}`);
-  console.log("[reroute/gen] Generation complete");
+  try {
+    await buildEntrypointBundle(cwd, args);
+  } catch (error) {
+    console.error("[reroute/gen] Failed to build entrypoint:", error);
+    throw error;
+  }
+  const endTime = performance.now();
+  const duration = ((endTime - startTime) / 1000).toFixed(2);
+  console.log(`[reroute/gen] Generation complete in ${duration}s`);
 }
 async function gen(args) {
   const cwd = process.cwd();
   const watchMode = args.includes("--watch") || args.includes("-w");
+  const isProd = isProductionMode(args);
   if (!watchMode) {
-    await generate(cwd);
-    await buildTailwindIfConfigured(cwd);
+    await generate(cwd, args);
+    await buildTailwindIfConfigured(cwd, isProd);
     checkMarkdownIfConfigured(cwd);
     return;
   }
   console.log("[reroute/gen] Watch mode enabled");
   console.log("[reroute/gen] Initial generation...");
-  await generate(cwd);
+  await generate(cwd, args);
   try {
-    await buildTailwindIfConfigured(cwd);
+    await buildTailwindIfConfigured(cwd, isProd);
     checkMarkdownIfConfigured(cwd);
   } catch {}
   const notifyReload = async (reason) => {
@@ -1284,6 +1448,7 @@ async function gen(args) {
       } catch {}
     }
   };
+  await notifyReload("initial generation");
   const routesPath = join5(cwd, ROUTES_DIR);
   console.log(`[reroute/gen] Watching ${routesPath} for changes...`);
   let debounce = null;
@@ -1295,16 +1460,16 @@ async function gen(args) {
     debounce = setTimeout(async () => {
       console.log("[reroute/gen] Change detected, regenerating...");
       try {
-        await generate(cwd);
-        await buildTailwindIfConfigured(cwd);
+        await generate(cwd, args);
+        await buildTailwindIfConfigured(cwd, isProd);
         await notifyReload("routes change");
       } catch (e) {
         console.error("[reroute/gen] Error during regeneration:", e);
       }
-    }, 120);
+    }, 50);
   });
   const clientPath = join5(cwd, "src", "client");
-  console.log(`[reroute/gen] Watching ${clientPath} for Tailwind class changes...`);
+  console.log(`[reroute/gen] Watching ${clientPath} for changes...`);
   let twDebounce = null;
   const twWatcher = watch(clientPath, { recursive: true }, (_ev, filename) => {
     if (!filename)
@@ -1320,10 +1485,14 @@ async function gen(args) {
       clearTimeout(twDebounce);
     twDebounce = setTimeout(async () => {
       try {
-        await buildTailwindIfConfigured(cwd);
+        if (name === "index.tsx" || name.includes("components/") || name.includes("hooks/") || name.includes("providers/")) {
+          console.log("[reroute/gen] Client code changed, rebuilding bundle...");
+          await buildEntrypointBundle(cwd, args);
+        }
+        await buildTailwindIfConfigured(cwd, isProd);
         await notifyReload("client change");
       } catch {}
-    }, 150);
+    }, 100);
   });
   process.on("SIGINT", () => {
     console.log(`
@@ -1344,69 +1513,6 @@ var init_gen = __esm(() => {
   init_tailwind();
 });
 
-// packages/cli/src/commands/boot.ts
-var exports_boot = {};
-__export(exports_boot, {
-  default: () => boot
-});
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join6 } from "node:path";
-async function boot(_) {
-  const cwd = process.cwd();
-  try {
-    console.log("[reroute/boot] Initializing .reroute directory...");
-    await mkdir3(join6(cwd, OUTPUT_DIR2), { recursive: true });
-    await mkdir3(join6(cwd, OUTPUT_COLLECTIONS_DIR2), { recursive: true });
-    await writeFile3(join6(cwd, OUTPUT_ROUTES2), STUB_ROUTES, "utf-8");
-    console.log(`[reroute/boot] Created stub: ${OUTPUT_ROUTES2}`);
-    await writeFile3(join6(cwd, OUTPUT_CONTENT_TS2), STUB_CONTENT, "utf-8");
-    console.log(`[reroute/boot] Created stub: ${OUTPUT_CONTENT_TS2}`);
-    await writeFile3(join6(cwd, OUTPUT_INDEX2), STUB_INDEX, "utf-8");
-    console.log(`[reroute/boot] Created stub: ${OUTPUT_INDEX2}`);
-    console.log("[reroute/boot] Initialization complete");
-    console.log('[reroute/boot] Run "reroute gen" to generate actual routes and content.');
-  } catch (error) {
-    console.error("[reroute/boot] Failed to initialize:", error);
-    throw error;
-  }
-}
-var OUTPUT_DIR2 = ".reroute", OUTPUT_ROUTES2 = ".reroute/routes.ts", OUTPUT_CONTENT_TS2 = ".reroute/content.ts", OUTPUT_COLLECTIONS_DIR2 = ".reroute/collections", OUTPUT_INDEX2 = ".reroute/index.ts", STUB_ROUTES = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
-// Run 'reroute gen' to generate actual routes
-/* eslint-disable */
-// @ts-nocheck
-
-export const layouts: any[] = [];
-export const notFoundRoutes: any[] = [];
-
-export function matchRoute(pathname: string): any {
-  return null;
-}
-
-export type RouteParams = Record<string, never>;
-`, STUB_CONTENT = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
-// Run 'reroute gen' to generate actual content
-/* eslint-disable */
-// @ts-nocheck
-
-export const contentRegistry: Record<string, any> = {};
-`, STUB_INDEX = `// \uD83D\uDEA8 Auto-generated stub by Reroute - DO NOT EDIT \uD83D\uDEA8
-// Run 'reroute gen' to generate actual artifacts
-/* eslint-disable */
-// @ts-nocheck
-
-import { layouts, matchRoute, notFoundRoutes } from './routes';
-
-export const artifacts = {
-  layouts,
-  matchRoute,
-  notFoundRoutes,
-  contentBaseUrl: '/.reroute/collections'
-} as const;
-
-export type RerouteArtifacts = typeof artifacts;
-`;
-var init_boot = () => {};
-
 // packages/cli/src/libs/log.ts
 function colorizeLogPrefix(text) {
   let colored = text;
@@ -1447,7 +1553,6 @@ var init_log = __esm(() => {
     "[reroute/markdown]": "{yellow-fg}",
     "[reroute/tailwind]": "{red-fg}",
     "[reroute/mdx]": "{bright-red-fg}",
-    "[reroute/boot]": "{bright-yellow-fg}",
     "[reroute/dev]": "{green-fg}",
     "[reroute/start]": "{bright-cyan-fg}",
     "[reroute/build]": "{bright-magenta-fg}",
@@ -1457,6 +1562,24 @@ var init_log = __esm(() => {
   };
 });
 
+// packages/cli/src/libs/server.ts
+async function waitForServerReady(port = 3000, timeout = 1e4) {
+  const startTime = Date.now();
+  const checkInterval = 200;
+  while (Date.now() - startTime < timeout) {
+    try {
+      const response = await fetch(`http://localhost:${port}/`, {
+        method: "GET"
+      });
+      if (response.status < 500) {
+        return;
+      }
+    } catch {}
+    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+  }
+  throw new Error(`Timeout waiting for server to respond after ${timeout}ms`);
+}
+
 // packages/cli/src/commands/dev.ts
 var exports_dev = {};
 __export(exports_dev, {
@@ -1464,19 +1587,65 @@ __export(exports_dev, {
 });
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync5 } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join6 } from "node:path";
+async function waitForRequiredFiles(cwd, timeout = 30000) {
+  const requiredFiles = [
+    join6(cwd, ".reroute/routes.ts"),
+    join6(cwd, ".reroute/content.ts"),
+    join6(cwd, ".reroute/index.ts")
+  ];
+  const bundlesDir = join6(cwd, ".reroute/bundles");
+  const startTime = Date.now();
+  const checkInterval = 100;
+  while (Date.now() - startTime < timeout) {
+    const allFilesExist = requiredFiles.every((file) => existsSync5(file));
+    if (!allFilesExist) {
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      continue;
+    }
+    if (existsSync5(bundlesDir)) {
+      const { readdirSync, statSync } = __require("node:fs");
+      try {
+        const files = readdirSync(bundlesDir);
+        const indexBundleFile = files.find((f) => {
+          if (!f.startsWith("index.") || !f.endsWith(".js") || f.endsWith(".map")) {
+            return false;
+          }
+          try {
+            const filePath = join6(bundlesDir, f);
+            const stats = statSync(filePath);
+            return stats.size > 100;
+          } catch {
+            return false;
+          }
+        });
+        if (indexBundleFile) {
+          const filePath = join6(bundlesDir, indexBundleFile);
+          const size1 = statSync(filePath).size;
+          await new Promise((resolve) => setTimeout(resolve, 200));
+          const size2 = statSync(filePath).size;
+          if (size1 === size2 && size2 > 100) {
+            return;
+          }
+        }
+      } catch {}
+    }
+    await new Promise((resolve) => setTimeout(resolve, checkInterval));
+  }
+  throw new Error(`Timeout waiting for required files to be created after ${timeout}ms`);
+}
 function getRerouteCommand() {
-  const binPath = join7(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join6(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync5(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join7(cwd, "node_modules", ".bin", "reroute"),
-    join7(cwd, "..", "node_modules", ".bin", "reroute"),
-    join7(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join7(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join6(cwd, "node_modules", ".bin", "reroute"),
+    join6(cwd, "..", "node_modules", ".bin", "reroute"),
+    join6(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join6(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync5(binPath2)) {
@@ -1488,10 +1657,6 @@ function getRerouteCommand() {
 async function dev(args) {
   const singleColumn = args.includes("--single") || args.includes("-s");
   try {
-    console.log("[reroute/dev] Running boot...");
-    await boot([]);
-    console.log(`[reroute/dev] Boot complete
-`);
     console.log("[reroute/dev] Starting development servers...");
     console.log(`[reroute/dev] Press Ctrl+C to stop
 `);
@@ -1503,9 +1668,27 @@ async function dev(args) {
       stdio: ["ignore", "pipe", "pipe"],
       shell: useShell
     });
+    console.log("[reroute/dev] Generating bundle...");
+    try {
+      await waitForRequiredFiles(process.cwd());
+    } catch (error) {
+      console.error("[reroute/dev] Failed to initialize:", error);
+      genProcess.kill();
+      process.exit(1);
+    }
     const serverProcess = spawn2("bun", ["--watch", "src/index.ts"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
+    console.log("[reroute/dev] Bundle complete, waiting for server...");
+    const port = Number(process.env.PORT || "3000");
+    try {
+      await waitForServerReady(port);
+    } catch (error) {
+      console.error("[reroute/dev] Server failed to start:", error);
+      genProcess.kill();
+      serverProcess.kill();
+      process.exit(1);
+    }
     if (singleColumn) {
       const genBuffer = { current: "" };
       const serverBuffer = { current: "" };
@@ -1751,7 +1934,6 @@ async function dev(args) {
 }
 var init_dev = __esm(() => {
   init_log();
-  init_boot();
 });
 
 // packages/cli/src/commands/start.ts
@@ -1761,19 +1943,19 @@ __export(exports_start, {
 });
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import { join as join8 } from "node:path";
+import { join as join7 } from "node:path";
 function getRerouteCommand2() {
-  const binPath = join8(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join7(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync6(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join8(cwd, "node_modules", ".bin", "reroute"),
-    join8(cwd, "..", "node_modules", ".bin", "reroute"),
-    join8(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join8(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join7(cwd, "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join7(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync6(binPath2)) {
@@ -1786,21 +1968,7 @@ async function start(_args) {
   try {
     const rerouteCmd = getRerouteCommand2();
     const useShell = rerouteCmd.includes(" ");
-    const bootBuffer = { current: "" };
     const genBuffer = { current: "" };
-    const handleBootOutput = (data) => {
-      const text = bootBuffer.current + data.toString();
-      const lines = text.split(`
-`);
-      bootBuffer.current = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) {
-          continue;
-        }
-        const ansiColored = colorizeLogPrefixAnsi(line);
-        console.log(ansiColored);
-      }
-    };
     const handleGenOutput = (data) => {
       const text = genBuffer.current + data.toString();
       const lines = text.split(`
@@ -1814,34 +1982,10 @@ async function start(_args) {
         console.log(ansiColored);
       }
     };
-    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Running boot...")}
-`);
-    const bootCommand = useShell ? `${rerouteCmd} boot` : rerouteCmd;
-    const bootArgs = useShell ? [] : ["boot"];
-    await new Promise((resolve, reject) => {
-      const bootProcess = spawn3(bootCommand, bootArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-        shell: useShell
-      });
-      bootProcess.stdout?.on("data", handleBootOutput);
-      bootProcess.stderr?.on("data", handleBootOutput);
-      bootProcess.on("exit", (code) => {
-        if (code !== null && code !== 0) {
-          reject(new Error(`Boot exited with code ${code}`));
-        } else {
-          resolve();
-        }
-      });
-      bootProcess.on("error", (error) => {
-        reject(error);
-      });
-    });
-    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Boot complete
-`));
     process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Running gen...")}
 `);
-    const genCommand = useShell ? `${rerouteCmd} gen` : rerouteCmd;
-    const genArgs = useShell ? [] : ["gen"];
+    const genCommand = useShell ? `${rerouteCmd} gen --prod` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen", "--prod"];
     await new Promise((resolve, reject) => {
       const genProcess = spawn3(genCommand, genArgs, {
         stdio: ["ignore", "pipe", "pipe"],
@@ -1864,8 +2008,6 @@ async function start(_args) {
 `));
     process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/start] Starting server...")}
 `);
-    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Press Ctrl+C to stop
-`));
     const serverProcess = spawn3("bun", ["src/index.ts"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -1873,6 +2015,19 @@ async function start(_args) {
     const handleServerOutput = createServerOutputHandler(serverBuffer);
     serverProcess.stdout?.on("data", handleServerOutput);
     serverProcess.stderr?.on("data", handleServerOutput);
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Waiting for server to be ready...
+`));
+    const port = Number(process.env.PORT || "3000");
+    try {
+      await waitForServerReady(port, 1e4);
+      process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Server is ready!
+`));
+    } catch {
+      process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] \uD83D\uDEA8Warning: Server may not be fully ready yet
+`));
+    }
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Press Ctrl+C to stop
+`));
     process.on("SIGINT", () => {
       process.stdout.write(`${colorizeLogPrefixAnsi(`
 [reroute/start] Shutting down...`)}
@@ -1916,19 +2071,19 @@ __export(exports_build, {
 });
 import { spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync4 } from "node:fs";
-import { join as join9 } from "node:path";
+import { join as join8 } from "node:path";
 function getRerouteCommand3() {
-  const binPath = join9(import.meta.dir, "..", "..", "bin.ts");
+  const binPath = join8(import.meta.dir, "..", "..", "bin.ts");
   const isBunDev = existsSync7(binPath);
   if (isBunDev) {
     return `bun ${binPath}`;
   }
   const cwd = process.cwd();
   const nodeModulesPaths = [
-    join9(cwd, "node_modules", ".bin", "reroute"),
-    join9(cwd, "..", "node_modules", ".bin", "reroute"),
-    join9(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join9(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+    join8(cwd, "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join8(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
   ];
   for (const binPath2 of nodeModulesPaths) {
     if (existsSync7(binPath2)) {
@@ -1939,7 +2094,7 @@ function getRerouteCommand3() {
 }
 function getOutputName() {
   const cwd = process.cwd();
-  const packageJsonPath = join9(cwd, "package.json");
+  const packageJsonPath = join8(cwd, "package.json");
   if (existsSync7(packageJsonPath)) {
     try {
       const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
@@ -1966,21 +2121,7 @@ async function build(args) {
     if (outfileArgIndex !== -1 && args[outfileArgIndex + 1]) {
       outputPath = args[outfileArgIndex + 1];
     }
-    const bootBuffer = { current: "" };
     const genBuffer = { current: "" };
-    const handleBootOutput = (data) => {
-      const text = bootBuffer.current + data.toString();
-      const lines = text.split(`
-`);
-      bootBuffer.current = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) {
-          continue;
-        }
-        const ansiColored = colorizeLogPrefixAnsi(line);
-        console.log(ansiColored);
-      }
-    };
     const handleGenOutput = (data) => {
       const text = genBuffer.current + data.toString();
       const lines = text.split(`
@@ -1994,34 +2135,10 @@ async function build(args) {
         console.log(ansiColored);
       }
     };
-    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running boot...")}
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running gen --prod...")}
 `);
-    const bootCommand = useShell ? `${rerouteCmd} boot` : rerouteCmd;
-    const bootArgs = useShell ? [] : ["boot"];
-    await new Promise((resolve, reject) => {
-      const bootProcess = spawn4(bootCommand, bootArgs, {
-        stdio: ["ignore", "pipe", "pipe"],
-        shell: useShell
-      });
-      bootProcess.stdout?.on("data", handleBootOutput);
-      bootProcess.stderr?.on("data", handleBootOutput);
-      bootProcess.on("exit", (code) => {
-        if (code !== null && code !== 0) {
-          reject(new Error(`Boot exited with code ${code}`));
-        } else {
-          resolve();
-        }
-      });
-      bootProcess.on("error", (error) => {
-        reject(error);
-      });
-    });
-    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Boot complete
-`));
-    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running gen...")}
-`);
-    const genCommand = useShell ? `${rerouteCmd} gen` : rerouteCmd;
-    const genArgs = useShell ? [] : ["gen"];
+    const genCommand = useShell ? `${rerouteCmd} gen --prod` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen", "--prod"];
     await new Promise((resolve, reject) => {
       const genProcess = spawn4(genCommand, genArgs, {
         stdio: ["ignore", "pipe", "pipe"],
@@ -2095,59 +2212,11 @@ async function generateContentHash(content) {
   return hex.slice(0, 8);
 }
 
-// packages/cli/src/libs/command.ts
-var exports_command = {};
-__export(exports_command, {
-  getRerouteCommand: () => getRerouteCommand4
-});
-import { existsSync as existsSync8 } from "node:fs";
-import { join as join10 } from "node:path";
-function getRerouteCommand4() {
-  const binPath = join10(import.meta.dir, "..", "..", "bin.ts");
-  const isBunDev = existsSync8(binPath);
-  if (isBunDev) {
-    return `bun ${binPath}`;
-  }
-  const cwd = process.cwd();
-  const nodeModulesPaths = [
-    join10(cwd, "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "..", "node_modules", ".bin", "reroute"),
-    join10(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
-  ];
-  for (const binPath2 of nodeModulesPaths) {
-    if (existsSync8(binPath2)) {
-      return binPath2;
-    }
-  }
-  return "reroute";
-}
-var init_command = () => {};
-
-// packages/cli/src/libs/index.ts
-var init_libs = __esm(() => {
-  init_command();
-  init_log();
-  init_markdown();
-  init_markdown_processor();
-  init_tailwind();
-});
-
-// packages/cli/index.ts
-var init_cli = __esm(() => {
-  init_libs();
-});
+// packages/core/src/bundler/index.ts
+var init_bundler = () => {};
 
 // packages/core/src/utils/path.ts
-var exports_path = {};
-__export(exports_path, {
-  stripStart: () => stripStart,
-  stripEnd: () => stripEnd,
-  join: () => join11,
-  extname: () => extname2,
-  basename: () => basename2
-});
-function join11(...parts) {
+function join9(...parts) {
   return parts.join("/").replace(/\/+/g, "/");
 }
 function extname2(p) {
@@ -2165,178 +2234,60 @@ function stripEnd(p, ch) {
   return p.endsWith(ch) ? p.slice(0, -ch.length) : p;
 }
 
-// packages/core/src/bundler/transpile.ts
-function isWatchMode() {
-  try {
-    return Array.isArray(process.execArgv) && process.execArgv.includes("--watch") || Array.isArray(process.argv) && process.argv.includes("--watch");
-  } catch {
-    return false;
-  }
-}
-async function transpileFile(filePath, originalPath, options, bundleCache) {
-  const src = await Bun.file(filePath).text();
-  const cacheKey = `${filePath}-${await generateContentHash(src)}`;
-  if (bundleCache.has(cacheKey)) {
-    return bundleCache.get(cacheKey);
-  }
-  console.log(`[reroute] Building ${originalPath}${options.minify ? " (minified)" : ""}...`);
+// packages/core/src/content/discovery.ts
+import { readdir as readdir3, stat } from "node:fs/promises";
+async function listContentFiles2(dir, baseRel) {
+  const out = [];
   try {
-    if (isWatchMode()) {
-      const cwd = typeof process !== "undefined" && process.cwd ? process.cwd() : "";
-      if (cwd) {
-        await buildTailwindIfConfigured(cwd);
+    const entries = await readdir3(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join9(dir, entry.name);
+      const rel = join9(baseRel, entry.name);
+      if (entry.isDirectory()) {
+        const nested = await listContentFiles2(full, rel);
+        out.push(...nested);
+      } else if (entry.isFile()) {
+        if (/\.(tsx|ts)$/.test(entry.name) && !entry.name.startsWith("_")) {
+          out.push(rel);
+        }
       }
     }
-  } catch (e) {
-    console.warn("[reroute/tailwind] rebuild failed:", e);
-  }
-  async function doBuild(sm) {
-    return await Bun.build({
-      entrypoints: [filePath],
-      target: "browser",
-      format: "esm",
-      minify: options.minify,
-      splitting: true,
-      sourcemap: sm,
-      jsx: {
-        runtime: "automatic",
-        importSource: "react",
-        development: !options.minify
-      },
-      define: {
-        "process.env.NODE_ENV": options.minify ? '"production"' : '"development"',
-        __DEV__: options.minify ? "false" : "true",
-        "import.meta.env.MODE": options.minify ? '"production"' : '"development"'
-      },
-      ...options.minify ? { drop: ["console", "debugger"] } : {}
-    });
-  }
-  let result;
+  } catch {}
+  return out;
+}
+async function discoverCollections(clientDir) {
+  const root = join9(clientDir, "routes");
+  const collections = new Set;
   try {
-    result = await doBuild(options.sourcemap ? "external" : "none");
-  } catch (error) {
-    console.warn(`[reroute] Build errored for ${originalPath} (sourcemap external). Retrying without sourcemap...`, error);
-    result = await doBuild("none");
-  }
-  if (!result.success) {
-    console.error(`[reroute] Failed to build ${filePath}`);
-    for (const log2 of result.logs)
-      console.error(log2);
-    throw new Error(`Failed to transpile ${filePath}`);
-  }
-  const outputs = await Promise.all(result.outputs.map(async (o) => ({
-    path: o.path,
-    text: await o.text()
-  })));
-  const entryBase = basename2(originalPath, extname2(originalPath));
-  let entry = outputs.find((o) => o.path.endsWith(`${entryBase}.js`));
-  if (!entry) {
-    entry = outputs.filter((o) => o.path.endsWith(".js")).sort((a, b) => b.text.length - a.text.length)[0];
-  }
-  if (!entry) {
-    throw new Error(`[reroute] No JS output generated for ${originalPath}`);
-  }
-  const code = entry.text;
-  let sourceMap;
-  if (options.sourcemap && result.outputs.length > 1) {
-    const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
-    if (mapOutput) {
-      sourceMap = await mapOutput.text();
-    }
-  }
-  const contentHash = await generateContentHash(code);
-  const chunks = outputs.filter((o) => o !== entry && o.path.endsWith(".js")).map((o) => ({
-    fileName: basename2(o.path),
-    code: o.text,
-    hash: "",
-    isEntry: false,
-    imports: []
-  }));
-  for (const c of chunks) {
-    c.hash = await generateContentHash(c.code);
-    try {
-      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
-      const matches = [...code.matchAll(re)];
-      if (matches.length) {
-        c.isEntry = false;
+    const entries = await readdir3(root, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const contentDir = join9(root, entry.name, "content");
+        try {
+          await stat(contentDir);
+          collections.add(entry.name);
+        } catch {}
       }
-    } catch {}
-  }
-  const staticDepNames = [];
-  try {
-    for (const c of chunks) {
-      const bn = c.fileName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`["'\`]((?:\\./)?${bn})["'\`]`, "g");
-      if (re.test(code))
-        staticDepNames.push(c.fileName);
     }
   } catch {}
-  const bundleInfo = {
-    hash: contentHash,
-    code,
-    sourceMap,
-    chunks
-  };
-  bundleCache.set(cacheKey, bundleInfo);
-  const sizeKB = (code.length / 1024).toFixed(2);
-  const gzippedSize = Bun.gzipSync(new TextEncoder().encode(code)).length;
-  const gzippedKB = (gzippedSize / 1024).toFixed(2);
-  console.log(`[reroute] Built ${originalPath} -> ${sizeKB} KB (${gzippedKB} KB gzipped)`);
-  return bundleInfo;
-}
-async function getBundleUrlsFor(modules, clientDir, prefix, options, bundleCache) {
-  const mods = Array.isArray(modules) ? modules : [modules];
-  const urls = [];
-  const { join: join12 } = await Promise.resolve().then(() => exports_path);
-  for (const mod of mods) {
-    const rel = mod.replace(/^\.\//, "");
-    const fullPath = join12(clientDir, rel);
-    try {
-      const bundleInfo = await transpileFile(fullPath, rel, options, bundleCache);
-      const base = basename2(rel, extname2(rel));
-      const entryUrl = `${prefix}/${base}.${bundleInfo.hash}.js`;
-      urls.push(entryUrl);
-      try {
-        const depNames = Array.isArray(bundleInfo.chunks) ? bundleInfo.chunks.map((c) => c.fileName).filter((name) => new RegExp(`["'\`]((?:\\./)?${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})["'\`]`, "g").test(bundleInfo.code)) : [];
-        const depUrls = depNames.map((n) => `${prefix}/${n}`.replace(/\/+/g, "/"));
-        entryUrlToStaticDeps.set(entryUrl, depUrls);
-      } catch {}
-    } catch (error) {
-      console.error(`[reroute] Error getting bundle URL for ${rel}:`, error);
-      urls.push(`${prefix}/${rel}`);
-    }
-  }
-  return urls;
-}
-function getStaticDepsForUrl(entryUrl) {
-  return entryUrlToStaticDeps.get(entryUrl) || [];
+  return Array.from(collections);
 }
-var entryUrlToStaticDeps;
-var init_transpile = __esm(() => {
-  init_cli();
-  entryUrlToStaticDeps = new Map;
-});
-
-// packages/core/src/bundler/index.ts
-var init_bundler = __esm(() => {
-  init_transpile();
-});
+var init_discovery = () => {};
 
 // packages/core/src/content/metadata.ts
-import { stat } from "node:fs/promises";
+import { stat as stat2 } from "node:fs/promises";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-async function getContentMeta(absPath, isWatchMode2) {
+async function getContentMeta(absPath, isWatchMode) {
   try {
     const url = pathToFileURL2(absPath).href;
-    const mod = await import(`${url}${isWatchMode2 ? `?t=${Date.now()}` : ""}`);
+    const mod = await import(`${url}${isWatchMode ? `?t=${Date.now()}` : ""}`);
     const meta = mod.meta || mod.frontmatter || {};
     if (meta && typeof meta === "object")
       return meta;
     return {};
   } catch {
     try {
-      const s = await stat(absPath);
+      const s = await stat2(absPath);
       return { date: new Date(s.mtimeMs).toISOString() };
     } catch {
       return {};
@@ -2362,94 +2313,16 @@ function escapeHtml(input) {
 }
 var init_metadata = () => {};
 
-// packages/core/src/content/discovery.ts
-import { readdir as readdir3, stat as stat2 } from "node:fs/promises";
-async function listContentFiles2(dir, baseRel) {
-  const out = [];
-  try {
-    const entries = await readdir3(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const full = join11(dir, entry.name);
-      const rel = join11(baseRel, entry.name);
-      if (entry.isDirectory()) {
-        const nested = await listContentFiles2(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 buildContentDTOs(collectionPath, clientDir, prefix, isWatchMode2) {
-  const normalized = stripStart(stripEnd(collectionPath, "/"), "/");
-  const contentRelDir = join11("routes", normalized, "content");
-  const contentAbsDir = join11(clientDir, contentRelDir);
-  const files = await listContentFiles2(contentAbsDir, "");
-  const items = [];
-  for (const rel of files) {
-    const fullRelPath = join11(contentRelDir, rel);
-    const absPath = join11(clientDir, fullRelPath);
-    const noExt = rel.replace(/\.(tsx|ts)$/, "");
-    const name = basename2(noExt);
-    const moduleUrl = `${prefix}/${fullRelPath}`.replace(/\/+/g, "/");
-    const meta = await getContentMeta(absPath, isWatchMode2);
-    const href = `/${normalized}/${name}`.replace(/\\+/g, "/");
-    items.push({
-      slug: noExt,
-      name,
-      path: fullRelPath,
-      module: moduleUrl,
-      meta,
-      href
-    });
-  }
-  return items;
-}
-async function discoverCollections(clientDir) {
-  const root = join11(clientDir, "routes");
-  const collections = new Set;
-  try {
-    const entries = await readdir3(root, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const contentDir = join11(root, entry.name, "content");
-        try {
-          await stat2(contentDir);
-          collections.add(entry.name);
-        } catch {}
-      }
-    }
-  } catch {}
-  return Array.from(collections);
-}
-var init_discovery = __esm(() => {
-  init_metadata();
-});
-
-// packages/core/src/content/registry.ts
-async function generateContentRegistry(cwd) {
-  try {
-    const p = join11(cwd, ".reroute", "content.ts");
-    const exists = await Bun.file(p).exists();
-    console.log(exists ? "[reroute] Content registry up-to-date" : "[reroute] Warning: .reroute/content.ts not found");
-  } catch {}
-}
-var init_registry = () => {};
-
 // packages/core/src/content/index.ts
 var init_content = __esm(() => {
   init_discovery();
   init_metadata();
-  init_registry();
 });
 
 // packages/core/src/ssr/modules.ts
 import { readdir as readdir4, stat as stat3 } from "node:fs/promises";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
-async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length < 2)
@@ -2457,20 +2330,20 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
     const collection = parts[0];
     const name = parts[1];
     try {
-      const registryPath = join11(cwd, ".reroute", "content.ts");
-      const reg = await import(pathToFileURL3(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const registryPath = join9(cwd, ".reroute", "content.ts");
+      const reg = await import(pathToFileURL3(registryPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
       const get = reg?.getContentEntry;
       const entry = typeof get === "function" ? get(collection, name) : undefined;
       const moduleUrl = entry?.module;
       if (moduleUrl?.endsWith(".js")) {
-        const abs = join11(cwd, moduleUrl.replace(/^\//, ""));
-        const href = pathToFileURL3(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const abs = join9(cwd, moduleUrl.replace(/^\//, ""));
+        const href = pathToFileURL3(abs).href + (isWatchMode ? `?t=${Date.now()}` : "");
         const mod = await import(href);
         return mod;
       }
     } catch {}
     try {
-      const chunkDir = join11(cwd, ".reroute", "chunks", collection);
+      const chunkDir = join9(cwd, ".reroute", "chunks", collection);
       const files = await readdir4(chunkDir);
       const matches = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
       if (matches.length) {
@@ -2478,22 +2351,22 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
         let latestM = 0;
         for (const f of matches) {
           try {
-            const s = await stat3(join11(chunkDir, f));
+            const s = await stat3(join9(chunkDir, f));
             if (s.mtimeMs >= latestM) {
               latestM = s.mtimeMs;
               latest = f;
             }
           } catch {}
         }
-        const absChunk = join11(chunkDir, latest);
-        const href = pathToFileURL3(absChunk).href + (isWatchMode2 ? `?t=${Date.now()}` : "");
+        const absChunk = join9(chunkDir, latest);
+        const href = pathToFileURL3(absChunk).href + (isWatchMode ? `?t=${Date.now()}` : "");
         const mod = await import(href);
         return mod;
       }
     } catch {}
     try {
-      const srcTsx = join11(clientDir, "routes", collection, "content", `${name}.tsx`);
-      const srcTs = join11(clientDir, "routes", collection, "content", `${name}.ts`);
+      const srcTsx = join9(clientDir, "routes", collection, "content", `${name}.tsx`);
+      const srcTs = join9(clientDir, "routes", collection, "content", `${name}.ts`);
       let absSrc = null;
       if (await Bun.file(srcTsx).exists())
         absSrc = srcTsx;
@@ -2501,7 +2374,7 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
         absSrc = srcTs;
       if (absSrc) {
         const href = pathToFileURL3(absSrc).href;
-        const mod = await (isWatchMode2 ? import(`${href}?t=${Date.now()}`) : import(href));
+        const mod = await (isWatchMode ? import(`${href}?t=${Date.now()}`) : import(href));
         return mod;
       }
     } catch {}
@@ -2511,7 +2384,7 @@ async function importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2
 var init_modules = () => {};
 
 // packages/core/src/ssr/seed.ts
-async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
+async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode) {
   try {
     const parts = pathname.split("/").filter(Boolean);
     if (parts.length < 2)
@@ -2519,7 +2392,7 @@ async function seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2) {
     const collection = parts[0];
     const name = parts[1];
     const key = `${collection}:${name}`;
-    const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+    const mod = await importContentModuleForPath(pathname, clientDir, cwd, isWatchMode);
     if (!mod)
       return;
     const C = mod.default || mod;
@@ -2543,9 +2416,9 @@ var init_seed = __esm(() => {
 // packages/core/src/ssr/data.ts
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 async function computeSSRDataForPath(params) {
-  const { pathname, clientDir, cwd, isWatchMode: isWatchMode2 } = params;
+  const { pathname, clientDir, cwd, isWatchMode } = params;
   try {
-    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+    await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
   } catch {}
   try {
     const parts = pathname.split("/").filter(Boolean);
@@ -2560,15 +2433,15 @@ async function computeSSRDataForPath(params) {
     }
   } catch {}
   try {
-    const routesPath = join11(cwd, ".reroute", "routes.ts");
-    const m = await import(pathToFileURL4(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const routesPath = join9(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL4(routesPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
     const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
     const r = match?.route;
     const paramsValue = match?.params || {};
     if (r && typeof r.path === "string") {
       try {
-        const abs = join11(clientDir, "routes", String(r.path));
-        const mod = await import(pathToFileURL4(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const abs = join9(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL4(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const ssr = mod?.ssr;
         const dataFn = ssr?.data;
         if (typeof dataFn === "function") {
@@ -2583,7 +2456,7 @@ var init_data = __esm(() => {
   init_seed();
 });
 
-// node_modules/dedent/dist/dedent.mjs
+// node_modules/.bun/dedent@1.7.0/node_modules/dedent/dist/dedent.mjs
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
   if (Object.getOwnPropertySymbols) {
@@ -2704,7 +2577,7 @@ var init_dedent = __esm(() => {
 
 // packages/core/src/template/html.ts
 async function loadIndexHtml(clientDir) {
-  const templatePath = join11(clientDir, "index.html");
+  const templatePath = join9(clientDir, "index.html");
   try {
     const content = await Bun.file(templatePath).text();
     return content;
@@ -2792,7 +2665,7 @@ async function renderSSRDocument(options) {
     rootComponent,
     clientDir,
     cwd,
-    isWatchMode: isWatchMode2,
+    isWatchMode,
     bundleUrl,
     head = "",
     lang = "en",
@@ -2808,15 +2681,6 @@ async function renderSSRDocument(options) {
 <link rel="modulepreload" href="${bundleUrl}" />`;
     }
   } catch {}
-  try {
-    const staticDeps = getStaticDepsForUrl(bundleUrl);
-    if (Array.isArray(staticDeps) && staticDeps.length) {
-      for (const dep of staticDeps) {
-        extraHead += `
-<link rel="modulepreload" href="${dep}" />`;
-      }
-    }
-  } catch {}
   let statusOverride;
   try {
     globalThis.__REROUTE_SSR_ACCESSED__ = {};
@@ -2829,7 +2693,7 @@ async function renderSSRDocument(options) {
       let modulePath = "";
       let isContentCollection = false;
       try {
-        const maybeDir = join11(clientDir, "routes", collection, "content");
+        const maybeDir = join9(clientDir, "routes", collection, "content");
         const s = await stat4(maybeDir);
         isContentCollection = typeof s?.isDirectory === "function" ? s.isDirectory() : true;
       } catch {
@@ -2839,8 +2703,8 @@ async function renderSSRDocument(options) {
         throw new Error("skip-content-preload");
       }
       try {
-        const registryPath = join11(cwd, ".reroute", "content.ts");
-        const reg = await import(pathToFileURL5(registryPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const registryPath = join9(cwd, ".reroute", "content.ts");
+        const reg = await import(pathToFileURL5(registryPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const get = reg?.getContentEntry;
         const entry = typeof get === "function" ? get(collection, name) : undefined;
         const moduleUrl = entry?.module;
@@ -2850,7 +2714,7 @@ async function renderSSRDocument(options) {
       } catch {}
       if (!modulePath) {
         try {
-          const chunkDir = join11(cwd, ".reroute", "chunks", collection);
+          const chunkDir = join9(cwd, ".reroute", "chunks", collection);
           const files = await readdir5(chunkDir);
           const candidates = files.filter((n) => n.startsWith(`${name}.`) && n.endsWith(".js"));
           if (candidates.length) {
@@ -2858,25 +2722,25 @@ async function renderSSRDocument(options) {
             let latestM = 0;
             for (const candidateName of candidates) {
               try {
-                const s = await stat4(join11(chunkDir, candidateName));
+                const s = await stat4(join9(chunkDir, candidateName));
                 if (s.mtimeMs >= latestM) {
                   latestM = s.mtimeMs;
                   latest = candidateName;
                 }
               } catch {}
             }
-            modulePath = `/${join11(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
+            modulePath = `/${join9(".reroute", "chunks", collection, latest).replace(/\\+/g, "/")}`;
           }
         } catch {}
       }
       if (!modulePath) {
-        const tsx = join11(clientDir, "routes", collection, "content", `${name}.tsx`);
-        const ts = join11(clientDir, "routes", collection, "content", `${name}.ts`);
+        const tsx = join9(clientDir, "routes", collection, "content", `${name}.tsx`);
+        const ts = join9(clientDir, "routes", collection, "content", `${name}.ts`);
         let srcUrl = "";
         if (await Bun.file(tsx).exists()) {
-          srcUrl = `/${join11("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
+          srcUrl = `/${join9("routes", collection, "content", `${name}.tsx`).replace(/\\+/g, "/")}`;
         } else if (await Bun.file(ts).exists()) {
-          srcUrl = `/${join11("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
+          srcUrl = `/${join9("routes", collection, "content", `${name}.ts`).replace(/\\+/g, "/")}`;
         }
         if (srcUrl) {
           modulePath = srcUrl;
@@ -2894,7 +2758,7 @@ async function renderSSRDocument(options) {
       }
     }
   } catch {}
-  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode2);
+  await seedSSRModuleForPath(pathname, clientDir, cwd, isWatchMode);
   const __SSR_DATA__ = {};
   try {
     try {
@@ -2914,15 +2778,15 @@ async function renderSSRDocument(options) {
       }
     } catch {}
     try {
-      const routesPath = join11(cwd, ".reroute", "routes.ts");
-      const m = await import(pathToFileURL5(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+      const routesPath = join9(cwd, ".reroute", "routes.ts");
+      const m = await import(pathToFileURL5(routesPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
       const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
       const r = match?.route;
       const params = match?.params || {};
       if (r && typeof r.path === "string") {
         try {
-          const abs = join11(clientDir, "routes", String(r.path));
-          const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+          const abs = join9(clientDir, "routes", String(r.path));
+          const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
           const ssr = mod?.ssr;
           const dataFn = ssr?.data;
           if (typeof dataFn === "function") {
@@ -2938,8 +2802,8 @@ async function renderSSRDocument(options) {
   } catch {}
   let __byCollectionForSSR = {};
   try {
-    const p = join11(cwd, ".reroute", "content.ts");
-    const mod = await import(pathToFileURL5(p).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const p = join9(cwd, ".reroute", "content.ts");
+    const mod = await import(pathToFileURL5(p).href + (isWatchMode ? `?t=${Date.now()}` : ""));
     __byCollectionForSSR = mod?.byCollection || {};
     try {
       globalThis.__REROUTE_COLLECTIONS__ = __byCollectionForSSR;
@@ -2953,10 +2817,10 @@ async function renderSSRDocument(options) {
   let inlineStyleTag = "";
   try {
     const candidates = [
-      join11(clientDir, "..", ".reroute", "theme.css"),
-      join11(clientDir, "..", "..", ".reroute", "theme.css"),
-      join11(clientDir, "..", "..", "..", ".reroute", "theme.css"),
-      join11(clientDir, "..", "..", "..", "..", ".reroute", "theme.css")
+      join9(clientDir, "..", ".reroute", "theme.css"),
+      join9(clientDir, "..", "..", ".reroute", "theme.css"),
+      join9(clientDir, "..", "..", "..", ".reroute", "theme.css"),
+      join9(clientDir, "..", "..", "..", "..", ".reroute", "theme.css")
     ];
     let cssPath = "";
     for (const p of candidates) {
@@ -3039,7 +2903,7 @@ async function renderSSRDocument(options) {
 </script>`;
   } catch {}
   hydrationScript += scripts.map((src) => `<script type="module" src="${src}"></script>`).join("");
-  if (isWatchMode2) {
+  if (isWatchMode) {
     hydrationScript += `<script type="module" src="/__reroute_watch.js"></script>`;
   }
   let perPageHead = "";
@@ -3064,8 +2928,8 @@ ${ssrHead}`;
     }
   } catch {}
   try {
-    const routesPath = join11(cwd, ".reroute", "routes.ts");
-    const m = await import(pathToFileURL5(routesPath).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+    const routesPath = join9(cwd, ".reroute", "routes.ts");
+    const m = await import(pathToFileURL5(routesPath).href + (isWatchMode ? `?t=${Date.now()}` : ""));
     const match = typeof m.matchRoute === "function" ? m.matchRoute(pathname) : null;
     const r = match?.route;
     if (!r) {
@@ -3073,8 +2937,8 @@ ${ssrHead}`;
     }
     if (r && typeof r.path === "string") {
       try {
-        const abs = join11(clientDir, "routes", String(r.path));
-        const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+        const abs = join9(clientDir, "routes", String(r.path));
+        const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
         const meta = mod?.meta;
         const ssr = mod?.ssr;
         if (meta)
@@ -3108,8 +2972,8 @@ ${ssrHead}`;
           }
           if (chosen && typeof chosen.path === "string") {
             try {
-              const abs = join11(clientDir, "routes", String(chosen.path));
-              const mod = await import(pathToFileURL5(abs).href + (isWatchMode2 ? `?t=${Date.now()}` : ""));
+              const abs = join9(clientDir, "routes", String(chosen.path));
+              const mod = await import(pathToFileURL5(abs).href + (isWatchMode ? `?t=${Date.now()}` : ""));
               const meta = mod?.meta;
               const ssr = mod?.ssr;
               if (meta)
@@ -3144,7 +3008,6 @@ ${ssrHead}`;
 }
 var init_render = __esm(() => {
   init_dedent();
-  init_bundler();
   init_metadata();
   init_template();
   init_seed();
@@ -3276,7 +3139,6 @@ var init_src = __esm(() => {
 // packages/core/index.ts
 var exports_core = {};
 __export(exports_core, {
-  transpileFile: () => transpileFile,
   toBytes: () => toBytes,
   stripStart: () => stripStart,
   stripEnd: () => stripEnd,
@@ -3284,20 +3146,16 @@ __export(exports_core, {
   renderSSRDocument: () => renderSSRDocument,
   loadIndexHtml: () => loadIndexHtml,
   listContentFiles: () => listContentFiles2,
-  join: () => join11,
+  join: () => join9,
   isCompressible: () => isCompressible,
   gzipIfAccepted: () => gzipIfAccepted,
-  getStaticDepsForUrl: () => getStaticDepsForUrl,
   getMimeType: () => getMimeType,
   getContentMeta: () => getContentMeta,
-  getBundleUrlsFor: () => getBundleUrlsFor,
-  generateContentRegistry: () => generateContentRegistry,
   generateContentHash: () => generateContentHash,
   extname: () => extname2,
   discoverCollections: () => discoverCollections,
   computeSSRDataForPath: () => computeSSRDataForPath,
   buildHeadFromMeta: () => buildHeadFromMeta,
-  buildContentDTOs: () => buildContentDTOs,
   basename: () => basename2,
   applyIndexTemplate: () => applyIndexTemplate,
   acceptsGzip: () => acceptsGzip,
@@ -3308,32 +3166,61 @@ var init_core = __esm(() => {
   init_src();
 });
 
+// packages/cli/src/libs/command.ts
+var exports_command = {};
+__export(exports_command, {
+  getRerouteCommand: () => getRerouteCommand4
+});
+import { existsSync as existsSync8 } from "node:fs";
+import { join as join10 } from "node:path";
+function getRerouteCommand4() {
+  const binPath = join10(import.meta.dir, "..", "..", "bin.ts");
+  const isBunDev = existsSync8(binPath);
+  if (isBunDev) {
+    return `bun ${binPath}`;
+  }
+  const cwd = process.cwd();
+  const nodeModulesPaths = [
+    join10(cwd, "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "..", "node_modules", ".bin", "reroute"),
+    join10(cwd, "..", "..", "..", "node_modules", ".bin", "reroute")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync8(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+var init_command = () => {};
+
 // packages/cli/src/commands/analyze.ts
 var exports_analyze = {};
 __export(exports_analyze, {
   default: () => analyze
 });
 import { existsSync as existsSync9, statSync } from "node:fs";
-import { readdir as readdir6, readFile as readFile2, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
-import { basename as basename3, join as join12, relative } from "node:path";
+import { readdir as readdir6, readFile, stat as stat5, writeFile } from "node:fs/promises";
+import { basename as basename3, join as join11, relative } from "node:path";
 import Table from "cli-table3";
 async function findBundles(cwd) {
   const bundles = [];
-  const chunksDir = join12(cwd, ".reroute", "chunks");
+  const chunksDir = join11(cwd, ".reroute", "chunks");
   if (existsSync9(chunksDir)) {
     const collections = await readdir6(chunksDir, { withFileTypes: true });
     for (const collection of collections) {
       if (!collection.isDirectory())
         continue;
-      const collectionDir = join12(chunksDir, collection.name);
+      const collectionDir = join11(chunksDir, collection.name);
       const files = await readdir6(collectionDir);
       for (const file of files) {
         if (!file.endsWith(".js"))
           continue;
-        const filePath = join12(collectionDir, file);
+        const filePath = join11(collectionDir, file);
         const stats = await stat5(filePath);
-        const content2 = await readFile2(filePath);
-        const gzippedSize = Bun.gzipSync(content2).length;
+        const content2 = await Bun.file(filePath).arrayBuffer();
+        const gzippedSize = Bun.gzipSync(new Uint8Array(content2)).length;
         bundles.push({
           path: filePath,
           name: file,
@@ -3345,15 +3232,15 @@ async function findBundles(cwd) {
       }
     }
   }
-  const distDir = join12(cwd, "dist");
+  const distDir = join11(cwd, "dist");
   if (existsSync9(distDir)) {
     const files = await readdir6(distDir);
     for (const file of files) {
-      const filePath = join12(distDir, file);
+      const filePath = join11(distDir, file);
       const stats = statSync(filePath);
       if (stats.isFile() && !file.endsWith(".map") && !file.endsWith(".d.ts")) {
-        const content2 = await readFile2(filePath);
-        const gzippedSize = Bun.gzipSync(content2).length;
+        const content2 = await Bun.file(filePath).arrayBuffer();
+        const gzippedSize = Bun.gzipSync(new Uint8Array(content2)).length;
         bundles.push({
           path: filePath,
           name: file,
@@ -3369,9 +3256,9 @@ async function findBundles(cwd) {
 }
 async function findBrowserEntry(cwd) {
   try {
-    const clientDir = join12(cwd, "src", "client");
-    const tsxEntry = join12(clientDir, "index.tsx");
-    const tsEntry = join12(clientDir, "index.ts");
+    const clientDir = join11(cwd, "src", "client");
+    const tsxEntry = join11(clientDir, "index.tsx");
+    const tsEntry = join11(clientDir, "index.ts");
     let sourceEntry = null;
     if (existsSync9(tsxEntry)) {
       sourceEntry = tsxEntry;
@@ -3395,7 +3282,7 @@ async function findBrowserEntry(cwd) {
     });
     if (!result.success) {
       if (result.logs && result.logs.length > 0) {
-        console.warn("[reroute/analyze] Browser build errors:", result.logs.map((log2) => log2.message).join(`
+        console.warn("[reroute/analyze] Browser build errors:", result.logs.map((log) => log.message).join(`
 `));
       }
       return null;
@@ -3404,17 +3291,17 @@ async function findBrowserEntry(cwd) {
       console.warn("[reroute/analyze] Browser build produced no outputs");
       return null;
     }
-    const tempDir = join12(cwd, ".reroute", "browser");
+    const tempDir = join11(cwd, ".reroute", "browser");
     await import("node:fs/promises").then((fs) => fs.mkdir(tempDir, { recursive: true }));
     const output = result.outputs[0];
     const code = await output.text();
     const actualHash = await generateContentHash2(code);
-    const bundlePath = join12(tempDir, `index.${actualHash}.js`);
-    await writeFile4(bundlePath, code, "utf-8");
+    const bundlePath = join11(tempDir, `index.${actualHash}.js`);
+    await writeFile(bundlePath, code, "utf-8");
     const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
     if (mapOutput) {
       const mapContent = await mapOutput.text();
-      await writeFile4(`${bundlePath}.map`, mapContent, "utf-8");
+      await writeFile(`${bundlePath}.map`, mapContent, "utf-8");
     }
     return bundlePath;
   } catch (error) {
@@ -3461,7 +3348,7 @@ function calculateStats(bundles) {
 }
 async function getInstalledPackageSizes(cwd) {
   const packageSizes = new Map;
-  const nodeModulesDir = join12(cwd, "node_modules");
+  const nodeModulesDir = join11(cwd, "node_modules");
   if (!existsSync9(nodeModulesDir))
     return packageSizes;
   try {
@@ -3520,7 +3407,7 @@ async function buildDependencyTree(entryPath, cwd) {
           if (!pkgNode) {
             pkgNode = {
               name: pkgName || "unknown",
-              path: join12(cwd, "node_modules", pkgName || ""),
+              path: join11(cwd, "node_modules", pkgName || ""),
               size: 0,
               children: []
             };
@@ -3541,7 +3428,7 @@ async function buildDependencyTree(entryPath, cwd) {
             if (!child) {
               child = {
                 name: part,
-                path: join12(cwd, ...parts.slice(0, i + 1)),
+                path: join11(cwd, ...parts.slice(0, i + 1)),
                 size: 0,
                 children: []
               };
@@ -3561,11 +3448,11 @@ async function buildDependencyTree(entryPath, cwd) {
         }
         return node.size;
       };
-      const content2 = await readFile2(entryPath, "utf-8");
+      const content2 = await readFile(entryPath, "utf-8");
       const modulePattern = /\/\/\s*(.+?\.(?:ts|tsx|js|jsx|mjs|cjs))\s*$/gm;
       const nodeModulesNode = {
         name: "node_modules",
-        path: join12(cwd, "node_modules"),
+        path: join11(cwd, "node_modules"),
         size: 0,
         children: []
       };
@@ -3631,7 +3518,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
       if (sourcePath.startsWith("/") || sourcePath.match(/^[A-Za-z]:\\/))
         return sourcePath;
       const bundleDir = bundlePath.substring(0, bundlePath.lastIndexOf("/"));
-      return join12(bundleDir, sourceRoot || "", sourcePath);
+      return join11(bundleDir, sourceRoot || "", sourcePath);
     }, computeSizes = function(node) {
       if (node.children && node.children.length > 0) {
         node.size = node.children.reduce((s, c) => s + computeSizes(c), 0);
@@ -3642,8 +3529,8 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
     if (!existsSync9(mapPath))
       return null;
     const [bundle, mapJson] = await Promise.all([
-      readFile2(bundlePath, "utf-8"),
-      readFile2(mapPath, "utf-8")
+      readFile(bundlePath, "utf-8"),
+      readFile(mapPath, "utf-8")
     ]);
     const map = JSON.parse(mapJson);
     const sourceRoot = map.sourceRoot || "";
@@ -3703,7 +3590,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
     };
     const nodeModulesNode = {
       name: "node_modules",
-      path: join12(cwd, "node_modules"),
+      path: join11(cwd, "node_modules"),
       size: 0,
       children: []
     };
@@ -3743,7 +3630,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
         if (!pkgNode) {
           pkgNode = {
             name: pkgName || "unknown",
-            path: join12(cwd, "node_modules", pkgName || ""),
+            path: join11(cwd, "node_modules", pkgName || ""),
             size: 0,
             children: []
           };
@@ -3764,7 +3651,7 @@ async function buildTreeFromSourceMap(bundlePath, cwd) {
           if (!child) {
             child = {
               name: part,
-              path: join12(cwd, ...parts.slice(0, i2 + 1)),
+              path: join11(cwd, ...parts.slice(0, i2 + 1)),
               size: 0,
               children: []
             };
@@ -3794,15 +3681,15 @@ async function generateHTMLReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join12(process.cwd(), "dist");
+    const distDir = join11(process.cwd(), "dist");
     if (existsSync9(distDir)) {
       const files = await readdir6(distDir);
       for (const file of files) {
-        const filePath = join12(distDir, file);
+        const filePath = join11(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
-          const content2 = await readFile2(filePath);
+          const content2 = await readFile(filePath);
           actualServerBinaryGzipped = Bun.gzipSync(content2).length;
           break;
         }
@@ -5280,15 +5167,15 @@ async function printConsoleReport(stats, depTree, mainInfo, browserDepTree, brow
   let actualServerBinarySize = null;
   let actualServerBinaryGzipped = null;
   try {
-    const distDir = join12(process.cwd(), "dist");
+    const distDir = join11(process.cwd(), "dist");
     if (existsSync9(distDir)) {
       const files = await readdir6(distDir);
       for (const file of files) {
-        const filePath = join12(distDir, file);
+        const filePath = join11(distDir, file);
         const stats2 = statSync(filePath);
         if (stats2.isFile() && !file.includes(".")) {
           actualServerBinarySize = stats2.size;
-          const content2 = await readFile2(filePath);
+          const content2 = await readFile(filePath);
           actualServerBinaryGzipped = Bun.gzipSync(content2).length;
           break;
         }
@@ -5318,7 +5205,7 @@ async function analyze(args) {
     const isProd = isProductionMode(args);
     const searchIndex = args.indexOf("--search");
     const initialSearch = searchIndex !== -1 && args[searchIndex + 1] ? args[searchIndex + 1] : "";
-    const rerouteIndexPath = join12(cwd, ".reroute", "index.ts");
+    const rerouteIndexPath = join11(cwd, ".reroute", "index.ts");
     if (!existsSync9(rerouteIndexPath)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] .reroute artifacts not found, running build...
 `));
@@ -5366,7 +5253,7 @@ async function analyze(args) {
       }
       try {
         const browserStat = await stat5(browserEntry);
-        const browserContent = await readFile2(browserEntry);
+        const browserContent = await readFile(browserEntry);
         const browserGzipped = Bun.gzipSync(browserContent).length;
         browserInfo = {
           name: basename3(browserEntry),
@@ -5381,13 +5268,13 @@ async function analyze(args) {
     let entry = null;
     let depTree = null;
     let mainInfo = null;
-    const srcEntry = join12(cwd, "src", "index.ts");
+    const srcEntry = join11(cwd, "src", "index.ts");
     if (existsSync9(srcEntry)) {
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Building server binary for analysis...
 `));
-      const { mkdir: mkdir4 } = await import("node:fs/promises");
-      const serverAnalysisDir = join12(cwd, ".reroute", "server");
-      await mkdir4(serverAnalysisDir, { recursive: true });
+      const { mkdir: mkdir3 } = await import("node:fs/promises");
+      const serverAnalysisDir = join11(cwd, ".reroute", "server");
+      await mkdir3(serverAnalysisDir, { recursive: true });
       const result = await Bun.build({
         entrypoints: [srcEntry],
         target: "bun",
@@ -5399,12 +5286,12 @@ async function analyze(args) {
       if (result.success && result.outputs.length > 0) {
         const output = result.outputs[0];
         const code = await output.text();
-        const analysisEntry = join12(serverAnalysisDir, "index.js");
-        await writeFile4(analysisEntry, code, "utf-8");
+        const analysisEntry = join11(serverAnalysisDir, "index.js");
+        await writeFile(analysisEntry, code, "utf-8");
         const mapOutput = result.outputs.find((o) => o.path.endsWith(".map"));
         if (mapOutput) {
           const mapContent = await mapOutput.text();
-          await writeFile4(`${analysisEntry}.map`, mapContent, "utf-8");
+          await writeFile(`${analysisEntry}.map`, mapContent, "utf-8");
         }
         entry = analysisEntry;
       }
@@ -5417,10 +5304,10 @@ async function analyze(args) {
 `));
       const installedSizes = await getInstalledPackageSizes(cwd);
       if (depTree) {
-        const packageJsonPath = join12(cwd, "package.json");
+        const packageJsonPath = join11(cwd, "package.json");
         if (existsSync9(packageJsonPath)) {
           try {
-            const packageJson = JSON.parse(await readFile2(packageJsonPath, "utf-8"));
+            const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
             const runtimeDeps = packageJson.dependencies || {};
             const nodeModulesNode = depTree.root.children?.find((c) => c.name === "node_modules");
             if (nodeModulesNode) {
@@ -5429,7 +5316,7 @@ async function analyze(args) {
                 if (!trackedPkgs.has(pkgName) && installedSizes.has(pkgName)) {
                   nodeModulesNode.children?.push({
                     name: pkgName,
-                    path: join12(cwd, "node_modules", pkgName),
+                    path: join11(cwd, "node_modules", pkgName),
                     size: installedSizes.get(pkgName) || 0
                   });
                 }
@@ -5448,7 +5335,7 @@ async function analyze(args) {
       }
       try {
         const entryStat = await stat5(entry);
-        const entryContent = await readFile2(entry);
+        const entryContent = await readFile(entry);
         const entryGzipped = Bun.gzipSync(entryContent).length;
         mainInfo = {
           name: basename3(entry),
@@ -5460,30 +5347,30 @@ async function analyze(args) {
     const fullOutput = args.includes("--full");
     await printConsoleReport(stats, depTree, mainInfo, browserDepTree, browserInfo, fullOutput);
     if (outputHtml || openBrowser) {
-      const htmlPath = join12(cwd, ".reroute", "analysis.html");
+      const htmlPath = join11(cwd, ".reroute", "analysis.html");
       const html2 = await generateHTMLReport(stats, depTree, mainInfo, browserDepTree, browserInfo, initialSearch);
-      const { mkdir: mkdir4 } = await import("node:fs/promises");
-      await mkdir4(join12(cwd, ".reroute"), { recursive: true });
-      await writeFile4(htmlPath, html2, "utf-8");
+      const { mkdir: mkdir3 } = await import("node:fs/promises");
+      await mkdir3(join11(cwd, ".reroute"), { recursive: true });
+      await writeFile(htmlPath, html2, "utf-8");
       console.log(colorizeLogPrefixAnsi(`[reroute/analyze] HTML report generated: ${relative(cwd, htmlPath)}
 `));
       if (openBrowser) {
         try {
           const { spawn: spawn5 } = await import("node:child_process");
           const platform = process.platform;
-          let command2;
+          let command;
           let commandArgs;
           if (platform === "darwin") {
-            command2 = "open";
+            command = "open";
             commandArgs = [htmlPath];
           } else if (platform === "win32") {
-            command2 = "cmd";
+            command = "cmd";
             commandArgs = ["/c", "start", "", htmlPath];
           } else {
-            command2 = "xdg-open";
+            command = "xdg-open";
             commandArgs = [htmlPath];
           }
-          spawn5(command2, commandArgs, { detached: true, stdio: "ignore" });
+          spawn5(command, commandArgs, { detached: true, stdio: "ignore" });
           console.log(colorizeLogPrefixAnsi(`[reroute/analyze] Opened report in browser
 `));
         } catch {
@@ -5525,7 +5412,6 @@ import path3 from "node:path";
 var commands = {
   init: () => Promise.resolve().then(() => (init_init(), exports_init)),
   gen: () => Promise.resolve().then(() => (init_gen(), exports_gen)),
-  boot: () => Promise.resolve().then(() => (init_boot(), exports_boot)),
   dev: () => Promise.resolve().then(() => (init_dev(), exports_dev)),
   start: () => Promise.resolve().then(() => (init_start(), exports_start)),
   build: () => Promise.resolve().then(() => (init_build(), exports_build)),
@@ -5542,9 +5428,9 @@ async function main() {
     await printHelp2();
     process.exit(0);
   }
-  const command2 = args[0];
-  if (!commands[command2]) {
-    console.error(`Unknown command: ${command2}`);
+  const command = args[0];
+  if (!commands[command]) {
+    console.error(`Unknown command: ${command}`);
     console.error("");
     await printHelp2();
     process.exit(1);
@@ -5557,7 +5443,7 @@ async function main() {
         Bun.env.NODE_ENV = "production";
       }
     }
-    const module = await commands[command2]();
+    const module = await commands[command]();
     await module.default(commandArgs);
   } catch (error) {
     console.error("Error executing command:", error);
@@ -5577,7 +5463,6 @@ async function printHelp2() {
   console.log("Commands:");
   console.log("");
   console.log("  init        Scaffold a new Reroute project");
-  console.log("  boot        Initialize .reroute directory with stub files");
   console.log("  gen         Generate content registry and static assets");
   console.log("  dev         Start development environment");
   console.log("  start       Run production-like server locally");
@@ -5595,7 +5480,6 @@ async function printHelp2() {
   console.log("Examples:");
   console.log("");
   console.log("  reroute init my-app");
-  console.log("  reroute boot");
   console.log("");
   console.log("  reroute gen");
   console.log("  reroute gen -w");
@@ -5625,7 +5509,7 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "0.9.0";
+    return "0.9.2";
   }
   const possiblePaths = [
     path3.join(import.meta.dir, "../../../package.json"),
@@ -5642,10 +5526,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "a5db82d";
+    return "07fb920";
   }
   return "dev";
 }
 main();
 
-//# debugId=49628F09E4188CEE64756E2164756E21
+//# debugId=EEA72E4BE30148EF64756E2164756E21