kilatjs 0.1.0 → 0.1.2

package/dist/cli.js

@@ -0,0 +1,1335 @@
+#!/usr/bin/env bun
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/server/live-reload.ts
+function startLiveReload(port = 35729) {
+  if (liveReloadServer)
+    return;
+  liveReloadServer = Bun.serve({
+    port,
+    fetch(req, server) {
+      if (server.upgrade(req, { data: {} })) {
+        return;
+      }
+      return new Response("Live Reload Server", { status: 200 });
+    },
+    websocket: {
+      open(ws) {
+        clients.add(ws);
+      },
+      close(ws) {
+        clients.delete(ws);
+      },
+      message() {}
+    }
+  });
+}
+function notifyReload() {
+  const message = JSON.stringify({ type: "reload" });
+  for (const client of clients) {
+    try {
+      client.send(message);
+    } catch {
+      clients.delete(client);
+    }
+  }
+}
+function getLiveReloadScript(port = 35729) {
+  return `
+<script>
+(function() {
+    const ws = new WebSocket('ws://localhost:${port}');
+    ws.onmessage = function(e) {
+        const data = JSON.parse(e.data);
+        if (data.type === 'reload') {
+            console.log('[KilatJS] Reloading...');
+            location.reload();
+        }
+    };
+    ws.onclose = function() {
+        console.log('[KilatJS] Live reload disconnected. Reconnecting...');
+        setTimeout(function() { location.reload(); }, 1000);
+    };
+})();
+</script>`;
+}
+async function watchDirectory(dir, onChange) {
+  const fileTimestamps = new Map;
+  let timeout = null;
+  let lastChange = 0;
+  const triggerChange = (filename) => {
+    const now = Date.now();
+    if (now - lastChange < 100)
+      return;
+    lastChange = now;
+    if (timeout)
+      clearTimeout(timeout);
+    timeout = setTimeout(() => {
+      onChange();
+    }, 50);
+  };
+  async function scanFiles() {
+    const timestamps = new Map;
+    try {
+      const glob = new Bun.Glob("**/*.{ts,tsx,js,jsx,css}");
+      for await (const file of glob.scan({ cwd: dir, absolute: true })) {
+        try {
+          const stat = Bun.file(file);
+          const lastModified = (await stat.stat())?.mtime?.getTime() || 0;
+          timestamps.set(file, lastModified);
+        } catch {}
+      }
+    } catch (error) {
+      console.warn(`⚠️ Could not scan directory ${dir}:`, error);
+    }
+    return timestamps;
+  }
+  const initialFiles = await scanFiles();
+  for (const [file, time] of initialFiles) {
+    fileTimestamps.set(file, time);
+  }
+  const pollInterval = setInterval(async () => {
+    const currentFiles = await scanFiles();
+    for (const [file, time] of currentFiles) {
+      const previousTime = fileTimestamps.get(file);
+      if (previousTime === undefined || previousTime < time) {
+        fileTimestamps.set(file, time);
+        if (previousTime !== undefined) {
+          const relativePath = file.replace(dir + "/", "");
+          triggerChange(relativePath);
+        }
+      }
+    }
+    for (const file of fileTimestamps.keys()) {
+      if (!currentFiles.has(file)) {
+        fileTimestamps.delete(file);
+        const relativePath = file.replace(dir + "/", "");
+        triggerChange(relativePath);
+      }
+    }
+  }, 500);
+  globalThis.__kilatWatchIntervals = globalThis.__kilatWatchIntervals || [];
+  globalThis.__kilatWatchIntervals.push(pollInterval);
+}
+function stopLiveReload() {
+  if (liveReloadServer) {
+    liveReloadServer.stop();
+    liveReloadServer = null;
+  }
+  clients.clear();
+}
+var clients, liveReloadServer = null;
+var init_live_reload = __esm(() => {
+  clients = new Set;
+});
+
+// src/adapters/react.ts
+import { renderToStaticMarkup } from "react-dom/server";
+import React from "react";
+
+class ReactAdapter {
+  static async renderToString(component, props) {
+    try {
+      const element = React.createElement(component, props);
+      return renderToStaticMarkup(element);
+    } catch (error) {
+      console.error("Error rendering React component:", error);
+      throw error;
+    }
+  }
+  static createDocument(html, meta = {}, config, options = {}) {
+    const title = meta.title || "KilatJS App";
+    const description = meta.description || "";
+    const robots = meta.robots || "index,follow";
+    let metaTags = "";
+    metaTags += `<meta charset="utf-8" />
+    `;
+    metaTags += `<meta name="viewport" content="width=device-width, initial-scale=1" />
+    `;
+    metaTags += `<meta name="robots" content="${robots}" />
+    `;
+    if (description) {
+      metaTags += `<meta name="description" content="${this.escapeHtml(description)}" />
+    `;
+    }
+    if (meta.canonical) {
+      metaTags += `<link rel="canonical" href="${this.escapeHtml(meta.canonical)}" />
+    `;
+    }
+    metaTags += `<meta property="og:title" content="${this.escapeHtml(meta.ogTitle || title)}" />
+    `;
+    if (meta.ogDescription || description) {
+      metaTags += `<meta property="og:description" content="${this.escapeHtml(meta.ogDescription || description)}" />
+    `;
+    }
+    if (meta.ogImage) {
+      metaTags += `<meta property="og:image" content="${this.escapeHtml(meta.ogImage)}" />
+    `;
+    }
+    const twitterCard = meta.twitterCard || "summary";
+    metaTags += `<meta name="twitter:card" content="${twitterCard}" />
+    `;
+    const reservedKeys = [
+      "title",
+      "description",
+      "robots",
+      "canonical",
+      "ogTitle",
+      "ogDescription",
+      "ogImage",
+      "twitterCard"
+    ];
+    Object.entries(meta).forEach(([key, value]) => {
+      if (!reservedKeys.includes(key) && typeof value === "string") {
+        metaTags += `<meta name="${this.escapeHtml(key)}" content="${this.escapeHtml(value)}" />
+    `;
+      }
+    });
+    const cssUrl = config?.dev ? `/styles.css?v=${Date.now()}` : "/styles.css";
+    metaTags += `<link rel="stylesheet" href="${cssUrl}" />
+    `;
+    metaTags += `<link rel="preconnect" href="https://fonts.googleapis.com" />
+    `;
+    metaTags += `<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    `;
+    metaTags += `<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
+    `;
+    const liveReloadScript = config?.dev ? getLiveReloadScript() : "";
+    const clientScriptTag = options.clientScript ? `<script>(${options.clientScript.toString()})()</script>` : "";
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>${this.escapeHtml(title)}</title>
+    ${metaTags}
+  </head>
+  <body>
+    <div id="root">
+      ${html}
+    </div>
+    ${liveReloadScript}
+    ${clientScriptTag}
+  </body>
+</html>`;
+  }
+  static escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+}
+var init_react = __esm(() => {
+  init_live_reload();
+});
+
+// src/adapters/htmx.ts
+class HTMXAdapter {
+  static async renderToString(template, props) {
+    try {
+      const html = await template(props);
+      return html;
+    } catch (error) {
+      console.error("Error rendering HTMX template:", error);
+      throw error;
+    }
+  }
+  static isHTMXRequest(request) {
+    return request.headers.get("HX-Request") === "true";
+  }
+  static isBoostedRequest(request) {
+    return request.headers.get("HX-Boosted") === "true";
+  }
+  static getCurrentUrl(request) {
+    return request.headers.get("HX-Current-URL");
+  }
+  static getTrigger(request) {
+    return request.headers.get("HX-Trigger");
+  }
+  static getTriggerName(request) {
+    return request.headers.get("HX-Trigger-Name");
+  }
+  static getTarget(request) {
+    return request.headers.get("HX-Target");
+  }
+  static createResponse(html, options = {}) {
+    const headers = new Headers({
+      "Content-Type": "text/html; charset=utf-8"
+    });
+    if (options.retarget) {
+      headers.set("HX-Retarget", options.retarget);
+    }
+    if (options.reswap) {
+      headers.set("HX-Reswap", options.reswap);
+    }
+    if (options.trigger) {
+      headers.set("HX-Trigger", options.trigger);
+    }
+    if (options.triggerAfterSettle) {
+      headers.set("HX-Trigger-After-Settle", options.triggerAfterSettle);
+    }
+    if (options.triggerAfterSwap) {
+      headers.set("HX-Trigger-After-Swap", options.triggerAfterSwap);
+    }
+    if (options.redirect) {
+      headers.set("HX-Redirect", options.redirect);
+    }
+    if (options.refresh) {
+      headers.set("HX-Refresh", "true");
+    }
+    if (options.pushUrl) {
+      headers.set("HX-Push-Url", options.pushUrl);
+    }
+    if (options.replaceUrl) {
+      headers.set("HX-Replace-Url", options.replaceUrl);
+    }
+    return new Response(html, { headers, status: options.status || 200 });
+  }
+  static redirectResponse(url) {
+    return new Response(null, {
+      headers: {
+        "HX-Redirect": url
+      }
+    });
+  }
+  static refreshResponse() {
+    return new Response(null, {
+      headers: {
+        "HX-Refresh": "true"
+      }
+    });
+  }
+  static createDocument(html, meta = {}, config) {
+    const title = meta.title || "KilatJS App";
+    const description = meta.description || "";
+    const robots = meta.robots || "index,follow";
+    let metaTags = "";
+    metaTags += `<meta charset="utf-8" />
+    `;
+    metaTags += `<meta name="viewport" content="width=device-width, initial-scale=1" />
+    `;
+    metaTags += `<meta name="robots" content="${robots}" />
+    `;
+    if (description) {
+      metaTags += `<meta name="description" content="${this.escapeHtml(description)}" />
+    `;
+    }
+    if (meta.canonical) {
+      metaTags += `<link rel="canonical" href="${this.escapeHtml(meta.canonical)}" />
+    `;
+    }
+    metaTags += `<meta property="og:title" content="${this.escapeHtml(meta.ogTitle || title)}" />
+    `;
+    if (meta.ogDescription || description) {
+      metaTags += `<meta property="og:description" content="${this.escapeHtml(meta.ogDescription || description)}" />
+    `;
+    }
+    if (meta.ogImage) {
+      metaTags += `<meta property="og:image" content="${this.escapeHtml(meta.ogImage)}" />
+    `;
+    }
+    const twitterCard = meta.twitterCard || "summary";
+    metaTags += `<meta name="twitter:card" content="${twitterCard}" />
+    `;
+    const reservedKeys = [
+      "title",
+      "description",
+      "robots",
+      "canonical",
+      "ogTitle",
+      "ogDescription",
+      "ogImage",
+      "twitterCard"
+    ];
+    Object.entries(meta).forEach(([key, value]) => {
+      if (!reservedKeys.includes(key) && typeof value === "string") {
+        metaTags += `<meta name="${this.escapeHtml(key)}" content="${this.escapeHtml(value)}" />
+    `;
+      }
+    });
+    metaTags += `<link rel="stylesheet" href="/styles.css" />
+    `;
+    metaTags += `<script src="https://unpkg.com/htmx.org@1.9.10" integrity="sha384-D1Kt99CQMDuVetoL1lrYwg5t+9QdHe7NLX/SoJYkXDFfX37iInKRy5xLSi8nO7UC" crossorigin="anonymous"></script>
+    `;
+    metaTags += `<link rel="preconnect" href="https://fonts.googleapis.com" />
+    `;
+    metaTags += `<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    `;
+    metaTags += `<link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet" />
+    `;
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>${this.escapeHtml(title)}</title>
+    ${metaTags}
+  </head>
+  <body hx-boost="true">
+    <div id="root">
+      ${html}
+    </div>
+    ${config?.dev ? getLiveReloadScript() : ""}
+  </body>
+</html>`;
+  }
+  static escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+}
+var init_htmx = __esm(() => {
+  init_live_reload();
+});
+
+// src/core/router.ts
+var Router;
+var init_router = __esm(() => {
+  init_react();
+  init_htmx();
+  Router = class Router {
+    routes = new Map;
+    config;
+    staticPaths = new Map;
+    fsRouter;
+    routeCache = new Map;
+    preloadedRoutes = new Map;
+    routePatterns = [];
+    apiRoutes = new Map;
+    static NOT_FOUND_RESPONSE = new Response("404 Not Found", { status: 404 });
+    static METHOD_NOT_ALLOWED_RESPONSE = new Response(JSON.stringify({ error: "Method Not Allowed" }), { status: 405, headers: { "Content-Type": "application/json" } });
+    static INTERNAL_ERROR_RESPONSE = new Response(JSON.stringify({ error: "Internal Server Error" }), { status: 500, headers: { "Content-Type": "application/json" } });
+    contextPool = [];
+    constructor(config) {
+      this.config = config;
+      this.fsRouter = new Bun.FileSystemRouter({
+        dir: config.routesDir,
+        style: "nextjs",
+        origin: `http://${config.hostname || "localhost"}:${config.port || 3000}`
+      });
+    }
+    getRoutes() {
+      return this.routes;
+    }
+    getStaticPaths() {
+      return this.staticPaths;
+    }
+    async loadRoutes(silent = false) {
+      this.fsRouter.reload();
+      this.routeCache.clear();
+      this.preloadedRoutes.clear();
+      this.routePatterns.length = 0;
+      this.apiRoutes.clear();
+      this.staticHtmlFiles.clear();
+      await this.preloadAllRoutes(silent);
+      if (!silent) {
+        console.log("\uD83D\uDD04 FileSystemRouter initialized with", this.preloadedRoutes.size, "routes");
+      }
+    }
+    async preloadAllRoutes(silent = false) {
+      await this.scanAndPreloadRoutes(this.config.routesDir, "", silent);
+    }
+    staticHtmlFiles = new Map;
+    async scanAndPreloadRoutes(dir, _basePath, _silent = false) {
+      try {
+        const proc = Bun.spawn(["find", dir, "-name", "*.ts", "-o", "-name", "*.tsx", "-o", "-name", "*.js", "-o", "-name", "*.jsx", "-o", "-name", "*.html"], {
+          stdout: "pipe"
+        });
+        const output = await new Response(proc.stdout).text();
+        const files = output.trim().split(`
+`).filter(Boolean);
+        for (const filePath of files) {
+          const relativePath = filePath.replace(dir, "");
+          const isHtml = filePath.endsWith(".html");
+          let routePath = relativePath.replace(/\.(tsx?|jsx?|html)$/, "");
+          if (routePath.endsWith("/index")) {
+            routePath = routePath.slice(0, -6) || "/";
+          }
+          if (!routePath.startsWith("/")) {
+            routePath = "/" + routePath;
+          }
+          if (isHtml) {
+            this.staticHtmlFiles.set(routePath, filePath);
+            continue;
+          }
+          const routeType = this.getRouteType(routePath);
+          try {
+            const routeExports = await import(filePath);
+            this.preloadedRoutes.set(routePath, routeExports);
+            if (routeType === "api") {
+              this.apiRoutes.set(routePath, routeExports);
+            }
+            if (routePath.includes("[")) {
+              const pattern = this.createRoutePattern(routePath);
+              if (pattern) {
+                this.routePatterns.push({
+                  pattern: pattern.regex,
+                  filePath,
+                  paramNames: pattern.paramNames,
+                  routeType
+                });
+              }
+            }
+          } catch (error) {
+            console.warn(`Failed to preload route ${filePath}:`, error);
+          }
+        }
+      } catch (error) {
+        console.warn("Failed to scan routes:", error);
+      }
+    }
+    getStaticHtmlFile(path) {
+      return this.staticHtmlFiles.get(path);
+    }
+    createRoutePattern(routePath) {
+      const paramNames = [];
+      let pattern = routePath.replace(/[.*+?^${}|\\]/g, "\\$&");
+      pattern = pattern.replace(/\\?\[([^\]]+)\\?\]/g, (_match, paramName) => {
+        paramNames.push(paramName);
+        return "([^/]+)";
+      });
+      try {
+        const regex = new RegExp(`^${pattern}$`);
+        return { regex, paramNames };
+      } catch (error) {
+        console.warn(`Failed to create pattern for ${routePath}:`, error);
+        return null;
+      }
+    }
+    getRouteType(pathname) {
+      if (pathname.startsWith("/api"))
+        return "api";
+      if (pathname.includes("[") || pathname.includes(":"))
+        return "dynamic";
+      return "static";
+    }
+    matchRoute(path) {
+      if (this.routeCache.has(path)) {
+        return this.routeCache.get(path);
+      }
+      let match = null;
+      if (this.preloadedRoutes.has(path)) {
+        match = {
+          route: path,
+          params: {},
+          exports: this.preloadedRoutes.get(path),
+          routeType: this.getRouteType(path)
+        };
+      }
+      if (!match) {
+        for (const routePattern of this.routePatterns) {
+          const regexMatch = path.match(routePattern.pattern);
+          if (regexMatch) {
+            const params = {};
+            routePattern.paramNames.forEach((name, index) => {
+              params[name] = regexMatch[index + 1];
+            });
+            let routePath = routePattern.filePath.replace(this.config.routesDir, "").replace(/\.(tsx?|jsx?)$/, "");
+            if (!routePath.startsWith("/")) {
+              routePath = "/" + routePath;
+            }
+            const exports = this.preloadedRoutes.get(routePath);
+            if (exports) {
+              match = {
+                route: path,
+                params,
+                exports,
+                routeType: routePattern.routeType
+              };
+              break;
+            }
+          }
+        }
+      }
+      this.routeCache.set(path, match);
+      return match;
+    }
+    async handleRequest(request) {
+      const url = request.url;
+      const pathStart = url.indexOf("/", 8);
+      const pathEnd = url.indexOf("?", pathStart);
+      const path = pathEnd === -1 ? url.slice(pathStart) : url.slice(pathStart, pathEnd);
+      if (path.startsWith("/api/")) {
+        return this.handleApiRouteFast(request, path);
+      }
+      if (path.endsWith(".css") || path === "/favicon.ico") {
+        const staticResponse = await this.handleStaticFile(path);
+        if (staticResponse)
+          return staticResponse;
+      }
+      if (!this.config.dev) {
+        const outDir = this.config.outDir || "./dist";
+        const filePath = `${outDir}${path === "/" ? "/index.html" : path}`;
+        const file = Bun.file(filePath);
+        if (await file.exists()) {
+          return new Response(file);
+        }
+      }
+      const htmlFilePath = this.staticHtmlFiles.get(path);
+      if (htmlFilePath) {
+        const file = Bun.file(htmlFilePath);
+        if (await file.exists()) {
+          return new Response(file, {
+            headers: {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": this.config.dev ? "no-cache" : "public, max-age=3600"
+            }
+          });
+        }
+      }
+      const match = this.matchRoute(path);
+      if (!match) {
+        return Router.NOT_FOUND_RESPONSE;
+      }
+      const { params, exports, routeType } = match;
+      const context = this.getContextFromPool(request, params, url);
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        const actionHandler = exports[request.method];
+        if (actionHandler && typeof actionHandler === "function") {
+          try {
+            const result = await actionHandler(context);
+            this.returnContextToPool(context);
+            return result;
+          } catch (error) {
+            this.returnContextToPool(context);
+            console.error(`Error handling ${request.method}:`, error);
+            return Router.INTERNAL_ERROR_RESPONSE;
+          }
+        }
+        this.returnContextToPool(context);
+        return Router.METHOD_NOT_ALLOWED_RESPONSE;
+      }
+      try {
+        const data = exports.load ? await exports.load(context) : {};
+        if (data instanceof Response) {
+          this.returnContextToPool(context);
+          return data;
+        }
+        const meta = exports.meta || {};
+        const html = await this.renderPage(exports.default, { data, params, state: context.state }, exports.ui, meta, { clientScript: exports.clientScript });
+        const cacheControl = routeType === "dynamic" ? "no-cache" : "public, max-age=3600";
+        this.returnContextToPool(context);
+        return new Response(html, {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+            "Cache-Control": cacheControl
+          }
+        });
+      } catch (error) {
+        this.returnContextToPool(context);
+        if (error instanceof Response)
+          return error;
+        console.error("Error rendering page:", error);
+        return Router.INTERNAL_ERROR_RESPONSE;
+      }
+    }
+    async handleApiRouteFast(request, path) {
+      let exports = this.apiRoutes.get(path);
+      let params = {};
+      if (!exports) {
+        for (const routePattern of this.routePatterns) {
+          if (routePattern.routeType === "api") {
+            const regexMatch = path.match(routePattern.pattern);
+            if (regexMatch) {
+              routePattern.paramNames.forEach((name, index) => {
+                params[name] = regexMatch[index + 1];
+              });
+              for (const [preloadedPath, preloadedExports] of this.preloadedRoutes.entries()) {
+                if (preloadedPath.includes("[") && preloadedPath.startsWith("/api/")) {
+                  exports = preloadedExports;
+                  break;
+                }
+              }
+              if (exports)
+                break;
+            }
+          }
+        }
+      }
+      if (!exports)
+        return Router.NOT_FOUND_RESPONSE;
+      const handler = exports[request.method] || exports.default;
+      if (!handler || typeof handler !== "function") {
+        return Router.METHOD_NOT_ALLOWED_RESPONSE;
+      }
+      try {
+        const context = this.getMinimalApiContext(request, params);
+        const response = await handler(context);
+        if (response instanceof Response)
+          return response;
+        return new Response(JSON.stringify(response), {
+          headers: { "Content-Type": "application/json" }
+        });
+      } catch (error) {
+        console.error(`API Error [${request.method} ${path}]:`, error);
+        return Router.INTERNAL_ERROR_RESPONSE;
+      }
+    }
+    getContextFromPool(request, params, url) {
+      if (this.contextPool.length > 0) {
+        const context = this.contextPool.pop();
+        context.request = request;
+        context.params = params;
+        context.query = new URLSearchParams(url.split("?")[1] || "");
+        context.state = {};
+        return context;
+      }
+      return {
+        request,
+        params,
+        query: new URLSearchParams(url.split("?")[1] || ""),
+        state: {}
+      };
+    }
+    returnContextToPool(context) {
+      if (this.contextPool.length < 100) {
+        this.contextPool.push(context);
+      }
+    }
+    getMinimalApiContext(request, params = {}) {
+      return {
+        request,
+        params,
+        query: new URLSearchParams(request.url.split("?")[1] || ""),
+        state: {}
+      };
+    }
+    async handleStaticFile(path) {
+      if (path.endsWith(".css")) {
+        const cssPath = this.config.tailwind?.cssPath || "./styles.css";
+        try {
+          const cssFile = Bun.file(cssPath);
+          if (await cssFile.exists()) {
+            return new Response(cssFile, {
+              headers: {
+                "Content-Type": "text/css",
+                "Cache-Control": this.config.dev ? "no-cache" : "public, max-age=3600"
+              }
+            });
+          }
+        } catch {}
+      }
+      if (path === "/favicon.ico") {
+        return new Response(null, { status: 204 });
+      }
+      return null;
+    }
+    async renderPage(PageComponent, props, uiFramework = "react", meta = {}, options = {}) {
+      switch (uiFramework) {
+        case "react":
+          const reactContent = await ReactAdapter.renderToString(PageComponent, props);
+          return ReactAdapter.createDocument(reactContent, meta, this.config, {
+            clientScript: options.clientScript
+          });
+        case "htmx":
+          const htmxContent = await HTMXAdapter.renderToString(PageComponent, props);
+          return HTMXAdapter.createDocument(htmxContent, meta, this.config);
+        default:
+          throw new Error(`Unsupported UI framework: ${uiFramework}`);
+      }
+    }
+  };
+});
+
+// src/server/server.ts
+class KilatServer {
+  router;
+  config;
+  appDir;
+  routesDir;
+  constructor(config) {
+    this.config = config;
+    const { appDir, routesDir } = this.resolvePaths(config);
+    this.appDir = appDir;
+    this.routesDir = routesDir;
+    this.router = new Router({ ...config, routesDir: this.routesDir });
+  }
+  resolvePaths(config) {
+    const cwd = process.cwd();
+    const appDir = config.appDir.startsWith("/") ? config.appDir : `${cwd}/${config.appDir}`;
+    const routesPath = `${appDir}/routes`;
+    const pagesPath = `${appDir}/pages`;
+    const checkRoutes = Bun.spawnSync(["test", "-d", routesPath]);
+    if (checkRoutes.exitCode === 0) {
+      return { appDir, routesDir: routesPath };
+    }
+    const checkPages = Bun.spawnSync(["test", "-d", pagesPath]);
+    if (checkPages.exitCode === 0) {
+      return { appDir, routesDir: pagesPath };
+    }
+    console.warn(`⚠️ No routes/ or pages/ folder found in ${appDir}, defaulting to routes/`);
+    return { appDir, routesDir: routesPath };
+  }
+  async start() {
+    const config = this.config;
+    const router = this.router;
+    if (config.tailwind?.enabled) {
+      await this.runTailwind(false, config.dev);
+      if (config.dev) {
+        this.runTailwind(true, true);
+      }
+    }
+    await router.loadRoutes(config.dev);
+    const routes = {};
+    const cssPath = config.tailwind?.cssPath || "./styles.css";
+    routes["/styles.css"] = async () => {
+      const file = Bun.file(cssPath);
+      if (await file.exists()) {
+        return new Response(file, {
+          headers: { "Content-Type": "text/css" }
+        });
+      }
+      return new Response("", { headers: { "Content-Type": "text/css" } });
+    };
+    const server = Bun.serve({
+      port: config.port || 3000,
+      hostname: config.hostname || "localhost",
+      development: config.dev ? {
+        hmr: true,
+        console: true
+      } : false,
+      routes,
+      async fetch(request) {
+        return router.handleRequest(request);
+      }
+    });
+    if (config.dev) {
+      console.log(`
+⚡ KilatJS Dev Server
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ➜ http://${server.hostname}:${server.port}
+  ➜ HMR + Live Reload enabled
+  ➜ Edit files and see changes instantly
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+      startLiveReload();
+      watchDirectory(this.routesDir, async () => {
+        await router.loadRoutes(true);
+        notifyReload();
+      });
+      const componentsDir = `${this.appDir}/components`;
+      const checkComponents = Bun.spawnSync(["test", "-d", componentsDir]);
+      if (checkComponents.exitCode === 0) {
+        watchDirectory(componentsDir, async () => {
+          await router.loadRoutes(true);
+          notifyReload();
+        });
+      }
+    } else {
+      console.log(`
+\uD83D\uDE80 KilatJS Production Server
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ➜ http://${server.hostname}:${server.port}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+    }
+    return server;
+  }
+  async buildStatic() {
+    console.log(`
+\uD83D\uDD28 KilatJS Production Build
+`);
+    if (this.config.tailwind?.enabled) {
+      await this.runTailwind(false, false);
+    }
+    await this.router.loadRoutes(true);
+    await this.ensureDir(this.config.outDir);
+    await this.displayRouteAnalysis();
+    await this.copyStaticAssets();
+    await this.generateProductionServer();
+    console.log(`
+✅ Build Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Output: ${this.config.outDir}
+   
+   Start: bun ${this.config.outDir}/server.js
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+  }
+  async displayRouteAnalysis() {
+    console.log("\uD83D\uDCC4 Routes Analysis:");
+    console.log("─────────────────────────────────────────────────────────");
+    const routes = [];
+    try {
+      const proc = Bun.spawn(["find", this.routesDir, "-name", "*.ts", "-o", "-name", "*.tsx", "-o", "-name", "*.js", "-o", "-name", "*.jsx"], {
+        stdout: "pipe"
+      });
+      const output = await new Response(proc.stdout).text();
+      const files = output.trim().split(`
+`).filter(Boolean);
+      for (const filePath of files) {
+        const relativePath = filePath.replace(this.routesDir, "");
+        let routePath = relativePath.replace(/\.(tsx?|jsx?)$/, "");
+        if (routePath.endsWith("/index")) {
+          routePath = routePath.slice(0, -6) || "/";
+        }
+        if (!routePath.startsWith("/")) {
+          routePath = "/" + routePath;
+        }
+        let type;
+        if (routePath.startsWith("/api")) {
+          type = "API";
+        } else if (routePath.includes("[")) {
+          type = "Dynamic SSR";
+        } else {
+          type = "SSR";
+        }
+        const shortFile = relativePath.replace(/^\//, "");
+        routes.push({ path: routePath, type, file: shortFile });
+      }
+    } catch (error) {
+      console.warn("Failed to analyze routes:", error);
+    }
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    const maxPathLen = Math.max(...routes.map((r) => r.path.length), 10);
+    const maxTypeLen = Math.max(...routes.map((r) => r.type.length), 6);
+    for (const route of routes) {
+      const typeIcon = route.type === "API" ? "⚡" : route.type === "Dynamic SSR" ? "\uD83D\uDD04" : "\uD83D\uDCC4";
+      const paddedPath = route.path.padEnd(maxPathLen);
+      const paddedType = route.type.padEnd(maxTypeLen);
+      console.log(`   ${typeIcon} ${paddedPath}  ${paddedType}  ${route.file}`);
+    }
+    console.log("─────────────────────────────────────────────────────────");
+    const apiCount = routes.filter((r) => r.type === "API").length;
+    const dynamicCount = routes.filter((r) => r.type === "Dynamic SSR").length;
+    const ssrCount = routes.filter((r) => r.type === "SSR").length;
+    console.log(`   Total: ${routes.length} routes (${ssrCount} SSR, ${dynamicCount} Dynamic, ${apiCount} API)
+`);
+  }
+  async generateProductionServer() {
+    console.log(`
+⚙️  Generating production server with FileSystemRouter...`);
+    const srcOutDir = `${this.config.outDir}/src`;
+    await this.copyDir(this.appDir, srcOutDir);
+    console.log(`   ✓ src/ (copied with all components and routes)`);
+    const serverCode = `#!/usr/bin/env bun
+/**
+ * KilatJS Production Server with FileSystemRouter
+ * Generated at: ${new Date().toISOString()}
+ * 
+ * Uses Bun's built-in FileSystemRouter for optimal performance
+ */
+
+const PORT = process.env.PORT || ${this.config.port || 3000};
+const HOST = process.env.HOST || "${this.config.hostname || "localhost"}";
+const ROOT = import.meta.dir;
+
+// Initialize FileSystemRouter
+const fsRouter = new Bun.FileSystemRouter({
+    dir: ROOT + "/src/routes",
+    style: "nextjs",
+    origin: \`http://\${HOST}:\${PORT}\`,
+});
+
+function getRouteType(pathname) {
+    if (pathname.startsWith("/api")) return "api";
+    if (pathname.includes("[") || pathname.includes(":")) return "dynamic";
+    return "static";
+}
+
+// React SSR support
+let React, ReactDOMServer;
+try {
+    React = await import("react");
+    ReactDOMServer = await import("react-dom/server");
+} catch (e) {
+    console.warn("React not available for SSR");
+}
+
+async function renderPage(Component, props, meta = {}) {
+    if (!ReactDOMServer || !React) {
+        return "<html><body>React not available for SSR</body></html>";
+    }
+    
+    const content = ReactDOMServer.renderToString(React.createElement(Component, props));
+    return \`<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>\${meta.title || "KilatJS App"}</title>
+    \${meta.description ? \`<meta name="description" content="\${meta.description}" />\` : ""}
+    <link rel="stylesheet" href="/styles.css" />
+</head>
+<body>
+    <div id="root">\${content}</div>
+</body>
+</html>\`;
+}
+
+console.log(\`
+\uD83D\uDE80 KilatJS Production Server (FileSystemRouter)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   http://\${HOST}:\${PORT}
+   Using Bun FileSystemRouter for optimal performance
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+\`);
+
+Bun.serve({
+    port: PORT,
+    hostname: HOST,
+    async fetch(req) {
+        const url = new URL(req.url);
+        const path = url.pathname;
+        
+        // 1. Try static files first
+        const staticFile = Bun.file(ROOT + (path === "/" ? "/index.html" : path));
+        if (await staticFile.exists()) {
+            return new Response(staticFile);
+        }
+        
+        // 2. Try index.html for directories
+        const indexFile = Bun.file(ROOT + path + "/index.html");
+        if (await indexFile.exists()) {
+            return new Response(indexFile);
+        }
+        
+        // 3. Use FileSystemRouter for dynamic routes
+        const match = fsRouter.match(path);
+        if (!match) {
+            console.log(\`No route match found for: \${path}\`);
+            return new Response("404 Not Found", { status: 404 });
+        }
+        
+        // Use relative path for cleaner logs
+        const relativePath = match.filePath.replace(ROOT + "/", "");
+        console.log(\`Route matched: \${path} -> \${relativePath}\`);
+        
+        try {
+            // Dynamically import the route
+            const routeExports = await import(match.filePath);
+            const routeType = getRouteType(match.pathname);
+            const params = match.params || {};
+            const ctx = { 
+                request: req, 
+                params, 
+                query: url.searchParams, 
+                state: {} 
+            };
+            
+            // API routes
+            if (routeType === "api") {
+                const handler = routeExports[req.method] || routeExports.default;
+                if (!handler) {
+                    return new Response(JSON.stringify({ error: "Method Not Allowed" }), {
+                        status: 405,
+                        headers: { "Content-Type": "application/json" }
+                    });
+                }
+                
+                const result = await handler(ctx);
+                if (result instanceof Response) return result;
+                
+                return new Response(JSON.stringify(result), {
+                    headers: { "Content-Type": "application/json" }
+                });
+            }
+            
+            // Page routes - handle HTTP methods
+            if (req.method !== "GET" && req.method !== "HEAD") {
+                const handler = routeExports[req.method];
+                if (handler) return await handler(ctx);
+                return new Response("Method Not Allowed", { status: 405 });
+            }
+            
+            // GET requests - SSR
+            const data = routeExports.load ? await routeExports.load(ctx) : {};
+            if (data instanceof Response) return data;
+            
+            const html = await renderPage(
+                routeExports.default, 
+                { data, params, state: {} }, 
+                routeExports.meta || {}
+            );
+            
+            const cacheControl = routeType === "dynamic" ? "no-cache" : "public, max-age=3600";
+            
+            return new Response(html, {
+                headers: { 
+                    "Content-Type": "text/html; charset=utf-8",
+                    "Cache-Control": cacheControl
+                }
+            });
+            
+        } catch (error) {
+            if (error instanceof Response) return error;
+            console.error("Route error:", error);
+            return new Response("Internal Server Error", { status: 500 });
+        }
+    }
+});
+`;
+    const serverPath = `${this.config.outDir}/server.js`;
+    await Bun.write(serverPath, serverCode);
+    console.log(`   ✓ server.js (FileSystemRouter-based)`);
+  }
+  async runTailwind(watch, silent = false) {
+    const { inputPath, cssPath } = this.config.tailwind || {};
+    if (!inputPath || !cssPath) {
+      if (!silent)
+        console.warn("⚠️ Tailwind enabled but inputPath or cssPath missing");
+      return;
+    }
+    const resolvedInputPath = inputPath.startsWith("/") ? inputPath : `${process.cwd()}/${inputPath}`;
+    const resolvedCssPath = cssPath.startsWith("/") ? cssPath : `${process.cwd()}/${cssPath}`;
+    const args = ["bunx", "@tailwindcss/cli", "-i", resolvedInputPath, "-o", resolvedCssPath];
+    if (watch) {
+      args.push("--watch");
+    }
+    if (!silent) {
+      console.log(`\uD83C\uDFA8 ${watch ? "Watching" : "Building"} Tailwind CSS...`);
+    }
+    try {
+      const proc = Bun.spawn(args, {
+        stdout: silent ? "pipe" : "inherit",
+        stderr: silent ? "pipe" : "inherit",
+        cwd: process.cwd()
+      });
+      if (!watch) {
+        await proc.exited;
+      }
+    } catch (error) {
+      if (!silent)
+        console.error("Failed to run Tailwind:", error);
+    }
+  }
+  async copyStaticAssets() {
+    console.log(`
+\uD83D\uDCE6 Copying static assets...`);
+    const cssPath = this.config.tailwind?.cssPath || "./styles.css";
+    const cssFile = Bun.file(cssPath);
+    if (await cssFile.exists()) {
+      const outputCssPath = `${this.config.outDir}/styles.css`;
+      await Bun.write(outputCssPath, cssFile);
+      console.log(`   ✓ styles.css`);
+    }
+    if (this.config.publicDir) {
+      const publicFile = Bun.file(this.config.publicDir);
+      if (await publicFile.exists()) {
+        await this.copyDir(this.config.publicDir, this.config.outDir);
+        console.log(`   ✓ public assets`);
+      }
+    }
+  }
+  async copyDir(src, dest) {
+    try {
+      const proc = Bun.spawn(["cp", "-r", src, dest], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+    } catch (error) {
+      console.warn(`Failed to copy ${src} to ${dest}:`, error);
+    }
+  }
+  async ensureDir(dir) {
+    try {
+      const proc = Bun.spawn(["mkdir", "-p", dir], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+    } catch (error) {
+      console.warn(`Failed to create directory ${dir}:`, error);
+    }
+  }
+}
+var init_server = __esm(() => {
+  init_router();
+  init_live_reload();
+});
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  stopLiveReload: () => stopLiveReload,
+  startLiveReload: () => startLiveReload,
+  startDevServer: () => startDevServer,
+  runCLI: () => runCLI,
+  notifyReload: () => notifyReload,
+  defineMeta: () => defineMeta,
+  defineLoader: () => defineLoader,
+  defineConfig: () => defineConfig,
+  defaultConfig: () => defaultConfig,
+  default: () => src_default,
+  createKilat: () => createKilat,
+  buildStatic: () => buildStatic,
+  Router: () => Router,
+  ReactAdapter: () => ReactAdapter,
+  KilatServer: () => KilatServer,
+  HTMXAdapter: () => HTMXAdapter
+});
+function createKilat(config = {}) {
+  const tailwindConfig = {
+    enabled: config.tailwind?.enabled ?? defaultConfig.tailwind?.enabled ?? false,
+    inputPath: config.tailwind?.inputPath,
+    cssPath: config.tailwind?.cssPath ?? defaultConfig.tailwind?.cssPath ?? "./styles.css",
+    configPath: config.tailwind?.configPath ?? defaultConfig.tailwind?.configPath
+  };
+  const finalConfig = {
+    ...defaultConfig,
+    ...config,
+    tailwind: tailwindConfig
+  };
+  return new KilatServer(finalConfig);
+}
+async function startDevServer(config = {}) {
+  const server = createKilat({ ...config, dev: true });
+  return server.start();
+}
+async function buildStatic(config = {}) {
+  const server = createKilat(config);
+  return server.buildStatic();
+}
+function defineLoader(loader) {
+  return loader;
+}
+function defineConfig(config) {
+  return config;
+}
+function defineMeta(meta) {
+  return meta;
+}
+async function runCLI(args = process.argv.slice(2)) {
+  const command = args[0];
+  if (!command) {
+    console.error("Please specify a command: dev or build");
+    process.exit(1);
+  }
+  async function loadConfig() {
+    const configPath = `${process.cwd()}/kilat.config.ts`;
+    const file = Bun.file(configPath);
+    if (!await file.exists()) {
+      console.warn("⚠️ No kilat.config.ts found, using defaults");
+      return {};
+    }
+    try {
+      const configModule = await import(configPath);
+      return configModule.default || configModule;
+    } catch (error) {
+      console.error("Failed to load config:", error);
+      return {};
+    }
+  }
+  const config = await loadConfig();
+  switch (command) {
+    case "dev":
+      const isProduction = args.includes("--production");
+      const devServer = createKilat({ ...config, dev: !isProduction });
+      await devServer.start();
+      break;
+    case "build":
+      await buildStatic(config);
+      break;
+    case "serve":
+      const serveOutDir = config.outDir || "./dist";
+      const serverPath = `${process.cwd()}/${serveOutDir}/server.js`;
+      const serverFile = Bun.file(serverPath);
+      if (!await serverFile.exists()) {
+        console.error(`❌ Production server not found at ${serveOutDir}/server.js`);
+        console.error(`   Run 'kilat build' first to generate the production build.`);
+        process.exit(1);
+      }
+      const serveProc = Bun.spawn(["bun", serverPath], {
+        stdio: ["inherit", "inherit", "inherit"],
+        cwd: process.cwd()
+      });
+      await serveProc.exited;
+      break;
+    case "preview":
+      const outDir = config.outDir || "./dist";
+      const port = config.port || 3000;
+      const hostname = config.hostname || "localhost";
+      const root = `${process.cwd()}/${outDir}`;
+      console.log(`
+\uD83D\uDD0D Preview server running:`);
+      console.log(`   ➜ http://${hostname}:${port}`);
+      console.log(`   Serving: ${outDir}
+`);
+      Bun.serve({
+        port,
+        hostname,
+        async fetch(req) {
+          const url = new URL(req.url);
+          let path = url.pathname;
+          const filePath = `${root}${path}`;
+          let file = Bun.file(filePath);
+          if (await file.exists()) {
+            return new Response(file);
+          }
+          const indexHtml = `${filePath}/index.html`;
+          file = Bun.file(indexHtml);
+          if (await file.exists()) {
+            return new Response(file);
+          }
+          const rootIndex = `${root}/index.html`;
+          file = Bun.file(rootIndex);
+          if (await file.exists()) {
+            return new Response(file);
+          }
+          return new Response("404 Not Found", { status: 404 });
+        }
+      });
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      console.log("Available commands: dev, build, serve, preview");
+      process.exit(1);
+  }
+}
+var defaultConfig, Kilat, src_default;
+var init_src = __esm(() => {
+  init_router();
+  init_server();
+  init_react();
+  init_htmx();
+  init_live_reload();
+  init_server();
+  defaultConfig = {
+    appDir: "./src",
+    outDir: "./dist",
+    port: 3000,
+    hostname: "localhost",
+    dev: false,
+    tailwind: {
+      enabled: false,
+      cssPath: "./styles.css"
+    }
+  };
+  Kilat = {
+    createKilat,
+    startDevServer,
+    buildStatic,
+    defineConfig,
+    defineLoader,
+    defineMeta,
+    runCLI,
+    defaultConfig
+  };
+  src_default = Kilat;
+});
+
+// src/cli.ts
+var args = process.argv.slice(2);
+var command = args[0];
+var isHotMode = process.env.__KILAT_HOT === "1";
+var isProduction = args.includes("--production");
+if (command === "dev" && !isHotMode && !isProduction) {
+  const scriptPath = import.meta.path;
+  const proc = Bun.spawn(["bun", "--hot", scriptPath, ...args], {
+    stdio: ["inherit", "inherit", "inherit"],
+    env: { ...process.env, __KILAT_HOT: "1" },
+    cwd: process.cwd()
+  });
+  const exitCode = await proc.exited;
+  process.exit(exitCode);
+} else {
+  const { runCLI: runCLI2 } = await Promise.resolve().then(() => (init_src(), exports_src));
+  runCLI2(args).catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}