npm - kilatjs - Versions diffs - 0.1.0 - Mend

kilatjs 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1046 @@
+// 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);
+      const html = renderToStaticMarkup(element);
+      return html;
+    } catch (error) {
+      console.error("Error rendering React component:", error);
+      throw error;
+    }
+  }
+  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)}" />
+    `;
+      }
+    });
+    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" />
+    `;
+    return `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>${this.escapeHtml(title)}</title>
+    ${metaTags}
+  </head>
+  <body>
+    <div id="root">
+      ${html}
+    </div>
+    ${config?.dev ? `<script>
+      (function() {
+        let currentServerId = null;
+        let isReconnecting = false;
+        function connect() {
+            const source = new EventSource('/_kilat/live-reload');
+            source.onmessage = (event) => {
+                const newServerId = event.data;
+                if (currentServerId === null) {
+                    currentServerId = newServerId;
+                } else if (currentServerId !== newServerId) {
+                    // Server ID changed, reload!
+                    location.reload();
+                }
+            };
+            source.onerror = () => {
+                source.close();
+                // Try to reconnect in 1s
+                setTimeout(connect, 1000);
+            };
+        }
+        connect();
+      })();
+    </script>` : ""}
+  </body>
+</html>`;
+  }
+  static escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+}
+// 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>
+  </body>
+</html>`;
+  }
+  static escapeHtml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+  }
+}
+// src/core/router.ts
+class Router {
+  routes = new Map;
+  config;
+  staticPaths = new Map;
+  serverId = Date.now().toString();
+  fsRouter;
+  routeCache = new Map;
+  preloadedRoutes = new Map;
+  routePatterns = [];
+  apiRoutes = new Map;
+  staticApiResponses = 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 = [];
+  poolIndex = 0;
+  constructor(config) {
+    this.config = config;
+    const routesDir = config.routesDir.startsWith("/") ? config.routesDir : `${process.cwd()}/${config.routesDir}`;
+    this.fsRouter = new Bun.FileSystemRouter({
+      dir: routesDir,
+      style: "nextjs",
+      origin: `http://${config.hostname || "localhost"}:${config.port || 3000}`
+    });
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  getStaticPaths() {
+    return this.staticPaths;
+  }
+  async loadRoutes() {
+    if (this.config.dev) {
+      this.fsRouter.reload();
+      this.routeCache.clear();
+      this.preloadedRoutes.clear();
+      this.routePatterns.length = 0;
+    }
+    await this.preloadAllRoutes();
+    console.log("\uD83D\uDD04 FileSystemRouter initialized with", this.preloadedRoutes.size, "preloaded routes");
+    if (this.config.dev) {
+      console.log("\uD83D\uDCCB Preloaded routes:");
+      for (const [route, exports] of this.preloadedRoutes.entries()) {
+        console.log(`   ${route} (${route.includes("[") ? "dynamic" : "static"})`);
+      }
+      console.log("\uD83D\uDCCB Dynamic route patterns:", this.routePatterns.length);
+      for (const pattern of this.routePatterns) {
+        console.log(`   ${pattern.pattern} -> ${pattern.filePath}`);
+      }
+    }
+  }
+  async preloadAllRoutes() {
+    const routesDir = this.config.routesDir.startsWith("/") ? this.config.routesDir : `${process.cwd()}/${this.config.routesDir}`;
+    await this.scanAndPreloadRoutes(routesDir, "");
+  }
+  async scanAndPreloadRoutes(dir, basePath) {
+    try {
+      const proc = Bun.spawn(["find", dir, "-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(dir, "");
+        let routePath = relativePath.replace(/\.(tsx?|jsx?)$/, "");
+        if (routePath.endsWith("/index")) {
+          routePath = routePath.slice(0, -6) || "/";
+        }
+        if (!routePath.startsWith("/")) {
+          routePath = "/" + routePath;
+        }
+        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);
+    }
+  }
+  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}$`);
+      console.log(`Created pattern for ${routePath}: ${regex} (params: ${paramNames.join(", ")})`);
+      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];
+          });
+          const routesDir = this.config.routesDir.startsWith("/") ? this.config.routesDir : `${process.cwd()}/${this.config.routesDir}`;
+          let routePath = routePattern.filePath.replace(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;
+  }
+  pathMatchesPattern(pattern, path) {
+    const patternParts = pattern.split("/").filter(Boolean);
+    const pathParts = path.split("/").filter(Boolean);
+    if (patternParts.length !== pathParts.length) {
+      return false;
+    }
+    for (let i = 0;i < patternParts.length; i++) {
+      const patternPart = patternParts[i];
+      const pathPart = pathParts[i];
+      if (!patternPart.startsWith("[") && patternPart !== pathPart) {
+        return false;
+      }
+    }
+    return true;
+  }
+  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" || path === "/_kilat/live-reload") {
+      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);
+      }
+      if (!path.endsWith(".html")) {
+        const indexFile = Bun.file(`${filePath}/index.html`);
+        if (await indexFile.exists()) {
+          return new Response(indexFile);
+        }
+      }
+    }
+    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);
+      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/") && this.pathMatchesPattern(preloadedPath, path)) {
+                exports = preloadedExports;
+                break;
+              }
+            }
+            if (exports)
+              break;
+          }
+        }
+      }
+    }
+    if (!exports) {
+      return Router.NOT_FOUND_RESPONSE;
+    }
+    const method = request.method;
+    const handler = exports[method] || exports.default;
+    if (!handler || typeof handler !== "function") {
+      return Router.METHOD_NOT_ALLOWED_RESPONSE;
+    }
+    try {
+      const context = this.getMinimalApiContext(request, path, 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 [${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, path, 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": "public, max-age=3600"
+            }
+          });
+        }
+      } catch (error) {}
+    }
+    if (path === "/favicon.ico") {
+      return new Response(null, { status: 204 });
+    }
+    if (path === "/_kilat/live-reload") {
+      const serverId = this.serverId;
+      return new Response(new ReadableStream({
+        start(controller) {
+          controller.enqueue(`data: ${serverId}
+`);
+        }
+      }), {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive"
+        }
+      });
+    }
+    return null;
+  }
+  create404Response() {
+    const html = `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>404 - Page Not Found</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <link rel="stylesheet" href="/styles.css" />
+  </head>
+  <body>
+    <div id="root">
+      <div class="container">
+        <h1>404 - Page Not Found</h1>
+        <p>The page you're looking for doesn't exist.</p>
+        <a href="/">Go back home</a>
+      </div>
+    </div>
+  </body>
+</html>`;
+    return new Response(html, {
+      status: 404,
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
+  async renderPage(PageComponent, props, uiFramework = "react", meta = {}) {
+    switch (uiFramework) {
+      case "react":
+        const reactContent = await ReactAdapter.renderToString(PageComponent, props);
+        return ReactAdapter.createDocument(reactContent, meta, this.config);
+      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;
+  constructor(config) {
+    this.config = config;
+    this.router = new Router(config);
+  }
+  async start() {
+    if (this.config.tailwind?.enabled) {
+      console.log("\uD83C\uDFA8 Building Tailwind CSS...");
+      await this.runTailwind(false);
+      if (this.config.dev) {
+        this.runTailwind(true);
+      }
+    }
+    await this.router.loadRoutes();
+    const router = this.router;
+    const config = this.config;
+    const server = Bun.serve({
+      port: config.port || 3000,
+      hostname: config.hostname || "localhost",
+      async fetch(request) {
+        return router.handleRequest(request);
+      }
+    });
+    console.log(`
+\uD83D\uDE80 KilatJS Server Running!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Local:   http://${server.hostname}:${server.port}
+   Mode:    ${config.dev ? "Development" : "Production"}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+    if (config.dev) {
+      console.log("\uD83D\uDCC1 Using FileSystemRouter for dynamic route discovery");
+      console.log("");
+    }
+    return server;
+  }
+  async buildStatic() {
+    if (this.config.tailwind?.enabled) {
+      await this.runTailwind(false);
+    }
+    await this.router.loadRoutes();
+    console.log(`\uD83D\uDD28 Building for hybrid deployment...
+`);
+    await this.ensureDir(this.config.outDir);
+    console.log("\uD83D\uDCC4 Static build with FileSystemRouter:");
+    console.log("─────────────────────────────────────");
+    console.log("   Using Bun's built-in FileSystemRouter for dynamic routing");
+    console.log("   Static assets will be copied to output directory");
+    await this.copyStaticAssets();
+    await this.generateProductionServer();
+    console.log(`
+✅ Hybrid Build Complete!
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+   Using Bun FileSystemRouter for all routes
+   Output: ${import.meta.dir}/../${this.config.outDir}
+   Run 'bun dist/server.js' to start the server.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+  }
+  async generateProductionServer() {
+    console.log(`
+⚙️  Generating production server with FileSystemRouter...`);
+    const srcDir = this.config.routesDir.replace("/routes", "");
+    const srcOutDir = `${this.config.outDir}/src`;
+    await this.copyDir(srcDir, 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 });
+        }
+        console.log(\`Route matched: \${path} -> \${match.filePath}\`);
+        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)`);
+  }
+  formatSize(bytes) {
+    if (bytes < 1024)
+      return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  }
+  async runTailwind(watch) {
+    const { inputPath, cssPath } = this.config.tailwind || {};
+    if (!inputPath || !cssPath) {
+      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");
+    }
+    console.log(`\uD83C\uDFA8 ${watch ? "Watching" : "Building"} Tailwind CSS...`);
+    try {
+      const proc = Bun.spawn(args, {
+        stdout: "inherit",
+        stderr: "inherit",
+        cwd: process.cwd()
+      });
+      if (!watch) {
+        await proc.exited;
+      }
+    } catch (error) {
+      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);
+    }
+  }
+}
+// src/index.ts
+var defaultConfig = {
+  routesDir: "./routes",
+  outDir: "./dist",
+  port: 3000,
+  hostname: "localhost",
+  dev: false,
+  tailwind: {
+    enabled: false,
+    cssPath: "./styles.css"
+  }
+};
+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;
+}
+var Kilat = {
+  createKilat,
+  startDevServer,
+  buildStatic,
+  defineConfig,
+  defineLoader,
+  defineMeta,
+  defaultConfig
+};
+var src_default = Kilat;
+export {
+  startDevServer,
+  defineMeta,
+  defineLoader,
+  defineConfig,
+  defaultConfig,
+  src_default as default,
+  createKilat,
+  buildStatic,
+  Router,
+  ReactAdapter,
+  KilatServer,
+  HTMXAdapter
+};