reroute-js 0.5.0 → 0.7.0

package/cli/bin.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // @bun
 /**
- * reroute-js v0.5.0
+ * reroute-js v0.7.0
  *
  * @license MIT
  * @copyright 2025 stewones <hi@stewan.io>
@@ -9,7 +9,23 @@
  *
  * Built with Bun <3
  */
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -20,6 +36,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // packages/cli/src/libs/version.ts
 import path from "node:path";
@@ -30,7 +47,7 @@ async function getVersionString() {
 }
 async function getVersion() {
   if (true) {
-    return "0.5.0";
+    return "0.7.0";
   }
   const possiblePaths = [
     path.join(import.meta.dir, "../../../../package.json"),
@@ -48,7 +65,7 @@ async function getVersion() {
 }
 async function getCommit() {
   if (true) {
-    return "68dd984";
+    return "4b119c0";
   }
   return "dev";
 }
@@ -113,15 +130,53 @@ async function scaffoldProject(options) {
   console.log(`
 \uD83D\uDCE6  Template: ${template}
 `);
-  const templatePath = join(import.meta.dir, "..", "_", template);
-  if (!existsSync(templatePath)) {
-    console.error(`Error: Template directory not found at ${templatePath}`);
+  const possibleTemplatePaths = [
+    join(import.meta.dir, "..", "_", template),
+    join(import.meta.dir, "..", "..", "..", "_", template)
+  ];
+  let templatePath;
+  for (const path2 of possibleTemplatePaths) {
+    if (existsSync(path2)) {
+      templatePath = path2;
+      break;
+    }
+  }
+  if (!templatePath) {
+    console.error(`Error: Template directory not found for template "${template}"`);
+    console.error(`Tried paths: ${possibleTemplatePaths.join(", ")}`);
     process.exit(1);
   }
+  const possibleExamplesPaths = [
+    join(import.meta.dir, "..", "..", "..", "..", "examples", template, "src"),
+    join(import.meta.dir, "..", "..", "..", "..", "..", "examples", template, "src")
+  ];
+  let examplesPath;
+  for (const path2 of possibleExamplesPaths) {
+    if (existsSync(path2)) {
+      examplesPath = path2;
+      break;
+    }
+  }
   await mkdir(projectPath, { recursive: true });
   await copyTemplateFiles(templatePath, projectPath, {
     PROJECT_NAME: projectName
   });
+  const sourceVariables = {
+    PROJECT_NAME: projectName
+  };
+  if (examplesPath) {
+    await copySourceFiles(examplesPath, join(projectPath, "src"), sourceVariables);
+  } else {
+    const templateSrcPath = join(templatePath, "src");
+    if (existsSync(templateSrcPath)) {
+      await copySourceFiles(templateSrcPath, join(projectPath, "src"), sourceVariables);
+    } else {
+      console.error(`Error: No src directory found for template "${template}"`);
+      console.error(`Tried examples paths: ${possibleExamplesPaths.join(", ")}`);
+      console.error(`Tried template path: ${templateSrcPath}`);
+      process.exit(1);
+    }
+  }
   console.log(`\uD83D\uDCE5  Installing dependencies...
 `);
   const proc = Bun.spawn(["bun", "install"], {
@@ -135,6 +190,9 @@ async function scaffoldProject(options) {
 async function copyTemplateFiles(templatePath, targetPath, variables) {
   const entries = await readdir(templatePath, { withFileTypes: true });
   for (const entry of entries) {
+    if (entry.isDirectory() && entry.name === "src") {
+      continue;
+    }
     const sourcePath = join(templatePath, entry.name);
     const destPath = join(targetPath, entry.name);
     if (entry.isDirectory()) {
@@ -151,6 +209,34 @@ async function copyTemplateFiles(templatePath, targetPath, variables) {
     }
   }
 }
+function applyVariableReplacements(content, fileName, variables) {
+  const shouldReplaceVariables = VARIABLE_REPLACEMENT_PATTERNS.some((pattern) => pattern.test(fileName));
+  if (!shouldReplaceVariables) {
+    return content;
+  }
+  let processedContent = content;
+  if (/\.html$/i.test(fileName)) {
+    if (variables.PROJECT_NAME) {
+      processedContent = processedContent.replace(/<title>.*?<\/title>/i, `<title>${variables.PROJECT_NAME}</title>`);
+    }
+  }
+  return processedContent;
+}
+async function copySourceFiles(sourcePath, targetPath, variables) {
+  const entries = await readdir(sourcePath, { withFileTypes: true });
+  await mkdir(targetPath, { recursive: true });
+  for (const entry of entries) {
+    const sourceEntryPath = join(sourcePath, entry.name);
+    const targetEntryPath = join(targetPath, entry.name);
+    if (entry.isDirectory()) {
+      await copySourceFiles(sourceEntryPath, targetEntryPath, variables);
+    } else if (entry.isFile()) {
+      const content = await readFile(sourceEntryPath, "utf-8");
+      const processedContent = variables ? applyVariableReplacements(content, entry.name, variables) : content;
+      await writeFile(targetEntryPath, processedContent);
+    }
+  }
+}
 function printSuccess(projectName, template) {
   console.log(`
 \uD83C\uDFCE️ Project created successfully!
@@ -203,21 +289,377 @@ async function printHelp() {
   console.log("  reroute init my-blog --template blog");
   console.log("  reroute init my-store --template store");
 }
+var VARIABLE_REPLACEMENT_PATTERNS;
 var init_init = __esm(() => {
   init_version();
+  VARIABLE_REPLACEMENT_PATTERNS = [
+    /\.html$/i
+  ];
 });
 
+// packages/cli/src/libs/markdown.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function isPackageAvailable(cwd, packageName) {
+  let currentDir = cwd;
+  for (let i = 0;i < 5; i++) {
+    const packageJsonPath = join2(currentDir, "package.json");
+    if (existsSync2(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        const deps = {
+          ...packageJson.dependencies,
+          ...packageJson.devDependencies,
+          ...packageJson.peerDependencies
+        };
+        if (packageName in deps) {
+          return true;
+        }
+      } catch {}
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return false;
+}
+function isReactMarkdownAvailable(cwd) {
+  return isPackageAvailable(cwd, "react-markdown");
+}
+function isShikiAvailable(cwd) {
+  return isPackageAvailable(cwd, "@shikijs/rehype");
+}
+function isRemarkGfmAvailable(cwd) {
+  return isPackageAvailable(cwd, "remark-gfm");
+}
+function isMdxAvailable(cwd) {
+  return isPackageAvailable(cwd, "@mdx-js/mdx");
+}
+function getMarkdownConfig(cwd) {
+  const hasReactMarkdown = isReactMarkdownAvailable(cwd);
+  const hasShiki = isShikiAvailable(cwd);
+  const hasRemarkGfm = isRemarkGfmAvailable(cwd);
+  const hasMdx = isMdxAvailable(cwd);
+  return {
+    hasReactMarkdown,
+    hasShiki,
+    hasRemarkGfm,
+    hasMdx,
+    isConfigured: hasReactMarkdown
+  };
+}
+function logMarkdownStatus(cwd) {
+  const config = getMarkdownConfig(cwd);
+  if (config.isConfigured) {
+    console.log("[reroute/markdown] Markdown rendering available");
+    if (config.hasShiki) {
+      console.log("[reroute/markdown] ✓ Shiki syntax highlighting enabled");
+    }
+    if (config.hasRemarkGfm) {
+      console.log("[reroute/markdown] ✓ GitHub Flavored Markdown enabled");
+    }
+    if (config.hasMdx) {
+      console.log("[reroute/markdown] ✓ MDX compiler enabled (JSX in markdown)");
+    }
+  }
+}
+function checkMarkdownIfConfigured(cwd) {
+  try {
+    const config = getMarkdownConfig(cwd);
+    if (config.isConfigured) {
+      logMarkdownStatus(cwd);
+    }
+    return config.isConfigured;
+  } catch (e) {
+    console.warn("[reroute/markdown] check failed:", e);
+    return false;
+  }
+}
+var init_markdown = () => {};
+
+// packages/cli/src/libs/markdown-processor.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, extname, join as join3 } from "node:path";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return { data: {}, content };
+  }
+  const [, frontmatterText, markdownContent] = match;
+  const data = {};
+  const lines = frontmatterText.split(`
+`);
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1)
+      continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (value.startsWith("[") && value.endsWith("]")) {
+      data[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
+    } else if (value === "true" || value === "false") {
+      data[key] = value === "true";
+    } else if (!Number.isNaN(Number(value))) {
+      data[key] = Number(value);
+    } else {
+      data[key] = value;
+    }
+  }
+  return { data, content: markdownContent };
+}
+function hasJSXSyntax(content) {
+  const jsxPatterns = [
+    /<[A-Z][a-zA-Z0-9]*/,
+    /import\s+{[^}]+}\s+from/,
+    /import\s+\w+\s+from/,
+    /export\s+(default|const|function)/,
+    /<\w+\s+\w+={/
+  ];
+  return jsxPatterns.some((pattern) => pattern.test(content));
+}
+function processMarkdownFile(filePath) {
+  const rawContent = readFileSync2(filePath, "utf-8");
+  const { data, content } = parseFrontmatter(rawContent);
+  const hasJSX = hasJSXSyntax(content);
+  return {
+    frontmatter: data,
+    content,
+    rawContent,
+    hasJSX
+  };
+}
+function isMdxAvailable2(cwd) {
+  let currentDir = cwd;
+  for (let i = 0;i < 5; i++) {
+    const packageJsonPath = join3(currentDir, "package.json");
+    if (existsSync3(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+        const deps = {
+          ...packageJson.dependencies,
+          ...packageJson.devDependencies,
+          ...packageJson.peerDependencies
+        };
+        if ("@mdx-js/mdx" in deps) {
+          return true;
+        }
+      } catch {}
+    }
+    const parentDir = dirname2(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return false;
+}
+async function compileMdx(content, cwd, options = {}) {
+  if (!isMdxAvailable2(cwd)) {
+    console.warn("[reroute/mdx] @mdx-js/mdx not installed. Install with: bun add @mdx-js/mdx");
+    return null;
+  }
+  try {
+    let compile;
+    const pathsToTry = [
+      join3(cwd, "node_modules/@mdx-js/mdx"),
+      join3(cwd, "../node_modules/@mdx-js/mdx"),
+      join3(cwd, "../../node_modules/@mdx-js/mdx"),
+      join3(cwd, "../../../node_modules/@mdx-js/mdx")
+    ];
+    for (const mdxPath of pathsToTry) {
+      try {
+        const mdxModule = __require(mdxPath);
+        compile = mdxModule.compile;
+        break;
+      } catch {}
+    }
+    if (!compile) {
+      console.error("[reroute/mdx] Could not load @mdx-js/mdx from any path");
+      return null;
+    }
+    const { enableGfm = true, theme = "github-dark" } = options;
+    const remarkPlugins = [];
+    const rehypePlugins = [];
+    if (enableGfm) {
+      const gfmPathsToTry = [
+        join3(cwd, "node_modules/remark-gfm"),
+        join3(cwd, "../node_modules/remark-gfm"),
+        join3(cwd, "../../node_modules/remark-gfm"),
+        join3(cwd, "../../../node_modules/remark-gfm")
+      ];
+      let remarkGfm = null;
+      for (const gfmPath of gfmPathsToTry) {
+        try {
+          remarkGfm = __require(gfmPath);
+          break;
+        } catch {}
+      }
+      if (remarkGfm) {
+        remarkPlugins.push(remarkGfm.default || remarkGfm);
+      } else {
+        console.warn("[reroute/mdx] remark-gfm not available, skipping");
+      }
+    }
+    const shikiPathsToTry = [
+      join3(cwd, "node_modules/@shikijs/rehype"),
+      join3(cwd, "../node_modules/@shikijs/rehype"),
+      join3(cwd, "../../node_modules/@shikijs/rehype"),
+      join3(cwd, "../../../node_modules/@shikijs/rehype")
+    ];
+    let rehypeShiki = null;
+    for (const shikiPath of shikiPathsToTry) {
+      try {
+        rehypeShiki = __require(shikiPath);
+        break;
+      } catch {}
+    }
+    if (rehypeShiki) {
+      rehypePlugins.push([rehypeShiki.default || rehypeShiki, { theme }]);
+    } else {
+      console.warn("[reroute/mdx] @shikijs/rehype not available, skipping highlighting");
+    }
+    const result = await compile(content, {
+      remarkPlugins,
+      rehypePlugins,
+      outputFormat: "program",
+      development: false
+    });
+    return String(result);
+  } catch (error) {
+    console.error("[reroute/mdx] Compilation failed:", error);
+    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 });
+  if (compiledMdx) {
+    return `// Generated from ${isMdx ? "MDX" : "Markdown"} file with @mdx-js/mdx
+
+// MDX compiled content with imports and component
+${compiledMdx}
+
+// Add metadata exports
+export const meta = ${JSON.stringify(frontmatter, null, 2)};
+
+export const ssr = {
+  head: [
+    '<meta property="og:type" content="article" />',
+    '<meta name="twitter:card" content="summary_large_image" />',
+  ],
+};
+`;
+  }
+  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 = [];
+  const rehypePluginsList = [];
+  if (enableGfm) {
+    pluginImports.push("import remarkGfm from 'remark-gfm';");
+    remarkPluginsList.push("remarkGfm");
+  }
+  const pluginImportsStr = pluginImports.length > 0 ? `${pluginImports.join(`
+`)}
+` : "";
+  const remarkPluginsStr = remarkPluginsList.length > 0 ? `remarkPlugins={[${remarkPluginsList.join(", ")}]}` : "";
+  const rehypePluginsStr = rehypePluginsList.length > 0 ? `rehypePlugins={[${rehypePluginsList.join(", ")}]}` : "";
+  const pluginsPropsStr = [remarkPluginsStr, rehypePluginsStr].filter(Boolean).join(`
+        `);
+  return `// Generated from markdown file
+import { Markdown } from 'reroute-js/react';
+${pluginImportsStr}
+const meta = ${JSON.stringify(frontmatter, null, 2)};
+
+const ssr = {
+  head: [
+    '<meta property="og:type" content="article" />',
+    '<meta name="twitter:card" content="summary_large_image" />',
+  ],
+};
+
+const markdownContent = \`${escapedContent}\`;
+
+function MarkdownRoute() {
+  return (
+    <div>
+      <Markdown
+        ${pluginsPropsStr}
+      >
+        {markdownContent}
+      </Markdown>
+    </div>
+  );
+}
+
+export { meta, ssr };
+export default MarkdownRoute;
+`;
+}
+function generatePlainMarkdownModule(processed) {
+  const { frontmatter, content } = processed;
+  const escapedContent = content.replace(/\\/g, "\\\\").split(String.fromCharCode(96)).join(`\\${String.fromCharCode(96)}`).split("$").join("\\$");
+  return `// Generated from markdown file (plain fallback)
+// No markdown renderer detected; showing raw content.
+export const meta = ${JSON.stringify(frontmatter, null, 2)};
+
+export const ssr = {
+  head: [
+    '<meta property="og:type" content="article" />',
+    '<meta name="twitter:card" content="summary_large_image" />',
+  ],
+};
+
+const markdownContent = \`${escapedContent}\`;
+
+export default function MarkdownFallback() {
+  return (
+    <div style={{ padding: '1rem' }}>
+      {meta?.title && (
+        <h1 style={{ fontSize: '1.5rem', fontWeight: 600 }}>{meta.title}</h1>
+      )}
+      <div style={{
+        margin: '0.75rem 0',
+        padding: '0.75rem',
+        borderLeft: '4px solid #eab308',
+        background: '#fefce8',
+        color: '#713f12'
+      }}>
+        <strong>Markdown rendering not configured.</strong>
+        <div style={{ marginTop: '0.25rem' }}>
+          Install: react-markdown (required), remark-gfm (optional), @mdx-js/mdx (optional), @shikijs/rehype (optional).
+        </div>
+      </div>
+      <pre style={{ whiteSpace: 'pre-wrap', lineHeight: 1.6 }}>{markdownContent}</pre>
+    </div>
+  );
+}
+`;
+}
+function isMarkdownFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return ext === ".md" || ext === ".mdx";
+}
+var init_markdown_processor = () => {};
+
 // packages/cli/src/libs/tailwind.ts
 import { spawn } from "node:child_process";
-import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
+import { join as join4 } from "node:path";
 function isTailwindAvailable(cwd) {
-  const packageJsonPath = join2(cwd, "package.json");
-  if (!existsSync2(packageJsonPath)) {
+  const packageJsonPath = join4(cwd, "package.json");
+  if (!existsSync4(packageJsonPath)) {
     return false;
   }
   try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync3(packageJsonPath, "utf-8"));
     const deps = {
       ...packageJson.dependencies,
       ...packageJson.devDependencies
@@ -228,17 +670,17 @@ function isTailwindAvailable(cwd) {
   }
 }
 function getTailwindPaths(cwd) {
-  const input = join2(cwd, "src/client/theme.css");
-  const output = join2(cwd, ".reroute/theme.css");
+  const input = join4(cwd, "src/client/theme.css");
+  const output = join4(cwd, ".reroute/theme.css");
   return { input, output };
 }
 function hasTailwindInput(cwd) {
   const { input } = getTailwindPaths(cwd);
-  if (!existsSync2(input)) {
+  if (!existsSync4(input)) {
     return false;
   }
   try {
-    const content = readFileSync(input, "utf-8");
+    const content = readFileSync3(input, "utf-8");
     return content.includes("tailwindcss");
   } catch {
     return false;
@@ -246,16 +688,16 @@ function hasTailwindInput(cwd) {
 }
 function resolveTailwindBin(cwd) {
   const pathsToTry = [
-    join2(cwd, "../node_modules/.bin/tailwindcss"),
-    join2(cwd, "../../node_modules/.bin/tailwindcss"),
-    join2(cwd, "../../../node_modules/.bin/tailwindcss")
+    join4(cwd, "../node_modules/.bin/tailwindcss"),
+    join4(cwd, "../../node_modules/.bin/tailwindcss"),
+    join4(cwd, "../../../node_modules/.bin/tailwindcss")
   ];
   for (const binPath of pathsToTry) {
-    if (existsSync2(binPath)) {
+    if (existsSync4(binPath)) {
       return binPath;
     }
   }
-  return join2(cwd, "node_modules/.bin/tailwindcss");
+  return join4(cwd, "node_modules/.bin/tailwindcss");
 }
 async function buildTailwind(cwd) {
   const { input, output } = getTailwindPaths(cwd);
@@ -313,12 +755,12 @@ __export(exports_gen, {
 });
 import { watch } from "node:fs";
 import { mkdir as mkdir2, readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { join as join5 } from "node:path";
 import { pathToFileURL } from "node:url";
 async function cleanupOutputDir(cwd) {
   try {
-    await rm(join3(cwd, OUTPUT_DIR), { force: true });
-    await mkdir2(join3(cwd, OUTPUT_DIR), { recursive: true });
+    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");
   } catch {}
 }
@@ -326,14 +768,14 @@ async function scanDirectory(dir, base = "") {
   const files = [];
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
-    const relativePath = join3(base, entry.name);
+    const fullPath = join5(dir, entry.name);
+    const relativePath = join5(base, entry.name);
     if (entry.isDirectory()) {
       if (entry.name === "content")
         continue;
       const nested = await scanDirectory(fullPath, relativePath);
       files.push(...nested);
-    } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts"))) {
+    } else if (entry.isFile() && (entry.name.endsWith(".tsx") || entry.name.endsWith(".ts") || entry.name.endsWith(".md") || entry.name.endsWith(".mdx"))) {
       if (relativePath.includes("/content/") || relativePath.startsWith("content/")) {
         continue;
       }
@@ -348,8 +790,8 @@ async function scan404Files(dir, base = "") {
   const files = [];
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join3(dir, entry.name);
-    const relativePath = join3(base, entry.name);
+    const fullPath = join5(dir, entry.name);
+    const relativePath = join5(base, entry.name);
     if (entry.isDirectory()) {
       const nested = await scan404Files(fullPath, relativePath);
       files.push(...nested);
@@ -361,8 +803,8 @@ async function scan404Files(dir, base = "") {
   return files;
 }
 function fileToRoute(filePath) {
-  const isLayout = filePath.endsWith("[layout].tsx") || filePath.endsWith("[layout].ts");
-  let routePath = filePath.replace(/\.(tsx|ts)$/, "");
+  const isLayout = filePath.endsWith("[layout].tsx") || filePath.endsWith("[layout].ts") || filePath.endsWith("[layout].md") || filePath.endsWith("[layout].mdx");
+  let routePath = filePath.replace(/\.(tsx|ts|md|mdx)$/, "");
   if (isLayout) {
     routePath = routePath.replace(/[layout]$/, "").replace(/\/$/, "");
   }
@@ -423,11 +865,20 @@ function generateRouteTree(files) {
     notFoundRoutes
   };
 }
+function getImportPath(filePath) {
+  const isMarkdown = /\.(md|mdx)$/.test(filePath);
+  if (isMarkdown) {
+    const pathWithoutExt2 = filePath.replace(/\.(md|mdx)$/, "");
+    return `./markdown/${pathWithoutExt2}`;
+  }
+  const pathWithoutExt = filePath.replace(/\.(tsx|ts)$/, "");
+  return `../src/client/routes/${pathWithoutExt}`;
+}
 function generateTypeScript(tree) {
   const imports = [
-    ...tree.routes.map((r, i) => `import Route${i} from '../src/client/routes/${r.filePath.replace(/\.(tsx|ts)$/, "")}';`),
-    ...tree.layouts.map((l, i) => `import Layout${i} from '../src/client/routes/${l.filePath.replace(/\.(tsx|ts)$/, "")}';`),
-    ...tree.notFoundRoutes.map((nf, i) => `import NotFound${i} from '../src/client/routes/${nf.filePath.replace(/\.(tsx|ts)$/, "")}';`)
+    ...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)}';`)
   ].join(`
 `);
   const routesArray = tree.routes.map((r, i) => {
@@ -534,7 +985,7 @@ function matchPattern(pattern: string, pathname: string): Record<string, string>
 async function listContentFiles(collectionDir) {
   try {
     const entries = await readdir2(collectionDir, { withFileTypes: true });
-    return entries.filter((e) => e.isFile() && /\.(tsx|ts)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name);
+    return entries.filter((e) => e.isFile() && /\.(tsx|ts|md|mdx)$/.test(e.name) && !e.name.startsWith("_")).map((e) => e.name);
   } catch {
     return [];
   }
@@ -548,7 +999,7 @@ async function sha8(text) {
   return hex.slice(0, 8);
 }
 async function buildContentChunks(cwd) {
-  const routesRoot = join3(cwd, ROUTES_DIR);
+  const routesRoot = join5(cwd, ROUTES_DIR);
   console.log(`[reroute/content] scan ${routesRoot}`);
   const collections = await readdir2(routesRoot, { withFileTypes: true });
   const results = [];
@@ -556,20 +1007,31 @@ async function buildContentChunks(cwd) {
     if (!c.isDirectory())
       continue;
     const collection = c.name;
-    const contentDir = join3(routesRoot, collection, "content");
+    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(",")}`);
     if (!files.length)
       continue;
     for (const file of files) {
-      const name = file.replace(/\.(tsx|ts)$/, "");
-      const absSrc = join3(contentDir, file);
+      const name = file.replace(/\.(tsx|ts|md|mdx)$/, "");
+      const absSrc = join5(contentDir, file);
+      const isMarkdown = /\.(md|mdx)$/.test(file);
+      const buildSrc = isMarkdown ? join5(cwd, ".reroute", "markdown", collection, "content", `${name}.tsx`) : absSrc;
+      if (isMarkdown) {
+        try {
+          const exists = await Bun.file(buildSrc).exists();
+          if (!exists) {
+            console.warn(`[reroute/content] Converted markdown missing, skipping: ${buildSrc}`);
+            continue;
+          }
+        } catch {}
+      }
       let code = "";
       try {
-        console.log(`[reroute/content] build ${absSrc}`);
+        console.log(`[reroute/content] build ${buildSrc}`);
         const result = await Bun.build({
-          entrypoints: [absSrc],
+          entrypoints: [buildSrc],
           target: "browser",
           format: "esm",
           splitting: false,
@@ -587,10 +1049,10 @@ async function buildContentChunks(cwd) {
         continue;
       }
       const hash = await sha8(code);
-      const chunkRelDir = join3(".reroute", "chunks", collection);
-      const chunkAbsDir = join3(cwd, chunkRelDir);
+      const chunkRelDir = join5(".reroute", "chunks", collection);
+      const chunkAbsDir = join5(cwd, chunkRelDir);
       const outFile = `${name}.${hash}.js`;
-      const absOut = join3(chunkAbsDir, outFile);
+      const absOut = join5(chunkAbsDir, outFile);
       await mkdir2(chunkAbsDir, { recursive: true });
       try {
         const exists = await Bun.file(absOut).exists();
@@ -599,8 +1061,8 @@ async function buildContentChunks(cwd) {
       } catch {}
       let meta = {};
       try {
-        console.log(`[reroute/content] meta ${absSrc}`);
-        const url = `${pathToFileURL(absSrc).href}?t=${Date.now()}`;
+        console.log(`[reroute/content] meta ${buildSrc}`);
+        const url = `${pathToFileURL(buildSrc).href}?t=${Date.now()}`;
         const m = await import(url);
         meta = m.meta || {};
       } catch {}
@@ -640,12 +1102,12 @@ async function buildContentChunks(cwd) {
   lines.push("  return m ? (m as Record<string, any>)[name] : undefined;");
   lines.push("}");
   lines.push("");
-  await mkdir2(join3(cwd, ".reroute"), { recursive: true });
-  await writeFile2(join3(cwd, OUTPUT_CONTENT_TS), lines.join(`
+  await mkdir2(join5(cwd, ".reroute"), { recursive: true });
+  await writeFile2(join5(cwd, OUTPUT_CONTENT_TS), lines.join(`
 `), "utf-8");
-  console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_CONTENT_TS)}`);
+  console.log(`[reroute/content] wrote ${join5(cwd, OUTPUT_CONTENT_TS)}`);
   const collectionsSet = new Set(results.map((r) => r.collection));
-  await mkdir2(join3(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
+  await mkdir2(join5(cwd, OUTPUT_COLLECTIONS_DIR), { recursive: true });
   for (const collection of collectionsSet) {
     const items = results.filter((r) => r.collection === collection);
     const js = [];
@@ -665,31 +1127,100 @@ async function buildContentChunks(cwd) {
     js.push("  return byName[name];");
     js.push("}");
     js.push("");
-    await writeFile2(join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
+    await writeFile2(join5(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`), js.join(`
 `), "utf-8");
-    console.log(`[reroute/content] wrote ${join3(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
+    console.log(`[reroute/content] wrote ${join5(cwd, OUTPUT_COLLECTIONS_DIR, `${collection}.js`)}`);
+  }
+}
+async function preprocessMarkdownFiles(cwd) {
+  console.log("[reroute/markdown] Starting markdown preprocessing...");
+  const routesPath = join5(cwd, ROUTES_DIR);
+  const markdownDir = join5(cwd, ".reroute", "markdown");
+  try {
+    await rm(markdownDir, { force: true, recursive: true });
+  } 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 {
+      const entries = await readdir2(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join5(dir, entry.name);
+        const relativePath = join5(base, entry.name);
+        if (entry.isDirectory()) {
+          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);
+        }
+      }
+    } catch (err) {
+      console.error(`[reroute/markdown] Error scanning ${dir}:`, err);
+    }
+    return files;
+  }
+  console.log(`[reroute/markdown] Scanning ${routesPath} for markdown files...`);
+  const markdownFiles = await scanMarkdown(routesPath);
+  console.log(`[reroute/markdown] Scan complete. Found files:`, markdownFiles);
+  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"));
+    try {
+      const processed = processMarkdownFile(sourcePath);
+      const isMdx = file.endsWith(".mdx");
+      let moduleCode;
+      if (markdownConfig.isConfigured) {
+        moduleCode = await generateMarkdownModule(processed, cwd, {
+          enableGfm: markdownConfig.hasRemarkGfm,
+          theme: "github-dark",
+          isMdx
+        });
+      } 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}`);
+    } catch (error) {
+      console.error(`[reroute/markdown] Failed to process ${file}:`, error);
+    }
   }
 }
 async function generate(cwd) {
   console.log("[reroute/gen] Starting generation...");
   await cleanupOutputDir(cwd);
-  const routesPath = join3(cwd, ROUTES_DIR);
+  await preprocessMarkdownFiles(cwd);
+  const routesPath = join5(cwd, ROUTES_DIR);
   try {
     const files = await scanDirectory(routesPath);
     const nfFiles = await scan404Files(routesPath);
     const all = Array.from(new Set([...files, ...nfFiles]));
     const tree = generateRouteTree(all.map((f) => f.replace(/\\/g, "/")));
     const ts = generateTypeScript(tree);
-    await mkdir2(join3(cwd, ".reroute"), { recursive: true });
-    await writeFile2(join3(cwd, OUTPUT_ROUTES), ts, "utf-8");
-    console.log(`[reroute/gen] Generated routes: ${join3(cwd, OUTPUT_ROUTES)}`);
+    await mkdir2(join5(cwd, ".reroute"), { recursive: true });
+    await writeFile2(join5(cwd, OUTPUT_ROUTES), ts, "utf-8");
+    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);
-    console.log(`[reroute/gen] Generated content: ${join3(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
+    console.log(`[reroute/gen] Generated content: ${join5(cwd, OUTPUT_CONTENT_TS)} + collections/*.js`);
   } catch (error) {
     console.error("[reroute/gen] Failed to generate content:", error);
     throw error;
@@ -709,10 +1240,10 @@ async function generate(cwd) {
   indexLines.push("} as const;");
   indexLines.push("");
   indexLines.push("export type RerouteArtifacts = typeof artifacts;");
-  await writeFile2(join3(cwd, OUTPUT_INDEX), indexLines.join(`
+  await writeFile2(join5(cwd, OUTPUT_INDEX), indexLines.join(`
 `), "utf-8");
-  console.log(`[reroute/gen] Generated index: ${join3(cwd, OUTPUT_INDEX)}`);
-  console.log("[reroute/gen] ✅ Generation complete!");
+  console.log(`[reroute/gen] Generated index: ${join5(cwd, OUTPUT_INDEX)}`);
+  console.log("[reroute/gen] Generation complete");
 }
 async function gen(args) {
   const cwd = process.cwd();
@@ -720,6 +1251,7 @@ async function gen(args) {
   if (!watchMode) {
     await generate(cwd);
     await buildTailwindIfConfigured(cwd);
+    checkMarkdownIfConfigured(cwd);
     return;
   }
   console.log("[reroute/gen] Watch mode enabled");
@@ -727,6 +1259,7 @@ async function gen(args) {
   await generate(cwd);
   try {
     await buildTailwindIfConfigured(cwd);
+    checkMarkdownIfConfigured(cwd);
   } catch {}
   const notifyReload = async (reason) => {
     const ports = [
@@ -745,7 +1278,7 @@ async function gen(args) {
       } catch {}
     }
   };
-  const routesPath = join3(cwd, ROUTES_DIR);
+  const routesPath = join5(cwd, ROUTES_DIR);
   console.log(`[reroute/gen] Watching ${routesPath} for changes...`);
   let debounce = null;
   const routesWatcher = watch(routesPath, { recursive: true }, (_ev, filename) => {
@@ -764,7 +1297,7 @@ async function gen(args) {
       }
     }, 120);
   });
-  const clientPath = join3(cwd, "src", "client");
+  const clientPath = join5(cwd, "src", "client");
   console.log(`[reroute/gen] Watching ${clientPath} for Tailwind class changes...`);
   let twDebounce = null;
   const twWatcher = watch(clientPath, { recursive: true }, (_ev, filename) => {
@@ -800,6 +1333,8 @@ async function gen(args) {
 }
 var ROUTES_DIR = "src/client/routes", OUTPUT_DIR = ".reroute", OUTPUT_ROUTES = ".reroute/routes.ts", OUTPUT_CONTENT_TS = ".reroute/content.ts", OUTPUT_COLLECTIONS_DIR = ".reroute/collections", OUTPUT_INDEX = ".reroute/index.ts";
 var init_gen = __esm(() => {
+  init_markdown();
+  init_markdown_processor();
   init_tailwind();
 });
 
@@ -809,20 +1344,20 @@ __export(exports_boot, {
   default: () => boot
 });
 import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { join as join4 } from "node:path";
+import { join as join6 } from "node:path";
 async function boot(_) {
   const cwd = process.cwd();
   try {
     console.log("[reroute/boot] Initializing .reroute directory...");
-    await mkdir3(join4(cwd, OUTPUT_DIR2), { recursive: true });
-    await mkdir3(join4(cwd, OUTPUT_COLLECTIONS_DIR2), { recursive: true });
-    await writeFile3(join4(cwd, OUTPUT_ROUTES2), STUB_ROUTES, "utf-8");
+    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(join4(cwd, OUTPUT_CONTENT_TS2), STUB_CONTENT, "utf-8");
+    await writeFile3(join6(cwd, OUTPUT_CONTENT_TS2), STUB_CONTENT, "utf-8");
     console.log(`[reroute/boot] Created stub: ${OUTPUT_CONTENT_TS2}`);
-    await writeFile3(join4(cwd, OUTPUT_INDEX2), STUB_INDEX, "utf-8");
+    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] 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);
@@ -866,12 +1401,692 @@ export type RerouteArtifacts = typeof artifacts;
 `;
 var init_boot = () => {};
 
+// packages/cli/src/libs/log.ts
+function colorizeLogPrefix(text) {
+  let colored = text;
+  const sortedPrefixes = Object.entries(PREFIX_COLORS).sort(([a], [b]) => b.length - a.length);
+  for (const [prefix, colorTag] of sortedPrefixes) {
+    colored = colored.replace(new RegExp(`(${prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})`, "g"), `${colorTag}$1{/}`);
+  }
+  return colored;
+}
+function blessedToAnsi(text) {
+  return text.replace(/\{cyan-fg\}/g, "\x1B[36m").replace(/\{blue-fg\}/g, "\x1B[34m").replace(/\{magenta-fg\}/g, "\x1B[35m").replace(/\{yellow-fg\}/g, "\x1B[33m").replace(/\{green-fg\}/g, "\x1B[32m").replace(/\{red-fg\}/g, "\x1B[31m").replace(/\{bright-cyan-fg\}/g, "\x1B[96m").replace(/\{bright-blue-fg\}/g, "\x1B[94m").replace(/\{bright-magenta-fg\}/g, "\x1B[95m").replace(/\{bright-yellow-fg\}/g, "\x1B[93m").replace(/\{bright-green-fg\}/g, "\x1B[92m").replace(/\{bright-red-fg\}/g, "\x1B[91m").replace(/\{\/\}/g, "\x1B[0m");
+}
+function colorizeLogPrefixAnsi(text) {
+  return blessedToAnsi(colorizeLogPrefix(text));
+}
+function createServerOutputHandler(buffer) {
+  return (data) => {
+    const text = buffer.current + data.toString();
+    const lines = text.split(`
+`);
+    buffer.current = lines.pop() || "";
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine) {
+        continue;
+      }
+      const ansiColored = colorizeLogPrefixAnsi(line);
+      console.log(ansiColored);
+    }
+  };
+}
+var PREFIX_COLORS;
+var init_log = __esm(() => {
+  PREFIX_COLORS = {
+    "[reroute]": "{cyan-fg}",
+    "[reroute/gen]": "{bright-blue-fg}",
+    "[reroute/content]": "{magenta-fg}",
+    "[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}",
+    "[api]": "{blue-fg}",
+    "[app]": "{bright-green-fg}"
+  };
+});
+
+// packages/cli/src/commands/dev.ts
+var exports_dev = {};
+__export(exports_dev, {
+  default: () => dev
+});
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join7 } from "node:path";
+function getRerouteCommand() {
+  const binPath = join7(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")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync5(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+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
+`);
+    const rerouteCmd = getRerouteCommand();
+    const useShell = rerouteCmd.includes(" ");
+    const genCommand = useShell ? `${rerouteCmd} gen --watch` : rerouteCmd;
+    const genArgs = useShell ? [] : ["gen", "--watch"];
+    const genProcess = spawn2(genCommand, genArgs, {
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: useShell
+    });
+    const serverProcess = spawn2("bun", ["--watch", "src/index.ts"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (singleColumn) {
+      const genBuffer = { current: "" };
+      const serverBuffer = { current: "" };
+      const handleGenOutput = (data) => {
+        const text = genBuffer.current + data.toString();
+        const lines = text.split(`
+`);
+        genBuffer.current = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) {
+            continue;
+          }
+          const ansiColored = colorizeLogPrefixAnsi(line);
+          console.log(ansiColored);
+        }
+      };
+      const handleServerOutput = createServerOutputHandler(serverBuffer);
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      serverProcess.stdout?.on("data", handleServerOutput);
+      serverProcess.stderr?.on("data", handleServerOutput);
+      genProcess.on("exit", (code) => {
+        console.log(`
+[reroute/gen] Process exited with code ${code}`);
+      });
+      serverProcess.on("exit", (code) => {
+        console.log(`
+[server] Process exited with code ${code}`);
+      });
+      process.on("SIGINT", () => {
+        console.log(`
+[reroute/dev] Shutting down...`);
+        genProcess.kill("SIGINT");
+        serverProcess.kill("SIGINT");
+        process.exit(0);
+      });
+    } else {
+      const blessed = await import("blessed");
+      const contrib = await import("blessed-contrib");
+      const screen = blessed.default.screen({
+        smartCSR: true,
+        title: "reroute dev",
+        mouse: true
+      });
+      const grid = new contrib.default.grid({
+        rows: 1,
+        cols: 2,
+        screen
+      });
+      const genBox = grid.set(0, 0, 1, 1, blessed.default.log, {
+        label: " reroute gen --watch ",
+        border: { type: "line" },
+        style: {
+          border: { fg: "cyan" }
+        },
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+          ch: " ",
+          inverse: true
+        },
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        input: true,
+        clickable: true
+      });
+      const serverBox = grid.set(0, 1, 1, 1, blessed.default.log, {
+        label: " bun --watch src/index.ts ",
+        border: { type: "line" },
+        style: {
+          border: { fg: "green" }
+        },
+        scrollable: true,
+        alwaysScroll: true,
+        scrollbar: {
+          ch: " ",
+          inverse: true
+        },
+        tags: true,
+        keys: true,
+        vi: true,
+        mouse: true,
+        input: true,
+        clickable: true
+      });
+      genBox.key(["up", "k"], () => {
+        genBox.scroll(-1);
+        screen.render();
+      });
+      genBox.key(["down", "j"], () => {
+        genBox.scroll(1);
+        screen.render();
+      });
+      genBox.key(["pageup"], () => {
+        genBox.scroll(-genBox.height);
+        screen.render();
+      });
+      genBox.key(["pagedown"], () => {
+        genBox.scroll(genBox.height);
+        screen.render();
+      });
+      genBox.key(["home", "g"], () => {
+        genBox.setScrollPerc(0);
+        screen.render();
+      });
+      genBox.key(["end", "G"], () => {
+        genBox.setScrollPerc(100);
+        screen.render();
+      });
+      serverBox.key(["up", "k"], () => {
+        serverBox.scroll(-1);
+        screen.render();
+      });
+      serverBox.key(["down", "j"], () => {
+        serverBox.scroll(1);
+        screen.render();
+      });
+      serverBox.key(["pageup"], () => {
+        serverBox.scroll(-serverBox.height);
+        screen.render();
+      });
+      serverBox.key(["pagedown"], () => {
+        serverBox.scroll(serverBox.height);
+        screen.render();
+      });
+      serverBox.key(["home", "g"], () => {
+        serverBox.setScrollPerc(0);
+        screen.render();
+      });
+      serverBox.key(["end", "G"], () => {
+        serverBox.setScrollPerc(100);
+        screen.render();
+      });
+      genBox.on("wheeldown", () => {
+        genBox.scroll(3);
+        screen.render();
+      });
+      genBox.on("wheelup", () => {
+        genBox.scroll(-3);
+        screen.render();
+      });
+      serverBox.on("wheeldown", () => {
+        serverBox.scroll(3);
+        screen.render();
+      });
+      serverBox.on("wheelup", () => {
+        serverBox.scroll(-3);
+        screen.render();
+      });
+      genBox.on("click", () => {
+        genBox.focus();
+        screen.render();
+      });
+      serverBox.on("click", () => {
+        serverBox.focus();
+        screen.render();
+      });
+      screen.key(["tab"], () => {
+        if (screen.focused === genBox) {
+          serverBox.focus();
+        } else {
+          genBox.focus();
+        }
+        screen.render();
+      });
+      genBox.focus();
+      screen.render();
+      genProcess.stdout?.on("data", (data) => {
+        const text = data.toString();
+        const lines = text.split(`
+`).filter((line) => line.trim());
+        if (lines.length > 0) {
+          const colored = colorizeLogPrefix(lines.join(`
+`));
+          genBox.log(colored);
+          screen.render();
+        }
+      });
+      genProcess.stderr?.on("data", (data) => {
+        const text = data.toString();
+        const lines = text.split(`
+`).filter((line) => line.trim());
+        if (lines.length > 0) {
+          const colored = colorizeLogPrefix(lines.join(`
+`));
+          genBox.log(colored);
+          screen.render();
+        }
+      });
+      serverProcess.stdout?.on("data", (data) => {
+        const text = data.toString();
+        const filteredText = text.split(`
+`).filter((line) => line.trim()).join(`
+`);
+        if (filteredText) {
+          const colored = colorizeLogPrefix(filteredText);
+          serverBox.log(colored);
+          screen.render();
+        }
+      });
+      serverProcess.stderr?.on("data", (data) => {
+        const text = data.toString();
+        const filteredText = text.split(`
+`).filter((line) => line.trim()).join(`
+`);
+        if (filteredText) {
+          const colored = colorizeLogPrefix(filteredText);
+          serverBox.log(colored);
+          screen.render();
+        }
+      });
+      genProcess.on("exit", (code) => {
+        genBox.log(`
+[Process exited with code ${code}]`);
+        screen.render();
+      });
+      serverProcess.on("exit", (code) => {
+        serverBox.log(`
+[Process exited with code ${code}]`);
+        screen.render();
+      });
+      screen.key(["escape", "q", "C-c"], () => {
+        genProcess.kill("SIGINT");
+        serverProcess.kill("SIGINT");
+        screen.destroy();
+        process.exit(0);
+      });
+      screen.on("resize", () => {
+        screen.render();
+      });
+    }
+  } catch (error) {
+    if (error.code === "SIGINT") {
+      console.log(`
+[reroute/dev] Shutting down...`);
+      process.exit(0);
+    }
+    console.error("[reroute/dev] Error:", error);
+    throw error;
+  }
+}
+var init_dev = __esm(() => {
+  init_log();
+  init_boot();
+});
+
+// packages/cli/src/commands/start.ts
+var exports_start = {};
+__export(exports_start, {
+  default: () => start
+});
+import { spawn as spawn3 } from "node:child_process";
+import { existsSync as existsSync6 } from "node:fs";
+import { join as join8 } from "node:path";
+function getRerouteCommand2() {
+  const binPath = join8(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")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync6(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+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(`
+`);
+      genBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        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"];
+    await new Promise((resolve, reject) => {
+      const genProcess = spawn3(genCommand, genArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      genProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Gen exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      genProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/start] Generation complete
+`));
+    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"]
+    });
+    const serverBuffer = { current: "" };
+    const handleServerOutput = createServerOutputHandler(serverBuffer);
+    serverProcess.stdout?.on("data", handleServerOutput);
+    serverProcess.stderr?.on("data", handleServerOutput);
+    process.on("SIGINT", () => {
+      process.stdout.write(`${colorizeLogPrefixAnsi(`
+[reroute/start] Shutting down...`)}
+`);
+      serverProcess.kill("SIGINT");
+      process.exit(0);
+    });
+    await new Promise((resolve, reject) => {
+      serverProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          console.error(colorizeLogPrefixAnsi(`[reroute/start] Server exited with code ${code}`));
+          reject(new Error(`Server exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      serverProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  } catch (error) {
+    if (error.code === "SIGINT") {
+      process.stdout.write(`${colorizeLogPrefixAnsi(`
+[reroute/start] Shutting down...`)}
+`);
+      process.exit(0);
+    }
+    process.stderr.write(`${colorizeLogPrefixAnsi("[reroute/start] Error: ") + String(error)}
+`);
+    throw error;
+  }
+}
+var init_start = __esm(() => {
+  init_log();
+});
+
+// packages/cli/src/commands/build.ts
+var exports_build = {};
+__export(exports_build, {
+  default: () => 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";
+function getRerouteCommand3() {
+  const binPath = join9(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")
+  ];
+  for (const binPath2 of nodeModulesPaths) {
+    if (existsSync7(binPath2)) {
+      return binPath2;
+    }
+  }
+  return "reroute";
+}
+function getOutputName() {
+  const cwd = process.cwd();
+  const packageJsonPath = join9(cwd, "package.json");
+  if (existsSync7(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync4(packageJsonPath, "utf-8"));
+      const name = packageJson.name;
+      if (name) {
+        const parts = name.split("-");
+        if (parts.length > 1 && parts[parts.length - 1] === "example") {
+          return parts[parts.length - 2] || "app";
+        }
+        return parts[parts.length - 1] || name;
+      }
+    } catch {}
+  }
+  return "app";
+}
+async function build(args) {
+  try {
+    const rerouteCmd = getRerouteCommand3();
+    const useShell = rerouteCmd.includes(" ");
+    let outputPath = `./dist/${getOutputName()}`;
+    const outfileIndex = args.indexOf("--outfile");
+    const shortOutfileIndex = args.indexOf("-o");
+    const outfileArgIndex = outfileIndex !== -1 ? outfileIndex : shortOutfileIndex;
+    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(`
+`);
+      genBuffer.current = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+        const ansiColored = colorizeLogPrefixAnsi(line);
+        console.log(ansiColored);
+      }
+    };
+    process.stdout.write(`${colorizeLogPrefixAnsi("[reroute/build] Running boot...")}
+`);
+    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"];
+    await new Promise((resolve, reject) => {
+      const genProcess = spawn4(genCommand, genArgs, {
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: useShell
+      });
+      genProcess.stdout?.on("data", handleGenOutput);
+      genProcess.stderr?.on("data", handleGenOutput);
+      genProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Gen exited with code ${code}`));
+        } else {
+          resolve();
+        }
+      });
+      genProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+    process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Generation complete
+`));
+    process.stdout.write(`${colorizeLogPrefixAnsi(`[reroute/build] Building binary to ${outputPath}...`)}
+`);
+    const isProduction = true;
+    const buildArgs = ["build", "src/index.ts", "--target", "bun", "--compile"];
+    if (isProduction) {
+      buildArgs.push("--minify");
+    }
+    const filteredArgs = args.filter((arg, idx) => {
+      if (outfileArgIndex !== -1) {
+        if (idx === outfileArgIndex || idx === outfileArgIndex + 1) {
+          return false;
+        }
+      }
+      return arg !== "--outfile" && arg !== "-o" && arg !== "--minify" && arg !== "--no-minify";
+    });
+    buildArgs.push(...filteredArgs, "--outfile", outputPath);
+    await new Promise((resolve, reject) => {
+      const buildProcess = spawn4("bun", buildArgs, {
+        stdio: "inherit"
+      });
+      buildProcess.on("exit", (code) => {
+        if (code !== null && code !== 0) {
+          reject(new Error(`Build exited with code ${code}`));
+        } else {
+          process.stdout.write(colorizeLogPrefixAnsi(`[reroute/build] Build complete: ${outputPath}
+`));
+          resolve();
+        }
+      });
+      buildProcess.on("error", (error) => {
+        reject(error);
+      });
+    });
+  } catch (error) {
+    process.stderr.write(`${colorizeLogPrefixAnsi("[reroute/build] Error: ") + String(error)}
+`);
+    throw error;
+  }
+}
+var init_build = __esm(() => {
+  init_log();
+});
+
 // packages/cli/src/cli.ts
 import path2 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))
+  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))
 };
 async function main() {
   const args = process.argv.slice(2);
@@ -900,25 +2115,49 @@ async function main() {
   }
 }
 async function printHelp2() {
+  console.log("");
   console.log(await getVersionString2());
   console.log("");
+  console.log("");
   console.log("Usage:");
+  console.log("");
   console.log("  reroute <command> [options]");
   console.log("");
+  console.log("");
   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("  init        Scaffold a new Reroute project");
+  console.log("  dev         Start development environment");
+  console.log("  start       Run production-like server locally");
+  console.log("  build       Build production binary");
+  console.log("");
   console.log("");
   console.log("Options:");
+  console.log("");
   console.log("  -h, --help     Show help");
   console.log("  -v, --version  Show version");
   console.log("");
+  console.log("");
   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");
   console.log("  reroute gen --watch");
-  console.log("  reroute init my-app");
+  console.log("");
+  console.log("  reroute dev");
+  console.log("  reroute dev -s");
+  console.log("  reroute dev --single");
+  console.log("");
+  console.log("  reroute start");
+  console.log("");
+  console.log("  reroute build");
+  console.log("  reroute build -o ./dist/myapp");
+  console.log("  reroute build --outfile ./dist/myapp");
 }
 async function getVersionString2() {
   const version = await getVersion2();
@@ -927,7 +2166,7 @@ async function getVersionString2() {
 }
 async function getVersion2() {
   if (true) {
-    return "0.5.0";
+    return "0.7.0";
   }
   const possiblePaths = [
     path2.join(import.meta.dir, "../../../package.json"),
@@ -944,10 +2183,10 @@ async function getVersion2() {
 }
 async function getCommit2() {
   if (true) {
-    return "68dd984";
+    return "4b119c0";
   }
   return "dev";
 }
 main();
 
-//# debugId=4C1324A287CB7DC364756E2164756E21
+//# debugId=B8066BB70A3F2A9464756E2164756E21