raktajs 0.1.0

package/dist/cli/rakta.js

@@ -0,0 +1,1511 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli/rakta.ts
+import { join as join17 } from "path";
+
+// src/config/loadConfig.ts
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+
+// src/config/defineConfig.ts
+var defaultConfig = {
+  appName: "Rakta.js App",
+  appDir: "app",
+  publicDir: "public",
+  port: 3000,
+  css: {
+    framework: "tailwind"
+  },
+  seo: {
+    defaultTitle: "Rakta.js App",
+    titleTemplate: "%s | Rakta.js App",
+    defaultDescription: "Built with Rakta.js",
+    siteUrl: "http://localhost:3000"
+  },
+  server: {
+    port: 3000,
+    hostname: "0.0.0.0",
+    cors: true,
+    compression: false,
+    trustProxy: false
+  },
+  build: {
+    entryPoint: "entry.client.tsx",
+    outDir: "dist",
+    sourcemap: false,
+    minify: true,
+    splitting: false,
+    target: "browser"
+  },
+  autoImport: {
+    enabled: false,
+    directories: ["components", "lib", "stores", "schemas"],
+    outputDirectory: ".rakta",
+    extensions: [".ts", ".tsx", ".js", ".jsx"],
+    dts: true
+  },
+  rpc: {
+    enabled: false,
+    basePath: "/rpc",
+    maxBodySize: 1048576
+  },
+  render: {
+    defaultMode: "csr",
+    routes: {}
+  }
+};
+
+// src/config/loadConfig.ts
+var CONFIG_FILENAMES = [
+  "rakta.config.ts",
+  "rakta.config.js",
+  "rakta.config.mts",
+  "rakta.config.mjs"
+];
+async function loadConfig(cwd = process.cwd()) {
+  const resolvedCwd = resolve(cwd);
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = join(resolvedCwd, filename);
+    if (!existsSync(configPath)) {
+      continue;
+    }
+    const configModule = await import(configPath);
+    const userConfig = configModule.default ?? {};
+    return mergeConfig(defaultConfig, userConfig);
+  }
+  return defaultConfig;
+}
+function mergeConfig(baseConfig, overrideConfig) {
+  return {
+    appName: overrideConfig.appName ?? baseConfig.appName,
+    appDir: overrideConfig.appDir ?? baseConfig.appDir,
+    publicDir: overrideConfig.publicDir ?? baseConfig.publicDir,
+    port: overrideConfig.port ?? baseConfig.port,
+    css: overrideConfig.css !== undefined ? { ...baseConfig.css, ...overrideConfig.css } : baseConfig.css,
+    seo: overrideConfig.seo !== undefined ? { ...baseConfig.seo, ...overrideConfig.seo } : baseConfig.seo,
+    server: overrideConfig.server !== undefined ? { ...baseConfig.server, ...overrideConfig.server } : baseConfig.server,
+    build: overrideConfig.build !== undefined ? { ...baseConfig.build, ...overrideConfig.build } : baseConfig.build,
+    autoImport: overrideConfig.autoImport !== undefined ? { ...baseConfig.autoImport, ...overrideConfig.autoImport } : baseConfig.autoImport,
+    rpc: overrideConfig.rpc !== undefined ? { ...baseConfig.rpc, ...overrideConfig.rpc } : baseConfig.rpc,
+    render: overrideConfig.render !== undefined ? {
+      defaultMode: overrideConfig.render.defaultMode ?? baseConfig.render.defaultMode,
+      routes: {
+        ...baseConfig.render.routes,
+        ...overrideConfig.render.routes
+      }
+    } : baseConfig.render
+  };
+}
+
+// src/forge/inspect.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/render/modes.ts
+var RENDER_MODE_DESCRIPTORS = {
+  csr: {
+    mode: "csr",
+    label: "Client-Side Rendering",
+    shortLabel: "CSR",
+    description: "React renders entirely in the browser. The server sends a minimal HTML shell with a JS bundle. No server required at runtime.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  },
+  ssr: {
+    mode: "ssr",
+    label: "Server-Side Rendering",
+    shortLabel: "SSR",
+    description: "React renders to HTML on the server per request. The client receives full HTML and then hydrates. Requires a running Node/Bun server.",
+    serverRequired: true,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: true
+  },
+  ssg: {
+    mode: "ssg",
+    label: "Static Site Generation",
+    shortLabel: "SSG",
+    description: "Pages are fully rendered at build time. Output is static HTML files. No server required at runtime.",
+    serverRequired: false,
+    buildTimeGenerated: true,
+    clientHydration: false,
+    roadmap: true
+  },
+  csg: {
+    mode: "csg",
+    label: "Client-Side Generation",
+    shortLabel: "CSG",
+    description: "A static shell is generated at build time, data is fetched and rendered on the client. Combines SSG speed with dynamic data.",
+    serverRequired: false,
+    buildTimeGenerated: true,
+    clientHydration: true,
+    roadmap: true
+  },
+  spa: {
+    mode: "spa",
+    label: "Single Page Application",
+    shortLabel: "SPA",
+    description: "A single HTML entry point is served for all routes. React handles all routing client-side. Equivalent to a standard Vite SPA.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  },
+  hybrid: {
+    mode: "hybrid",
+    label: "Hybrid Rendering",
+    shortLabel: "Hybrid",
+    description: "Different routes use different render modes. Configured via the `render.routes` map in rakta.config.ts. The top-level mode is the fallback.",
+    serverRequired: false,
+    buildTimeGenerated: false,
+    clientHydration: true,
+    roadmap: false
+  }
+};
+function pathMatchesPattern(pathname, pattern) {
+  if (pattern === pathname)
+    return true;
+  const patternParts = pattern.split("/");
+  const pathParts = pathname.split("/");
+  if (patternParts.length !== pathParts.length)
+    return false;
+  for (let i = 0;i < patternParts.length; i++) {
+    const pp = patternParts[i];
+    const path = pathParts[i];
+    if (pp === undefined || path === undefined)
+      return false;
+    if (pp.startsWith(":"))
+      continue;
+    if (pp !== path)
+      return false;
+  }
+  return true;
+}
+function resolveRouteMode(pathname, config) {
+  const patterns = Object.keys(config.routes).sort((a, b) => b.length - a.length);
+  for (const pattern of patterns) {
+    const overrideMode = config.routes[pattern];
+    if (overrideMode !== undefined && pathMatchesPattern(pathname, pattern)) {
+      return {
+        routePath: pathname,
+        mode: overrideMode,
+        source: "route-override"
+      };
+    }
+  }
+  return {
+    routePath: pathname,
+    mode: config.defaultMode,
+    source: "default"
+  };
+}
+function isRoadmapMode(mode) {
+  return RENDER_MODE_DESCRIPTORS[mode].roadmap;
+}
+
+// src/router/manifest.ts
+import { existsSync as existsSync3, readFileSync, writeFileSync } from "fs";
+
+// src/router/scanner.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join as join2, relative } from "path";
+var FILE_TO_KIND = {
+  "page.tsx": "page",
+  "page.ts": "page",
+  "page.jsx": "page",
+  "page.js": "page",
+  "layout.tsx": "layout",
+  "layout.ts": "layout",
+  "layout.jsx": "layout",
+  "layout.js": "layout",
+  "loading.tsx": "loading",
+  "loading.ts": "loading",
+  "loading.jsx": "loading",
+  "loading.js": "loading",
+  "notFound.tsx": "notFound",
+  "notFound.ts": "notFound",
+  "notFound.jsx": "notFound",
+  "notFound.js": "notFound",
+  "error.tsx": "error",
+  "error.ts": "error",
+  "error.jsx": "error",
+  "error.js": "error",
+  "route.ts": "api",
+  "route.js": "api"
+};
+function parseSegment(raw) {
+  const isDynamic = raw.startsWith("[") && raw.endsWith("]");
+  const paramName = isDynamic ? raw.slice(1, -1) : "";
+  return { raw, isDynamic, paramName };
+}
+function collectParamNames(segments) {
+  return segments.filter((segment) => segment.isDynamic && segment.paramName.length > 0).map((segment) => segment.paramName);
+}
+function segmentsToUrlPattern(segments) {
+  if (segments.length === 0)
+    return "/";
+  const parts = segments.map((segment) => segment.isDynamic && segment.paramName ? `:${segment.paramName}` : segment.raw);
+  return `/${parts.join("/")}`;
+}
+function scanDirectory(dirPath, appRoot, results) {
+  if (!existsSync2(dirPath))
+    return;
+  const entries = readdirSync(dirPath);
+  for (const entryName of entries) {
+    const fullPath = join2(dirPath, entryName);
+    const stats = statSync(fullPath);
+    if (stats.isDirectory()) {
+      scanDirectory(fullPath, appRoot, results);
+      continue;
+    }
+    if (!stats.isFile())
+      continue;
+    const kind = FILE_TO_KIND[entryName];
+    if (!kind)
+      continue;
+    const relativePath = relative(appRoot, fullPath).replace(/\\/g, "/");
+    const dirRelative = relative(appRoot, dirPath).replace(/\\/g, "/");
+    const rawSegments = dirRelative === "" ? [] : dirRelative.split("/");
+    const segments = rawSegments.map(parseSegment);
+    const urlPattern = segmentsToUrlPattern(segments);
+    const paramNames = collectParamNames(segments);
+    const isDynamic = paramNames.length > 0;
+    results.push({
+      filePath: relativePath,
+      urlPattern,
+      kind,
+      segments,
+      isDynamic,
+      paramNames
+    });
+  }
+}
+function scanRoutes(options) {
+  const results = [];
+  scanDirectory(options.appDir, options.appDir, results);
+  results.sort((routeA, routeB) => {
+    if (routeA.isDynamic !== routeB.isDynamic) {
+      return routeA.isDynamic ? 1 : -1;
+    }
+    return routeA.urlPattern.localeCompare(routeB.urlPattern);
+  });
+  return results;
+}
+
+// src/router/manifest.ts
+function generateManifest(appDir) {
+  const routes = scanRoutes({ appDir });
+  const manifest = {
+    version: "1",
+    generatedAt: new Date().toISOString(),
+    routes
+  };
+  return manifest;
+}
+function writeManifest(manifest, outputPath) {
+  writeFileSync(outputPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+function readManifest(manifestPath) {
+  if (!existsSync3(manifestPath))
+    return null;
+  const raw = readFileSync(manifestPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || !("routes" in parsed)) {
+    return null;
+  }
+  return parsed;
+}
+function printManifest(manifest) {
+  const pageRoutes = manifest.routes.filter((route) => route.kind === "page");
+  const apiRoutes = manifest.routes.filter((route) => route.kind === "api");
+  const layoutRoutes = manifest.routes.filter((route) => route.kind === "layout");
+  const specialRoutes = manifest.routes.filter((route) => ["loading", "not-found", "error"].includes(route.kind));
+  const line = "\u2500".repeat(56);
+  console.log(`
+  Rakta.js Route Manifest`);
+  console.log(`  ${line}`);
+  console.log(`  Generated: ${manifest.generatedAt}`);
+  console.log(`  Total:     ${manifest.routes.length} routes
+`);
+  if (pageRoutes.length > 0) {
+    console.log("  Pages:");
+    for (const route of pageRoutes) {
+      const dynamic = route.isDynamic ? `  [params: ${route.paramNames.join(", ")}]` : "";
+      console.log(`    GET  ${route.urlPattern}${dynamic}`);
+    }
+    console.log("");
+  }
+  if (apiRoutes.length > 0) {
+    console.log("  API Routes:");
+    for (const route of apiRoutes) {
+      const dynamic = route.isDynamic ? `  [params: ${route.paramNames.join(", ")}]` : "";
+      console.log(`    ANY  ${route.urlPattern}${dynamic}`);
+    }
+    console.log("");
+  }
+  if (layoutRoutes.length > 0) {
+    console.log("  Layouts:");
+    for (const route of layoutRoutes) {
+      console.log(`    ${route.urlPattern === "/" ? "root" : route.urlPattern}`);
+    }
+    console.log("");
+  }
+  if (specialRoutes.length > 0) {
+    console.log("  Special:");
+    for (const route of specialRoutes) {
+      console.log(`    [${route.kind}]  ${route.filePath}`);
+    }
+    console.log("");
+  }
+  console.log(`  ${line}
+`);
+}
+
+// src/forge/inspect.ts
+function detectArtifactKind(filename) {
+  if (filename === "route-manifest.json")
+    return "manifest";
+  if (filename.endsWith(".css"))
+    return "stylesheet";
+  if (filename.endsWith(".js") || filename.endsWith(".mjs"))
+    return "script";
+  return "asset";
+}
+function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+function scanDirectory2(dirPath) {
+  if (!existsSync4(dirPath))
+    return [];
+  const collected = [];
+  function walk(current) {
+    const entries = readdirSync2(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join3(current, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.isFile()) {
+        collected.push({
+          outputPath: full,
+          sizeBytes: statSync2(full).size,
+          kind: detectArtifactKind(entry.name)
+        });
+      }
+    }
+  }
+  walk(dirPath);
+  return collected;
+}
+function inspectBuild(options) {
+  const artifacts = scanDirectory2(options.outDir);
+  const manifestPath = join3(options.outDir, "route-manifest.json");
+  const manifest = readManifest(manifestPath);
+  const emptyManifest = {
+    version: "1",
+    generatedAt: new Date().toISOString(),
+    routes: []
+  };
+  const routeModes = (manifest ?? emptyManifest).routes.filter((r) => r.kind === "page" || r.kind === "api").map((r) => {
+    const resolved = resolveRouteMode(r.urlPattern, options.renderConfig);
+    return {
+      pattern: r.urlPattern,
+      mode: resolved.mode,
+      source: resolved.source
+    };
+  });
+  return {
+    buildDir: options.outDir,
+    artifacts,
+    manifest: manifest ?? emptyManifest,
+    routeModes,
+    totalSizeBytes: artifacts.reduce((sum, a) => sum + a.sizeBytes, 0),
+    inspectedAt: new Date().toISOString()
+  };
+}
+function printInspectReport(report) {
+  const sep = "\u2500".repeat(58);
+  console.log(`
+        
+ Rakta.js Forge - Build Inspection
+    `);
+  console.log(`
+        ${sep}
+    `);
+  console.log(`
+        Directory:  ${report.buildDir}
+    `);
+  console.log(`
+        Inspected:  ${report.inspectedAt}
+    `);
+  console.log(`
+        Total size: ${formatBytes(report.totalSizeBytes)}
+
+    `);
+  if (report.artifacts.length > 0) {
+    console.log("Artifacts:");
+    for (const artifact of report.artifacts) {
+      const rel = artifact.outputPath.replace(report.buildDir, ".").replace(/\\/g, "/");
+      console.log(`
+        [${artifact.kind.padEnd(10)}]  
+        ${rel.padEnd(38)}  
+        ${formatBytes(artifact.sizeBytes)}`);
+    }
+    console.log("");
+  }
+  if (report.routeModes.length > 0) {
+    console.log("Route Render Modes:");
+    for (const rm of report.routeModes) {
+      const src = rm.source === "route-override" ? "(override)" : "(default) ";
+      console.log(`
+        ${rm.mode.toUpperCase().padEnd(8)}  
+        ${rm.pattern.padEnd(36)}  ${src}`);
+    }
+    console.log("");
+  }
+  console.log(`${sep}
+`);
+}
+
+// src/cli/build.ts
+import { isAbsolute, join as join5 } from "path";
+
+// src/forge/build.ts
+import { mkdirSync } from "fs";
+import { join as join4, resolve as resolve2 } from "path";
+async function buildProject(options) {
+  const startMs = Date.now();
+  const artifacts = [];
+  const errors = [];
+  mkdirSync(resolve2(options.outDir), { recursive: true });
+  const manifest = generateManifest(options.appDir);
+  const manifestPath = join4(options.outDir, "route-manifest.json");
+  writeManifest(manifest, manifestPath);
+  const manifestContent = JSON.stringify(manifest);
+  artifacts.push({
+    outputPath: manifestPath,
+    sizeBytes: new TextEncoder().encode(manifestContent).byteLength,
+    kind: "manifest"
+  });
+  const buildResult = await Bun.build({
+    entrypoints: [options.entryPoint],
+    outdir: options.outDir,
+    target: options.target,
+    minify: options.minify,
+    sourcemap: options.sourcemap ? "external" : "none",
+    splitting: options.splitting,
+    naming: {
+      entry: "[name].[ext]",
+      chunk: "chunks/[name]-[hash].[ext]",
+      asset: "assets/[name]-[hash].[ext]"
+    }
+  });
+  if (!buildResult.success) {
+    for (const log of buildResult.logs) {
+      errors.push(log.message);
+    }
+    return {
+      success: false,
+      artifacts,
+      manifest,
+      buildMs: Date.now() - startMs,
+      errors
+    };
+  }
+  for (const output of buildResult.outputs) {
+    artifacts.push({
+      outputPath: output.path,
+      sizeBytes: output.size,
+      kind: output.path.endsWith(".css") ? "stylesheet" : "script"
+    });
+  }
+  return {
+    success: true,
+    artifacts,
+    manifest,
+    buildMs: Date.now() - startMs,
+    errors: []
+  };
+}
+
+// src/cli/build.ts
+function resolveProjectPath(cwd, pathValue) {
+  if (isAbsolute(pathValue)) {
+    return pathValue;
+  }
+  return join5(cwd, pathValue);
+}
+async function buildCommand(cwd = process.cwd()) {
+  const projectConfig = await loadConfig(cwd);
+  const appDirectory = projectConfig.appDir ?? "app";
+  const publicDirectory = projectConfig.publicDir ?? "public";
+  const outputDirectory = projectConfig.build.outDir ?? "dist";
+  const entryFile = projectConfig.build.entryPoint ?? "entry.client.tsx";
+  const entryPoint = resolveProjectPath(join5(cwd, appDirectory), entryFile);
+  const outDir = resolveProjectPath(cwd, outputDirectory);
+  console.log(`
+  Building Rakta.js application...
+`);
+  const buildResult = await buildProject({
+    entryPoint,
+    outDir,
+    appDir: join5(cwd, appDirectory),
+    publicDir: join5(cwd, publicDirectory),
+    appName: projectConfig.appName,
+    sourcemap: projectConfig.build.sourcemap ?? false,
+    minify: projectConfig.build.minify ?? true,
+    splitting: projectConfig.build.splitting ?? false,
+    target: projectConfig.build.target ?? "browser",
+    renderConfig: projectConfig.render
+  });
+  if (!buildResult.success) {
+    console.error("Build failed:");
+    for (const buildError of buildResult.errors) {
+      console.error(`${buildError}`);
+    }
+    process.exit(1);
+  }
+  console.log(`Build complete in ${buildResult.buildMs}ms`);
+  console.log(`Output: ${outDir}`);
+  console.log(`Artifacts: ${buildResult.artifacts.length}
+`);
+}
+
+// src/cli/dev.ts
+import { join as join7 } from "path";
+
+// src/forge/devServer.ts
+import { existsSync as existsSync5, readFileSync as readFileSync2 } from "fs";
+import { join as join6 } from "path";
+
+// src/render/renderer.ts
+function buildHtmlShell(options) {
+  return `
+  <!DOCTYPE html>
+    <html lang="${options.lang}">
+        <head>
+            <meta charset="UTF-8" />
+            <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+            <title>
+                ${options.appName}
+            </title>
+            <link rel="stylesheet" href="${options.cssPath}" />
+        </head>
+        <body>
+            <div id="rakta-root"></div>
+            <script type="module" src="${options.scriptPath}"></script>
+        </body>
+    </html>`;
+}
+function makeSuccess(html, mode, renderMs, httpStatus = 200, fromCache = false) {
+  return {
+    kind: "success",
+    html,
+    mode,
+    httpStatus,
+    responseHeaders: { "Content-Type": "text/html; charset=utf-8" },
+    fromCache,
+    renderMs
+  };
+}
+function makeFailure(reason, mode, httpStatus = 500) {
+  return { kind: "failure", reason, mode, httpStatus };
+}
+async function render(context, options) {
+  const startMs = Date.now();
+  if (isRoadmapMode(context.mode)) {
+    console.warn(`[Rakta.js] Render mode "${context.mode}" is a roadmap feature (v0.2.0). ` + `Falling back to CSR for: ${context.routePath}`);
+    return makeSuccess(buildHtmlShell(options), "csr", Date.now() - startMs);
+  }
+  switch (context.mode) {
+    case "csr":
+    case "spa":
+      return makeSuccess(buildHtmlShell(options), context.mode, Date.now() - startMs);
+    case "hybrid":
+      return makeSuccess(buildHtmlShell(options), "csr", Date.now() - startMs);
+    case "ssr":
+    case "ssg":
+    case "csg":
+      return makeFailure(`Render mode "${context.mode}" is not yet implemented.`, context.mode, 501);
+  }
+}
+
+// src/router/matcher.ts
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildPatternRegex(segments) {
+  const paramNames = [];
+  const parts = segments.map((segment) => {
+    if (segment.isDynamic && segment.paramName) {
+      paramNames.push(segment.paramName);
+      return "([^/]+)";
+    }
+    return escapeRegex(segment.raw);
+  });
+  const pattern = parts.length === 0 ? "" : `/${parts.join("/")}`;
+  const regex = new RegExp(`^${pattern || "/"}$`);
+  return { regex, paramNames };
+}
+function matchRoute(pathname, routes) {
+  const normalized = pathname !== "/" && pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+  for (const entry of routes) {
+    if (entry.kind !== "page" && entry.kind !== "api")
+      continue;
+    const { regex, paramNames } = buildPatternRegex(entry.segments);
+    const match = regex.exec(normalized);
+    if (!match)
+      continue;
+    const params = {};
+    paramNames.forEach((name, index) => {
+      const captured = match[index + 1];
+      if (captured !== undefined) {
+        params[name] = decodeURIComponent(captured);
+      }
+    });
+    return { entry, params };
+  }
+  return null;
+}
+
+// src/forge/devServer.ts
+var DEFAULT_DEV_PORT = 3000;
+var MIME_MAP = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function resolveMime(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return MIME_MAP[ext] ?? "application/octet-stream";
+}
+function resolveDevPort(port) {
+  return port > 0 ? port : DEFAULT_DEV_PORT;
+}
+function startDevServer(options) {
+  const manifest = generateManifest(options.appDir);
+  const resolvedPort = resolveDevPort(options.port);
+  const server = Bun.serve({
+    port: resolvedPort,
+    hostname: options.host,
+    async fetch(request) {
+      const url = new URL(request.url);
+      const { pathname } = url;
+      const publicPath = join6(options.publicDir, pathname);
+      if (existsSync5(publicPath) && !publicPath.endsWith("/")) {
+        return new Response(readFileSync2(publicPath), {
+          headers: { "Content-Type": resolveMime(pathname) }
+        });
+      }
+      const apiMatch = matchRoute(pathname, manifest.routes.filter((route) => route.kind === "api"));
+      if (apiMatch) {
+        const modulePath = join6(options.appDir, apiMatch.entry.filePath);
+        const routeModule = await import(modulePath);
+        const method = request.method.toUpperCase();
+        const handler = routeModule[method];
+        if (typeof handler !== "function") {
+          return new Response("Method not allowed", { status: 405 });
+        }
+        return await handler(request);
+      }
+      const resolved = resolveRouteMode(pathname, options.renderConfig);
+      const searchParams = {};
+      url.searchParams.forEach((value, key) => {
+        searchParams[key] = value;
+      });
+      const requestHeaders = {};
+      request.headers.forEach((value, key) => {
+        requestHeaders[key] = value;
+      });
+      const result = await render({
+        routePath: pathname,
+        mode: resolved.mode,
+        params: {},
+        searchParams,
+        requestHeaders,
+        timestampMs: Date.now()
+      }, {
+        appName: options.appName,
+        scriptPath: "/app.js",
+        cssPath: "/globals.css",
+        lang: "en"
+      });
+      if (result.kind === "failure") {
+        return new Response(result.reason, { status: result.httpStatus });
+      }
+      return new Response(result.html, {
+        status: result.httpStatus,
+        headers: result.responseHeaders
+      });
+    }
+  });
+  const serverPort = typeof server.port === "number" ? server.port : resolvedPort;
+  return {
+    port: serverPort,
+    host: options.host,
+    url: `http://${options.host}:${serverPort}`,
+    stop: () => server.stop()
+  };
+}
+
+// src/cli/dev.ts
+async function devCommand(cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  console.log(`
+  Starting Rakta.js dev server...
+`);
+  startDevServer({
+    port: config.port,
+    host: config.server.hostname ?? "0.0.0.0",
+    appDir: join7(cwd, config.appDir),
+    publicDir: join7(cwd, config.publicDir),
+    appName: config.appName,
+    renderConfig: config.render
+  });
+}
+
+// src/cli/doctor.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join8 } from "path";
+async function doctorCommand(cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  const checks = [
+    {
+      label: "Bun runtime",
+      passed: typeof Bun !== "undefined",
+      note: typeof Bun !== "undefined" ? `v${Bun.version}` : "not found"
+    },
+    {
+      label: "rakta.config.ts",
+      passed: existsSync6(join8(cwd, "rakta.config.ts")) || existsSync6(join8(cwd, "rakta.config.js"))
+    },
+    {
+      label: `app/ directory (${config.appDir})`,
+      passed: existsSync6(join8(cwd, config.appDir))
+    },
+    {
+      label: "app/page.tsx (root page)",
+      passed: existsSync6(join8(cwd, config.appDir, "page.tsx"))
+    },
+    {
+      label: "app/layout.tsx (root layout)",
+      passed: existsSync6(join8(cwd, config.appDir, "layout.tsx"))
+    },
+    {
+      label: `public/ directory (${config.publicDir})`,
+      passed: existsSync6(join8(cwd, config.publicDir))
+    },
+    {
+      label: "package.json",
+      passed: existsSync6(join8(cwd, "package.json"))
+    },
+    {
+      label: "tsconfig.json",
+      passed: existsSync6(join8(cwd, "tsconfig.json"))
+    }
+  ];
+  const sep = "\u2500".repeat(52);
+  console.log(`
+  Rakta.js Doctor`);
+  console.log(`  ${sep}`);
+  let allPassed = true;
+  for (const check of checks) {
+    const icon = check.passed ? "pass" : "FAIL";
+    const note = check.note ? `  (${check.note})` : "";
+    console.log(`  [${icon}]  ${check.label}${note}`);
+    if (!check.passed)
+      allPassed = false;
+  }
+  console.log(`  ${sep}`);
+  if (allPassed) {
+    console.log(`  All checks passed.
+`);
+  } else {
+    console.log(`  Some checks failed. Review the output above.
+`);
+    process.exit(1);
+  }
+}
+
+// src/auto-import/generator.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join10 } from "path";
+
+// src/auto-import/scanner.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
+import { basename, extname, join as join9, relative as relative2 } from "path";
+var DEFAULT_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx"
+];
+function detectKind(filePath) {
+  const lower = filePath.replace(/\\/g, "/").toLowerCase();
+  if (lower.includes("/stores/") || lower.endsWith(".store.ts") || lower.endsWith(".store.tsx")) {
+    return "store";
+  }
+  if (lower.includes("/schemas/") || lower.endsWith(".schema.ts") || lower.endsWith(".schema.tsx")) {
+    return "schema";
+  }
+  if (lower.includes("/components/")) {
+    return "component";
+  }
+  const fileName = basename(lower);
+  if (fileName.startsWith("use")) {
+    return "hook";
+  }
+  if (lower.includes("/lib/") || lower.includes("/utils/") || lower.includes("/helpers/")) {
+    return "utils";
+  }
+  return "unknown";
+}
+function toPascalCase(text) {
+  return text.replace(/[-_.]/g, " ").replace(/\s+(.)/g, (_match, char) => char.toUpperCase()).replace(/^(.)/, (_match, char) => char.toUpperCase());
+}
+function deriveExportName(filePath, dirPath) {
+  const relativePath = relative2(dirPath, filePath).replace(/\\/g, "/");
+  const withoutExtension = relativePath.replace(/\.(ts|tsx|js|jsx)$/, "").replace(/\/index$/, "");
+  return toPascalCase(withoutExtension.replace(/\//g, "_"));
+}
+function walkDirectory(dirPath, extensions) {
+  if (!existsSync7(dirPath)) {
+    return [];
+  }
+  const collected = [];
+  function walk(currentPath) {
+    const entries = readdirSync3(currentPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || entry.name === "node_modules") {
+        continue;
+      }
+      const fullPath = join9(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && extensions.includes(extname(entry.name))) {
+        collected.push(fullPath);
+      }
+    }
+  }
+  walk(dirPath);
+  return collected;
+}
+function scanForExports(options) {
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const discovered = [];
+  const outputAbs = join9(options.frontendRoot, options.outputDirectory);
+  for (const directory of options.directories) {
+    const directoryAbs = join9(options.frontendRoot, directory);
+    const files = walkDirectory(directoryAbs, extensions);
+    for (const filePath of files) {
+      const relativeFromOutput = relative2(outputAbs, filePath).replace(/\\/g, "/").replace(/\.(ts|tsx)$/, "");
+      const importPath = relativeFromOutput.startsWith(".") ? relativeFromOutput : `./${relativeFromOutput}`;
+      discovered.push({
+        name: deriveExportName(filePath, directoryAbs),
+        filePath: relative2(options.frontendRoot, filePath).replace(/\\/g, "/"),
+        importPath,
+        kind: detectKind(filePath)
+      });
+    }
+  }
+  return discovered;
+}
+
+// src/auto-import/generator.ts
+var GENERATED_HEADER = `// This file is auto-generated by: bun rakta imports:generate
+// Do not edit manually. Re-generate whenever you add or remove files.
+// Note: Rakta Auto Import v0.1.0 produces a typed re-export layer.
+// Import from this file in your app code:
+//   import { useCounterStore, http } from "./.rakta/auto-imports";
+`;
+function buildImportLines(exports) {
+  if (exports.length === 0) {
+    return `// No exports discovered. Check your autoImport.directories config.
+`;
+  }
+  return exports.map((discoveredExport) => `export * from "${discoveredExport.importPath}";`).join(`
+`);
+}
+function generateAutoImports(options) {
+  const exports = scanForExports({
+    frontendRoot: options.frontendRoot,
+    directories: options.directories,
+    outputDirectory: options.outputDirectory,
+    ...options.extensions ? {
+      extensions: options.extensions
+    } : {}
+  });
+  const outputDir = join10(options.frontendRoot, options.outputDirectory);
+  mkdirSync2(outputDir, {
+    recursive: true
+  });
+  const tsContent = `${GENERATED_HEADER}
+${buildImportLines(exports)}
+`;
+  writeFileSync2(join10(outputDir, "auto-imports.ts"), tsContent, "utf-8");
+  if (options.generateDts) {
+    const dtsContent = tsContent.replace("// This file is auto-generated by: bun rakta imports:generate", "// Type declarations \u2014 auto-generated by: bun rakta imports:generate");
+    writeFileSync2(join10(outputDir, "auto-imports.d.ts"), dtsContent, "utf-8");
+  }
+  return {
+    generatedAt: new Date().toISOString(),
+    sourceDirectories: options.directories,
+    exports
+  };
+}
+function printAutoImportSummary(manifest) {
+  console.log(`
+  Rakta Auto Import`);
+  console.log(`  ${"\u2500".repeat(50)}`);
+  console.log(`Generated: ${manifest.generatedAt}`);
+  console.log(`Exports:   ${manifest.exports.length}`);
+  if (manifest.exports.length > 0) {
+    console.log("");
+    for (const discoveredExport of manifest.exports) {
+      console.log(`[${discoveredExport.kind.padEnd(10)}] ${discoveredExport.name}  <-  ${discoveredExport.filePath}`);
+    }
+  }
+  console.log(`  ${"\u2500".repeat(50)}
+`);
+}
+
+// src/cli/imports.ts
+async function importsGenerateCommand(cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  if (!config.autoImport.enabled) {
+    console.warn("  Auto Import is disabled in rakta.config.ts (autoImport.enabled = false).");
+    return;
+  }
+  const manifest = generateAutoImports({
+    frontendRoot: cwd,
+    directories: config.autoImport.directories,
+    outputDirectory: config.autoImport.outputDirectory,
+    extensions: config.autoImport.extensions ?? [".ts", ".tsx", ".js", ".jsx"],
+    generateDts: config.autoImport.dts ?? true
+  });
+  printAutoImportSummary(manifest);
+}
+
+// src/cli/make.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname, join as join11 } from "path";
+function toPascalCase2(name) {
+  return name.split(/[-_/]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function writeIfNew(filePath, content) {
+  if (existsSync8(filePath)) {
+    console.warn(`  Already exists: ${filePath}`);
+    return;
+  }
+  mkdirSync3(dirname(filePath), { recursive: true });
+  writeFileSync3(filePath, content, "utf-8");
+  console.log(`  Created: ${filePath}`);
+}
+function getRelativeFilePath(filePath, cwd) {
+  return filePath.replace(`${cwd}/`, "");
+}
+async function makeCommand(target, name, cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  const appDir = join11(cwd, config.appDir);
+  const componentName = toPascalCase2(name);
+  switch (target) {
+    case "page": {
+      const filePath = join11(appDir, name, "page.tsx");
+      writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
+import React from "react";
+import type { Metadata } from "rakta/seo";
+
+export const metadata: Metadata = {
+  title: "${componentName}",
+};
+
+export default function ${componentName}Page() {
+  return (
+    <main>
+      <h1>${componentName}</h1>
+    </main>
+  );
+}
+`);
+      break;
+    }
+    case "layout": {
+      const filePath = join11(appDir, name, "layout.tsx");
+      writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
+import React from "react";
+import type { LayoutProps } from "rakta/router";
+
+export default function ${componentName}Layout({ children }: LayoutProps) {
+  return <section>{children}</section>;
+}
+`);
+      break;
+    }
+    case "component": {
+      const filePath = join11(cwd, "components", "ui", `${componentName}.tsx`);
+      writeIfNew(filePath, `// components/ui/${componentName}.tsx
+import React from "react";
+
+export interface ${componentName}Props {
+  children?: React.ReactNode;
+  className?: string;
+}
+
+export function ${componentName}({ children, className }: ${componentName}Props) {
+  return <div className={className}>{children}</div>;
+}
+
+export default ${componentName};
+`);
+      break;
+    }
+    case "api": {
+      const filePath = join11(appDir, "api", name, "route.ts");
+      writeIfNew(filePath, `// ${getRelativeFilePath(filePath, cwd)}
+import type { RouteContext } from "rakta/router";
+
+export async function GET(_request: Request, context: RouteContext): Promise<Response> {
+  return Response.json({ message: "Hello from /api/${name}", pathname: context.pathname });
+}
+`);
+      break;
+    }
+  }
+}
+
+// src/cli/routes.ts
+import { join as join12 } from "path";
+async function routesCommand(cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  const appDir = join12(cwd, config.appDir);
+  const manifest = generateManifest(appDir);
+  printManifest(manifest);
+}
+
+// src/cli/rpcTypes.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join13 } from "path";
+async function rpcTypesCommand(cwd = process.cwd()) {
+  const sharedTypesDir = join13(cwd, "..", "shared", "types");
+  if (!existsSync9(sharedTypesDir)) {
+    mkdirSync4(sharedTypesDir, { recursive: true });
+  }
+  const outputPath = join13(sharedTypesDir, "rpc.ts");
+  const content = `// shared/types/rpc.ts
+// Auto-generated by: bun rakta rpc:types
+// Re-exports AppRouter type from the backend for type-safe frontend RPC calls.
+// Re-run this command after modifying backend/src/rpc/router.ts.
+
+export type { AppRouter } from "../../backend/src/rpc/router.js";
+`;
+  writeFileSync4(outputPath, content, "utf-8");
+  console.log(`
+  Generated: shared/types/rpc.ts
+`);
+  console.log(`  Import in frontend:`);
+  console.log(`    import type { AppRouter } from "../../shared/types/rpc";
+`);
+}
+
+// src/cli/seo.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, writeFileSync as writeFileSync5 } from "fs";
+import { join as join14 } from "path";
+async function seoGenerateCommand(cwd = process.cwd()) {
+  const config = await loadConfig(cwd);
+  const appDir = join14(cwd, config.appDir);
+  const sitemapDir = join14(appDir, "api", "sitemap.xml");
+  const robotsDir = join14(appDir, "api", "robots.txt");
+  if (!existsSync10(sitemapDir)) {
+    mkdirSync5(sitemapDir, { recursive: true });
+    writeFileSync5(join14(sitemapDir, "route.ts"), `// app/api/sitemap.xml/route.ts \u2014 generated by: bun rakta seo:generate
+import { createSitemapHandler } from "rakta/seo";
+
+export const GET = createSitemapHandler({
+  baseUrl: process.env["BASE_URL"] ?? "${config.seo.siteUrl ?? "http://localhost:3000"}",
+  entries: [
+    { loc: "/", changefreq: "daily", priority: 1.0 },
+    { loc: "/about", changefreq: "monthly", priority: 0.8 },
+  ],
+});
+`, "utf-8");
+    console.log("  Created: app/api/sitemap.xml/route.ts");
+  } else {
+    console.warn("  Already exists: app/api/sitemap.xml/route.ts");
+  }
+  if (!existsSync10(robotsDir)) {
+    mkdirSync5(robotsDir, { recursive: true });
+    writeFileSync5(join14(robotsDir, "route.ts"), `// app/api/robots.txt/route.ts \u2014 generated by: bun rakta seo:generate
+import { createRobotsHandler } from "rakta/seo";
+
+export const GET = createRobotsHandler({
+  rules: [
+    {
+      userAgent: "*",
+      allow: "/",
+      disallow: ["/api/"],
+    },
+  ],
+  sitemap: "${config.seo.siteUrl ?? "http://localhost:3000"}/api/sitemap.xml",
+});
+`, "utf-8");
+    console.log("  Created: app/api/robots.txt/route.ts");
+  } else {
+    console.warn("  Already exists: app/api/robots.txt/route.ts");
+  }
+  console.log(`
+  SEO route handlers generated.
+`);
+}
+
+// src/cli/start.ts
+import { join as join16 } from "path";
+
+// src/tide/adapter.ts
+import { existsSync as existsSync11, readFileSync as readFileSync3 } from "fs";
+import { join as join15 } from "path";
+// src/tide/runtime.ts
+function createRuntimeContext(request, url, params, resolvedMode) {
+  const searchParams = {};
+  url.searchParams.forEach((value, key) => {
+    searchParams[key] = value;
+  });
+  const requestHeaders = {};
+  request.headers.forEach((value, key) => {
+    requestHeaders[key] = value;
+  });
+  return {
+    url,
+    params,
+    request,
+    searchParams,
+    resolvedMode,
+    requestHeaders,
+    pathname: url.pathname,
+    timestampMs: Date.now(),
+    method: request.method.toUpperCase()
+  };
+}
+function buildTextResponse(body, status, headers) {
+  return new Response(body, { status, headers });
+}
+function buildHtmlResponse(html, status = 200) {
+  return buildTextResponse(html, status, {
+    "Content-Type": "text/html; charset=utf-8"
+  });
+}
+function buildJsonResponse(responseData, status = 200) {
+  return buildTextResponse(JSON.stringify(responseData), status, {
+    "Content-Type": "application/json; charset=utf-8"
+  });
+}
+function buildErrorResponse(errorMessage, status = 500) {
+  return buildJsonResponse({ error: errorMessage }, status);
+}
+
+// src/tide/adapter.ts
+var STATIC_MIME_TYPES = {
+  ".js": "application/javascript; charset=utf-8",
+  ".ts": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function mimeForPath(filePath) {
+  const extensionIndex = filePath.lastIndexOf(".");
+  if (extensionIndex < 0) {
+    return "application/octet-stream";
+  }
+  const extension = filePath.slice(extensionIndex).toLowerCase();
+  return STATIC_MIME_TYPES[extension] ?? "application/octet-stream";
+}
+function normalizeStaticPath(pathname) {
+  const pathnameWithoutLeadingSlash = pathname.replace(/^\/+/, "");
+  if (pathnameWithoutLeadingSlash.length > 0) {
+    return pathnameWithoutLeadingSlash;
+  }
+  return "index.html";
+}
+function isApiRouteExports(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return true;
+}
+function getApiRouteHandler(routeExports, method) {
+  if (method === "GET") {
+    return routeExports.GET;
+  }
+  if (method === "POST") {
+    return routeExports.POST;
+  }
+  if (method === "PUT") {
+    return routeExports.PUT;
+  }
+  if (method === "PATCH") {
+    return routeExports.PATCH;
+  }
+  if (method === "DELETE") {
+    return routeExports.DELETE;
+  }
+  if (method === "HEAD") {
+    return routeExports.HEAD;
+  }
+  if (method === "OPTIONS") {
+    return routeExports.OPTIONS;
+  }
+  return;
+}
+function createBunAdapter(adapterConfig, renderConfig) {
+  const manifest = generateManifest(adapterConfig.appDir);
+  const searchDirectories = [adapterConfig.publicDir, adapterConfig.outDir];
+  let serverInstance;
+  async function handle(request) {
+    const url = new URL(request.url);
+    const { pathname } = url;
+    const staticPathname = normalizeStaticPath(pathname);
+    for (const searchDirectory of searchDirectories) {
+      const filePath = join15(searchDirectory, staticPathname);
+      if (existsSync11(filePath) && !filePath.endsWith("/")) {
+        return new Response(readFileSync3(filePath), {
+          headers: {
+            "Content-Type": mimeForPath(filePath),
+            "Cache-Control": "public, max-age=31536000, immutable"
+          }
+        });
+      }
+    }
+    const apiRoutes = manifest.routes.filter((route) => route.kind === "api");
+    const apiMatch = matchRoute(pathname, apiRoutes);
+    if (apiMatch) {
+      const modulePath = join15(adapterConfig.appDir, apiMatch.entry.filePath);
+      const routeModule = await import(modulePath);
+      if (!isApiRouteExports(routeModule)) {
+        return new Response("Invalid API route module", {
+          status: 500
+        });
+      }
+      const handler = getApiRouteHandler(routeModule, request.method.toUpperCase());
+      if (!handler) {
+        return new Response("Method not allowed", {
+          status: 405
+        });
+      }
+      return await handler(request);
+    }
+    const resolvedRouteMode = resolveRouteMode(pathname, renderConfig);
+    const runtimeContext = createRuntimeContext(request, url, {}, resolvedRouteMode.mode);
+    const renderResult = await render({
+      routePath: runtimeContext.pathname,
+      mode: runtimeContext.resolvedMode,
+      params: runtimeContext.params,
+      searchParams: runtimeContext.searchParams,
+      requestHeaders: runtimeContext.requestHeaders,
+      timestampMs: runtimeContext.timestampMs
+    }, {
+      appName: adapterConfig.appName,
+      scriptPath: "/app.js",
+      cssPath: "/globals.css",
+      lang: "en"
+    });
+    if (renderResult.kind === "failure") {
+      return buildErrorResponse(renderResult.reason, renderResult.httpStatus);
+    }
+    return buildHtmlResponse(renderResult.html, renderResult.httpStatus);
+  }
+  return {
+    kind: "bun",
+    handle,
+    start: async () => {
+      serverInstance = Bun.serve({
+        port: adapterConfig.port,
+        hostname: adapterConfig.host,
+        fetch: handle
+      });
+      console.log(`[Rakta.js Tide] Running at http://${adapterConfig.host}:${serverInstance.port}`);
+    },
+    stop: () => {
+      if (!serverInstance) {
+        return;
+      }
+      serverInstance.stop();
+    }
+  };
+}
+
+// src/cli/start.ts
+async function startCommand(cwd = process.cwd()) {
+  const projectConfig = await loadConfig(cwd);
+  const outputDirectory = projectConfig.build.outDir ?? "dist";
+  console.log(`
+ Starting Rakta.js production server...
+`);
+  const serverAdapter = createBunAdapter({
+    kind: "bun",
+    port: projectConfig.port,
+    host: projectConfig.server.hostname ?? "0.0.0.0",
+    appName: projectConfig.appName,
+    appDir: join16(cwd, projectConfig.appDir),
+    publicDir: join16(cwd, projectConfig.publicDir),
+    outDir: join16(cwd, outputDirectory)
+  }, projectConfig.render);
+  await serverAdapter.start();
+}
+
+// src/cli/rakta.ts
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var cliArgs = process.argv.slice(2);
+var selectedCommand = cliArgs[0] ?? "help";
+var firstArgument = cliArgs[1];
+var cwd = process.cwd();
+var BANNER = [
+  "",
+  `${BOLD}${RED} \u2588\u2588\u2588\u2588\u2588\u2588\u2557   \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2557  \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557          \u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557${RESET}`,
+  `${BOLD}${RED} \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2551 \u2588\u2588\u2554\u255D \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557         \u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D${RESET}`,
+  `${BOLD}${RED} \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2554\u255D     \u2588\u2588\u2551    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551         \u2588\u2588\u2551 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557${RESET}`,
+  `${BOLD}${RED} \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551 \u2588\u2588\u2554\u2550\u2588\u2588\u2557     \u2588\u2588\u2551    \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551    \u2588\u2588   \u2588\u2588\u2551 \u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551${RESET}`,
+  `${BOLD}${RED} \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2551  \u2588\u2588\u2557    \u2588\u2588\u2551    \u2588\u2588\u2551  \u2588\u2588\u2551 \u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551${RESET}`,
+  `${BOLD}${RED} \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D    \u255A\u2550\u255D    \u255A\u2550\u255D  \u255A\u2550\u255D \u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D${RESET}`,
+  ""
+].join(`
+`);
+function printHelp() {
+  console.log(BANNER);
+  console.log(`${BOLD}${RED} Rakta.js CLI${RESET}`);
+  console.log(`${DIM} Small in size. Fierce in speed. Alive in every route.${RESET}`);
+  console.log("");
+  console.log(`${BOLD}Usage:${RESET}`);
+  console.log("  bun rakta <command> [options]");
+  console.log("");
+  console.log(`${BOLD}Commands:${RESET}`);
+  console.log("  rakta dev");
+  console.log("  rakta build");
+  console.log("  rakta start");
+  console.log("  rakta routes");
+  console.log("");
+  console.log("  rakta make:page <name>");
+  console.log("  rakta make:layout <name>");
+  console.log("  rakta make:component <name>");
+  console.log("  rakta make:api <name>");
+  console.log("");
+  console.log("  rakta seo:generate");
+  console.log("  rakta imports:generate");
+  console.log("  rakta rpc:types");
+  console.log("");
+  console.log("  rakta forge:inspect");
+  console.log("  rakta tide:render");
+  console.log("  rakta doctor");
+  console.log("  rakta help");
+  console.log("");
+}
+function getRequiredArgument(commandName, argumentValue) {
+  if (typeof argumentValue === "string" && argumentValue.trim().length > 0) {
+    return argumentValue;
+  }
+  console.error(`${BOLD}${RED}Rakta.js${RESET} ${DIM}missing argument for:${RESET} ${commandName}`);
+  console.error(`${DIM}Usage: rakta ${commandName} <name>${RESET}`);
+  process.exit(1);
+}
+async function runForgeInspect() {
+  const projectConfig = await loadConfig(cwd);
+  const outputDirectory = projectConfig.build.outDir ?? "dist";
+  const inspectReport = inspectBuild({
+    outDir: join17(cwd, outputDirectory),
+    renderConfig: projectConfig.render
+  });
+  printInspectReport(inspectReport);
+}
+async function main() {
+  switch (selectedCommand) {
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    case "dev":
+      await devCommand(cwd);
+      break;
+    case "build":
+      await buildCommand(cwd);
+      break;
+    case "start":
+      await startCommand(cwd);
+      break;
+    case "routes":
+      await routesCommand(cwd);
+      break;
+    case "make:page":
+      await makeCommand("page", getRequiredArgument("make:page", firstArgument), cwd);
+      break;
+    case "make:layout":
+      await makeCommand("layout", getRequiredArgument("make:layout", firstArgument), cwd);
+      break;
+    case "make:component":
+      await makeCommand("component", getRequiredArgument("make:component", firstArgument), cwd);
+      break;
+    case "make:api":
+      await makeCommand("api", getRequiredArgument("make:api", firstArgument), cwd);
+      break;
+    case "seo:generate":
+      await seoGenerateCommand(cwd);
+      break;
+    case "imports:generate":
+      await importsGenerateCommand(cwd);
+      break;
+    case "rpc:types":
+      await rpcTypesCommand(cwd);
+      break;
+    case "forge:inspect":
+      await runForgeInspect();
+      break;
+    case "tide:render":
+      console.log(`${BOLD}${RED}Rakta.js${RESET} ${DIM}tide:render is planned for v0.2.0.${RESET}`);
+      break;
+    case "doctor":
+      await doctorCommand(cwd);
+      break;
+    default:
+      console.error(`${BOLD}${RED}Rakta.js${RESET} ${DIM}unknown command:${RESET} ${selectedCommand}`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((caughtError) => {
+  const errorMessage = caughtError instanceof Error ? caughtError.message : String(caughtError);
+  console.error(`
+${BOLD}${RED}Rakta.js error:${RESET} ${errorMessage}
+`);
+  process.exit(1);
+});
+
+//# debugId=2D6840578E402FF964756E2164756E21