baraqex 2.0.0 → 2.0.2

package/dist/index.js

@@ -1,19 +1,47 @@
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 
+// src/core/batch.ts
+var isBatching = false;
+var syncQueue = [];
+var asyncQueue = [];
+async function batchUpdates(fn) {
+  if (isBatching) {
+    if (fn.constructor.name === "AsyncFunction") {
+      asyncQueue.push(fn);
+    } else {
+      syncQueue.push(fn);
+    }
+    return;
+  }
+  isBatching = true;
+  try {
+    const result = fn();
+    if (result instanceof Promise) {
+      await result;
+    }
+    while (syncQueue.length > 0) {
+      const nextFn = syncQueue.shift();
+      nextFn();
+    }
+    while (asyncQueue.length > 0) {
+      const nextFn = asyncQueue.shift();
+      await nextFn();
+    }
+  } finally {
+    isBatching = false;
+  }
+}
+function getIsBatching() {
+  return isBatching;
+}
+
 // src/core/context.ts
+var contextStacks = /* @__PURE__ */ new Map();
 function createContext(defaultValue) {
   const id = Symbol("context");
   contextStacks.set(id, []);
@@ -50,15 +78,9 @@ function useContext(context) {
 function getContextValue(context) {
   return useContext(context);
 }
-var contextStacks;
-var init_context = __esm({
-  "src/core/context.ts"() {
-    "use strict";
-    contextStacks = /* @__PURE__ */ new Map();
-  }
-});
 
 // src/core/hooks.ts
+var rootIdCounter = 0;
 function createRootState() {
   return {
     id: ++rootIdCounter,
@@ -69,6 +91,10 @@ function createRootState() {
     currentElement: null
   };
 }
+var currentRoot = null;
+var currentComponentId = null;
+var hookIndex = 0;
+var isServer = typeof window === "undefined";
 function prepareRender(root, componentId) {
   if (root) {
     currentRoot = root;
@@ -237,6 +263,7 @@ function useErrorBoundary() {
   const resetError = () => setError(null);
   return [error, resetError];
 }
+var idCounter = 0;
 function useId() {
   const ref = useRef(null);
   if (ref.current === null) {
@@ -263,20 +290,215 @@ function cleanupRoot(root) {
   });
   root.components.clear();
 }
-var rootIdCounter, currentRoot, currentComponentId, hookIndex, isServer, idCounter;
-var init_hooks = __esm({
-  "src/core/hooks.ts"() {
-    "use strict";
-    rootIdCounter = 0;
-    currentRoot = null;
-    currentComponentId = null;
-    hookIndex = 0;
-    isServer = typeof window === "undefined";
-    idCounter = 0;
+
+// src/core/jsx-runtime.ts
+var isBrowser = typeof document !== "undefined";
+function jsx(type, props, key) {
+  const processedProps = { ...props };
+  if (key !== void 0) {
+    processedProps.key = key;
   }
-});
+  if (arguments.length > 3) {
+    processedProps.children = Array.prototype.slice.call(arguments, 3);
+  }
+  return { type, props: processedProps, key: processedProps.key };
+}
+var jsxs = jsx;
+function jsxDEV(type, props, key, _isStaticChildren, _source, _self) {
+  return jsx(type, props, key);
+}
+var Fragment = ({ children }) => children;
+function assertBrowser(method) {
+  if (!isBrowser) {
+    throw new Error(
+      `[baraqex] ${method}() can only be called in a browser environment. Use renderToString() for server-side rendering.`
+    );
+  }
+}
+function createTextNode(text) {
+  return document.createTextNode(text);
+}
+function applyProps(element, props) {
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children")
+      continue;
+    if (key === "className") {
+      element.setAttribute("class", String(value));
+    } else if (key === "htmlFor") {
+      element.setAttribute("for", String(value));
+    } else if (key.startsWith("on") && typeof value === "function") {
+      const eventName = key.slice(2).toLowerCase();
+      element.addEventListener(eventName, value);
+    } else if (key === "style" && typeof value === "object") {
+      Object.assign(element.style, value);
+    } else if (key === "dangerouslySetInnerHTML" && value && value.__html) {
+      element.innerHTML = value.__html;
+    } else if (key === "ref") {
+      if (typeof value === "function") {
+        value(element);
+      } else if (value && typeof value === "object" && "current" in value) {
+        value.current = element;
+      }
+    } else if (value !== false && value != null) {
+      if (value === true) {
+        element.setAttribute(key, "");
+      } else {
+        element.setAttribute(key, String(value));
+      }
+    }
+  }
+}
+async function createElement(vnode) {
+  assertBrowser("createElement");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      const node = await createElement(child);
+      fragment.appendChild(node);
+    }
+    return fragment;
+  }
+  if (typeof vnode === "object" && "type" in vnode && vnode.props !== void 0) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      if (type === Fragment) {
+        const children2 = props?.children;
+        if (children2 == null)
+          return createTextNode("");
+        return createElement(children2);
+      }
+      const root = getCurrentRoot() ?? void 0;
+      const renderId = prepareRender(root);
+      try {
+        const result = type(props || {});
+        return await createElement(result);
+      } finally {
+        finishRender();
+      }
+    }
+    const element = document.createElement(type);
+    applyProps(element, props || {});
+    const children = props?.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children : [children];
+      for (const child of childArray) {
+        const childNode = await createElement(child);
+        element.appendChild(childNode);
+      }
+    }
+    return element;
+  }
+  return createTextNode(String(vnode));
+}
+function createElementSync(vnode) {
+  assertBrowser("createElementSync");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      fragment.appendChild(createElementSync(child));
+    }
+    return fragment;
+  }
+  if (typeof vnode === "object" && "type" in vnode) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      if (type === Fragment) {
+        return createElementSync(props?.children);
+      }
+      const result = type(props || {});
+      return createElementSync(result);
+    }
+    const element = document.createElement(type);
+    applyProps(element, props || {});
+    const children = props?.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children : [children];
+      for (const child of childArray) {
+        element.appendChild(createElementSync(child));
+      }
+    }
+    return element;
+  }
+  return createTextNode(String(vnode));
+}
+
+// src/core/renderer.ts
+var isBrowser2 = typeof document !== "undefined";
+var rootMap = /* @__PURE__ */ new WeakMap();
+async function render(element, container) {
+  if (!isBrowser2) {
+    throw new Error(
+      "[baraqex] render() can only be called in a browser. Use renderToString() for server-side rendering."
+    );
+  }
+  if (!container) {
+    throw new Error("[baraqex] render() requires a container element");
+  }
+  let root = rootMap.get(container);
+  if (!root) {
+    root = createRootState();
+    rootMap.set(container, root);
+  }
+  await batchUpdates(async () => {
+    prepareRender(root);
+    try {
+      setRenderCallback(render, element, container);
+      const domNode = await createElement(element);
+      container.textContent = "";
+      container.appendChild(domNode);
+    } finally {
+      finishRender();
+    }
+  });
+}
+async function hydrate(element, container) {
+  await render(element, container);
+}
+function createRoot(container) {
+  const root = createRootState();
+  rootMap.set(container, root);
+  return {
+    render: (element) => render(element, container),
+    unmount: () => {
+      cleanupRoot(root);
+      rootMap.delete(container);
+      container.textContent = "";
+    }
+  };
+}
+function hasRoot(container) {
+  return rootMap.has(container);
+}
 
 // src/core/server-renderer.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
 function renderToString(vnode) {
   prepareRender();
   try {
@@ -383,1663 +605,6 @@ function renderNodeToString(vnode) {
 function escapeHtml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
-var VOID_ELEMENTS;
-var init_server_renderer = __esm({
-  "src/core/server-renderer.ts"() {
-    "use strict";
-    init_hooks();
-    VOID_ELEMENTS = /* @__PURE__ */ new Set([
-      "area",
-      "base",
-      "br",
-      "col",
-      "embed",
-      "hr",
-      "img",
-      "input",
-      "link",
-      "meta",
-      "param",
-      "source",
-      "track",
-      "wbr"
-    ]);
-  }
-});
-
-// src/server/database.ts
-var Database;
-var init_database = __esm({
-  "src/server/database.ts"() {
-    "use strict";
-    Database = class {
-      constructor(config) {
-        __publicField(this, "config");
-        __publicField(this, "mongoClient", null);
-        __publicField(this, "mongoDb", null);
-        __publicField(this, "mysqlPool", null);
-        __publicField(this, "pgPool", null);
-        this.config = config;
-      }
-      async connect() {
-        switch (this.config.type) {
-          case "mongodb":
-            await this.connectMongo();
-            break;
-          case "mysql":
-            await this.connectMysql();
-            break;
-          case "postgres":
-            await this.connectPostgres();
-            break;
-          default:
-            throw new Error(`Unsupported database type: ${this.config.type}`);
-        }
-      }
-      async connectMongo() {
-        try {
-          const { MongoClient } = await import("mongodb");
-          this.mongoClient = new MongoClient(this.config.url);
-          await this.mongoClient.connect();
-          this.mongoDb = this.mongoClient.db();
-          console.log("Connected to MongoDB");
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("MongoDB driver not installed. Run: npm install mongodb");
-          }
-          console.error("MongoDB connection error:", error);
-          throw error;
-        }
-      }
-      async connectMysql() {
-        try {
-          const mysql = await import("mysql2/promise");
-          this.mysqlPool = mysql.createPool(this.config.url);
-          await this.mysqlPool.getConnection();
-          console.log("Connected to MySQL");
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("MySQL driver not installed. Run: npm install mysql2");
-          }
-          console.error("MySQL connection error:", error);
-          throw error;
-        }
-      }
-      async connectPostgres() {
-        try {
-          const pg = await import("pg");
-          this.pgPool = new pg.Pool({ connectionString: this.config.url });
-          const client = await this.pgPool.connect();
-          client.release();
-          console.log("Connected to PostgreSQL");
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("PostgreSQL driver not installed. Run: npm install pg @types/pg");
-          }
-          console.error("PostgreSQL connection error:", error);
-          throw error;
-        }
-      }
-      async disconnect() {
-        if (this.mongoClient) {
-          await this.mongoClient.close();
-          this.mongoClient = null;
-          this.mongoDb = null;
-        }
-        if (this.mysqlPool) {
-          await this.mysqlPool.end();
-          this.mysqlPool = null;
-        }
-        if (this.pgPool) {
-          await this.pgPool.end();
-          this.pgPool = null;
-        }
-      }
-      // Database-specific methods
-      getMongoDb() {
-        return this.mongoDb;
-      }
-      getMysqlPool() {
-        return this.mysqlPool;
-      }
-      getPgPool() {
-        return this.pgPool;
-      }
-      // Generic query method
-      async query(sql, values) {
-        switch (this.config.type) {
-          case "mongodb":
-            throw new Error("For MongoDB, use getMongoDb() instead of query()");
-          case "mysql":
-            if (!this.mysqlPool)
-              throw new Error("MySQL not connected");
-            const [rows] = await this.mysqlPool.execute(sql, values || []);
-            return rows;
-          case "postgres":
-            if (!this.pgPool)
-              throw new Error("PostgreSQL not connected");
-            const result = await this.pgPool.query(sql, values || []);
-            return result.rows;
-          default:
-            throw new Error(`Unsupported database type: ${this.config.type}`);
-        }
-      }
-    };
-  }
-});
-
-// src/server/auth.ts
-var AuthService;
-var init_auth = __esm({
-  "src/server/auth.ts"() {
-    "use strict";
-    AuthService = class {
-      constructor(config) {
-        __publicField(this, "config");
-        __publicField(this, "jwtPromise", null);
-        this.config = {
-          expiresIn: "24h",
-          ...config
-        };
-      }
-      async getJwt() {
-        if (!this.jwtPromise) {
-          this.jwtPromise = import("jsonwebtoken").catch((error) => {
-            this.jwtPromise = null;
-            if (error.code === "MODULE_NOT_FOUND") {
-              throw new Error(
-                "jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken"
-              );
-            }
-            throw error;
-          });
-        }
-        return this.jwtPromise;
-      }
-      async hashPassword(password) {
-        try {
-          const bcrypt = await import("bcryptjs");
-          return bcrypt.hash(password, 10);
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("bcryptjs not installed. Run: npm install bcryptjs @types/bcryptjs");
-          }
-          throw error;
-        }
-      }
-      async comparePasswords(password, hashedPassword) {
-        try {
-          const bcrypt = await import("bcryptjs");
-          return bcrypt.compare(password, hashedPassword);
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("bcryptjs not installed. Run: npm install bcryptjs @types/bcryptjs");
-          }
-          throw error;
-        }
-      }
-      async generateToken(user) {
-        const jwt = await this.getJwt();
-        const options = {};
-        if (this.config.expiresIn) {
-          options.expiresIn = this.config.expiresIn;
-        }
-        return jwt.sign(
-          { id: user.id, username: user.username, roles: user.roles || [] },
-          this.config.secret,
-          options
-        );
-      }
-      async verifyToken(token) {
-        try {
-          const jwt = await this.getJwt();
-          return jwt.verify(token, this.config.secret);
-        } catch {
-          return null;
-        }
-      }
-      initialize() {
-        return async (req, res, next) => {
-          const token = this.extractToken(req);
-          if (token) {
-            const decoded = await this.verifyToken(token);
-            if (decoded) {
-              req.user = decoded;
-            }
-          }
-          next();
-        };
-      }
-      requireAuth() {
-        return (req, res, next) => {
-          if (!req.user) {
-            return res.status(401).json({ message: "Unauthorized" });
-          }
-          return next();
-        };
-      }
-      requireRoles(roles) {
-        return (req, res, next) => {
-          if (!req.user) {
-            return res.status(401).json({ message: "Unauthorized" });
-          }
-          const userRoles = req.user.roles || [];
-          const hasRequiredRole = roles.some((role) => userRoles.includes(role));
-          if (!hasRequiredRole) {
-            return res.status(403).json({ message: "Forbidden" });
-          }
-          return next();
-        };
-      }
-      extractToken(req) {
-        if (req.headers.authorization && req.headers.authorization.startsWith("Bearer ")) {
-          return req.headers.authorization.substring(7);
-        }
-        return null;
-      }
-    };
-  }
-});
-
-// src/server/api-router.ts
-import path from "path";
-import fs from "fs";
-import { pathToFileURL } from "url";
-var ApiRouter;
-var init_api_router = __esm({
-  "src/server/api-router.ts"() {
-    "use strict";
-    ApiRouter = class {
-      constructor(apiDir, auth = null) {
-        __publicField(this, "router", null);
-        __publicField(this, "apiDir");
-        __publicField(this, "auth");
-        __publicField(this, "initialized", false);
-        this.apiDir = path.resolve(process.cwd(), apiDir);
-        this.auth = auth;
-      }
-      async initialize() {
-        if (this.initialized && this.router)
-          return;
-        try {
-          const express = await import("express");
-          this.router = express.default.Router();
-          this.setupRoutes();
-          this.initialized = true;
-          console.log("\u2705 API Router initialized successfully");
-        } catch (error) {
-          console.error("\u274C Failed to initialize API Router:", error);
-          if (error.code === "MODULE_NOT_FOUND") {
-            throw new Error("Express not installed. Run: npm install express @types/express");
-          }
-          throw error;
-        }
-      }
-      isInitialized() {
-        return this.initialized && this.router !== null;
-      }
-      setupRoutes() {
-        if (!fs.existsSync(this.apiDir)) {
-          console.log(`API directory not found: ${this.apiDir}`);
-          return;
-        }
-        this.scanDirectory(this.apiDir, "");
-      }
-      scanDirectory(dirPath, routePrefix) {
-        const entries = fs.readdirSync(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path.join(dirPath, entry.name);
-          if (entry.isDirectory()) {
-            this.scanDirectory(fullPath, `${routePrefix}/${entry.name}`);
-          } else if (this.isRouteFile(entry.name)) {
-            const routePath = this.getRoutePath(entry.name, routePrefix);
-            this.registerRoute(fullPath, routePath);
-          }
-        }
-      }
-      isRouteFile(filename) {
-        return filename.endsWith(".js") || filename.endsWith(".ts") || filename.endsWith(".mjs");
-      }
-      getRoutePath(filename, routePrefix) {
-        const baseName = path.basename(filename, path.extname(filename));
-        if (baseName === "index") {
-          return routePrefix || "/";
-        }
-        const paramMatch = baseName.match(/^\[(.+)\]$/);
-        if (paramMatch) {
-          return `${routePrefix}/:${paramMatch[1]}`;
-        }
-        return `${routePrefix}/${baseName}`;
-      }
-      async registerRoute(filePath, routePath) {
-        try {
-          const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
-          const fileUrl = pathToFileURL(absolutePath).href;
-          const urlWithTimestamp = `${fileUrl}?t=${Date.now()}`;
-          const routeModule = await import(urlWithTimestamp);
-          if (!this.isValidRouteModule(routeModule)) {
-            console.warn(`Invalid route module: ${filePath}`);
-            return;
-          }
-          console.log(`Registering API route: ${routePath}`);
-          const middleware = routeModule.middleware || [];
-          for (const method of ["get", "post", "put", "delete", "patch", "options"]) {
-            const handler = routeModule[method];
-            if (typeof handler === "function") {
-              const routerMethod = this.router[method];
-              routerMethod.call(
-                this.router,
-                routePath,
-                ...middleware,
-                this.wrapHandler(handler)
-              );
-            }
-          }
-        } catch (error) {
-          console.error(`Error registering route (${filePath}):`, error);
-        }
-      }
-      isValidRouteModule(module) {
-        if (!module)
-          return false;
-        return ["get", "post", "put", "delete", "patch", "options"].some((method) => typeof module[method] === "function");
-      }
-      wrapHandler(handler) {
-        return async (req, res, next) => {
-          try {
-            await handler(req, res, next);
-          } catch (error) {
-            next(error);
-          }
-        };
-      }
-    };
-  }
-});
-
-// src/server/middleware.ts
-function rateLimit(options) {
-  const requests = /* @__PURE__ */ new Map();
-  const cleanupInterval = setInterval(() => {
-    const now = Date.now();
-    for (const [ip, times] of requests) {
-      const valid = times.filter((t) => now - t < options.windowMs);
-      if (valid.length === 0) {
-        requests.delete(ip);
-      } else {
-        requests.set(ip, valid);
-      }
-    }
-  }, options.windowMs);
-  if (cleanupInterval.unref) {
-    cleanupInterval.unref();
-  }
-  return (req, res, next) => {
-    const ip = req.ip || req.socket?.remoteAddress || "unknown";
-    const now = Date.now();
-    const reqTimes = (requests.get(ip) || []).filter((time) => now - time < options.windowMs);
-    reqTimes.push(now);
-    requests.set(ip, reqTimes);
-    if (reqTimes.length > options.max) {
-      return res.status(429).json({
-        error: {
-          message: "Too Many Requests",
-          retryAfter: Math.ceil(options.windowMs / 1e3)
-        }
-      });
-    }
-    return next();
-  };
-}
-var requestLogger, errorHandler, notFoundHandler;
-var init_middleware = __esm({
-  "src/server/middleware.ts"() {
-    "use strict";
-    requestLogger = (req, res, next) => {
-      console.log(`${(/* @__PURE__ */ new Date()).toISOString()} - ${req.method} ${req.url}`);
-      next();
-    };
-    errorHandler = (err, req, res, _next) => {
-      console.error(err.stack);
-      res.status(500).json({
-        error: {
-          message: "Internal Server Error",
-          ...process.env.NODE_ENV !== "production" ? { details: err.message, stack: err.stack } : {}
-        }
-      });
-    };
-    notFoundHandler = (req, res) => {
-      res.status(404).json({
-        error: {
-          message: `Not Found - ${req.method} ${req.url}`
-        }
-      });
-    };
-  }
-});
-
-// src/server/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  ensureDirectory: () => ensureDirectory,
-  generateToken: () => generateToken,
-  getEnvironmentInfo: () => getEnvironmentInfo,
-  getPagination: () => getPagination,
-  hashString: () => hashString,
-  isDirectoryEmpty: () => isDirectoryEmpty,
-  readJsonFile: () => readJsonFile,
-  safeJsonParse: () => safeJsonParse,
-  sendError: () => sendError,
-  sendSuccess: () => sendSuccess,
-  validateFields: () => validateFields,
-  validateFileUpload: () => validateFileUpload,
-  writeJsonFile: () => writeJsonFile
-});
-import crypto2 from "crypto";
-import fs2 from "fs/promises";
-import path2 from "path";
-function safeJsonParse(json, fallback) {
-  try {
-    return JSON.parse(json);
-  } catch (error) {
-    return fallback;
-  }
-}
-function generateToken(length = 32) {
-  return crypto2.randomBytes(length).toString("hex");
-}
-function hashString(input, salt = "") {
-  return crypto2.createHash("sha256").update(input + salt).digest("hex");
-}
-function getPagination(req) {
-  const page = Math.max(1, parseInt(req.query.page) || 1);
-  const rawLimit = parseInt(req.query.limit);
-  let limit;
-  if (isNaN(rawLimit) || rawLimit <= 0) {
-    limit = 20;
-  } else {
-    limit = Math.max(1, Math.min(100, rawLimit));
-  }
-  const skip = (page - 1) * limit;
-  return { page, limit, skip };
-}
-function sendSuccess(res, data, message = "Success") {
-  return res.json({
-    success: true,
-    message,
-    data
-  });
-}
-function sendError(res, message = "An error occurred", statusCode = 400, errors) {
-  return res.status(statusCode).json({
-    success: false,
-    message,
-    errors: errors || void 0
-  });
-}
-function validateFields(req, requiredFields) {
-  const missing = requiredFields.filter((field) => {
-    const value = req.body[field];
-    return value === void 0 || value === null || value === "";
-  });
-  return {
-    valid: missing.length === 0,
-    missing
-  };
-}
-function validateFileUpload(file, options = {}) {
-  if (!file) {
-    return { valid: false, error: "No file provided" };
-  }
-  if (options.maxSize && file.size > options.maxSize) {
-    return {
-      valid: false,
-      error: `File too large. Maximum size allowed is ${options.maxSize / 1024 / 1024}MB`
-    };
-  }
-  if (options.allowedTypes && options.allowedTypes.length > 0) {
-    const fileType = file.mimetype;
-    if (!options.allowedTypes.includes(fileType)) {
-      return {
-        valid: false,
-        error: `Invalid file type. Allowed types: ${options.allowedTypes.join(", ")}`
-      };
-    }
-  }
-  return { valid: true };
-}
-function getEnvironmentInfo() {
-  return {
-    nodeVersion: process.version,
-    platform: process.platform,
-    arch: process.arch,
-    memory: process.memoryUsage(),
-    uptime: process.uptime(),
-    env: process.env.NODE_ENV || "development"
-  };
-}
-async function isDirectoryEmpty(dirPath) {
-  try {
-    const files = await fs2.readdir(dirPath);
-    return files.length === 0;
-  } catch (error) {
-    return true;
-  }
-}
-async function ensureDirectory(dirPath) {
-  try {
-    await fs2.access(dirPath);
-  } catch (error) {
-    await fs2.mkdir(dirPath, { recursive: true });
-  }
-}
-async function writeJsonFile(filePath, data) {
-  await ensureDirectory(path2.dirname(filePath));
-  await fs2.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
-}
-async function readJsonFile(filePath, defaultValue) {
-  try {
-    const data = await fs2.readFile(filePath, "utf8");
-    return safeJsonParse(data, defaultValue);
-  } catch (error) {
-    return defaultValue;
-  }
-}
-var init_utils = __esm({
-  "src/server/utils.ts"() {
-    "use strict";
-  }
-});
-
-// src/server/templates.ts
-var templates_exports = {};
-__export(templates_exports, {
-  generateDocument: () => generateDocument,
-  generateErrorPage: () => generateErrorPage,
-  generateLoadingPage: () => generateLoadingPage
-});
-function generateDocument(content, options = {}) {
-  const {
-    title = "Baraqex App",
-    description = "",
-    lang = "en",
-    charset = "UTF-8",
-    viewport = "width=device-width, initial-scale=1.0",
-    scripts = [],
-    styles = [],
-    meta = {},
-    bodyClasses = "",
-    htmlAttrs = {},
-    bodyAttrs = {},
-    initialData = {},
-    componentName = ""
-  } = options;
-  const htmlAttributes = Object.entries(htmlAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
-  const bodyAttributes = Object.entries(bodyAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
-  const metaTags = [
-    `<meta charset="${charset}">`,
-    `<meta name="viewport" content="${viewport}">`,
-    description ? `<meta name="description" content="${escapeHtml3(description)}">` : ""
-  ];
-  Object.entries(meta).forEach(([name, content2]) => {
-    metaTags.push(`<meta name="${escapeHtml3(name)}" content="${escapeHtml3(content2)}">`);
-  });
-  const scriptTags = scripts.map((src) => {
-    if (src.startsWith("<script")) {
-      return src;
-    }
-    return `<script src="${escapeHtml3(src)}" ${src.endsWith(".js") ? 'type="module"' : ""} defer></script>`;
-  });
-  const styleTags = styles.map((href) => {
-    if (href.startsWith("<style")) {
-      return href;
-    }
-    return `<link rel="stylesheet" href="${escapeHtml3(href)}">`;
-  });
-  const initialDataScript = Object.keys(initialData).length > 0 ? `<script id="__APP_DATA__" type="application/json">${escapeHtml3(JSON.stringify(initialData))}</script>` : "";
-  return `<!DOCTYPE html>
-<html lang="${lang}" ${htmlAttributes}>
-<head>
-  ${metaTags.filter(Boolean).join("\n  ")}
-  <title>${escapeHtml3(title)}</title>
-  ${styleTags.join("\n  ")}
-</head>
-<body class="${bodyClasses}" ${bodyAttributes}>
-  <div id="app-root" data-ssr-root${componentName ? ` data-component="${escapeHtml3(componentName)}"` : ""}>${content}</div>
-  ${initialDataScript}
-  ${scriptTags.join("\n  ")}
-</body>
-</html>`;
-}
-function generateErrorPage(statusCode, message, error) {
-  const errorMessages = {
-    400: "Bad Request",
-    401: "Unauthorized",
-    403: "Forbidden",
-    404: "Not Found",
-    500: "Internal Server Error"
-  };
-  const title = `${statusCode} - ${errorMessages[statusCode] || "Error"}`;
-  const isDev = process.env.NODE_ENV !== "production";
-  const errorDetails = isDev && error ? `
-    <div class="error-details">
-      <pre>${escapeHtml3(error.stack || error.message)}</pre>
-    </div>
-  ` : "";
-  const content = `
-    <div class="error-container">
-      <h1>${statusCode}</h1>
-      <h2>${escapeHtml3(errorMessages[statusCode] || "Error")}</h2>
-      <p>${escapeHtml3(message)}</p>
-      ${errorDetails}
-      <a href="/" class="home-link">Back to Home</a>
-    </div>
-  `;
-  const styles = [`<style>
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      min-height: 100vh;
-      margin: 0;
-      background-color: #f7f7f7;
-      color: #333;
-    }
-    .error-container {
-      text-align: center;
-      padding: 2rem;
-      border-radius: 8px;
-      background-color: white;
-      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
-      max-width: 600px;
-      width: 100%;
-    }
-    h1 {
-      font-size: 6rem;
-      margin: 0;
-      color: #e74c3c;
-    }
-    h2 {
-      margin-top: 0;
-      margin-bottom: 1rem;
-      color: #333;
-    }
-    .error-details {
-      text-align: left;
-      margin: 2rem 0;
-      padding: 1rem;
-      background-color: #f8f8f8;
-      border-radius: 4px;
-      overflow: auto;
-    }
-    pre {
-      margin: 0;
-      font-family: monospace;
-      font-size: 0.85rem;
-      white-space: pre-wrap;
-    }
-    .home-link {
-      display: inline-block;
-      margin-top: 1.5rem;
-      padding: 0.75rem 1.5rem;
-      background-color: #3498db;
-      color: white;
-      text-decoration: none;
-      border-radius: 4px;
-      transition: background-color 0.2s;
-    }
-    .home-link:hover {
-      background-color: #2980b9;
-    }
-  </style>`];
-  return generateDocument(content, {
-    title,
-    description: `Error ${statusCode}: ${errorMessages[statusCode] || "Error"}`,
-    bodyClasses: "error-page",
-    styles
-  });
-}
-function generateLoadingPage(message = "Loading...") {
-  const content = `
-    <div class="loading-container">
-      <div class="spinner"></div>
-      <p>${escapeHtml3(message)}</p>
-    </div>
-  `;
-  const styles = [`<style>
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      min-height: 100vh;
-      margin: 0;
-      background-color: #f7f7f7;
-      color: #333;
-    }
-    .loading-container {
-      text-align: center;
-    }
-    .spinner {
-      width: 50px;
-      height: 50px;
-      border: 5px solid rgba(0, 0, 0, 0.1);
-      border-radius: 50%;
-      border-top-color: #3498db;
-      animation: spin 1s ease-in-out infinite;
-      margin: 0 auto 20px;
-    }
-    @keyframes spin {
-      to { transform: rotate(360deg); }
-    }
-  </style>`];
-  return generateDocument(content, {
-    title: "Loading",
-    bodyClasses: "loading-page",
-    styles
-  });
-}
-function escapeHtml3(text) {
-  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-var init_templates = __esm({
-  "src/server/templates.ts"() {
-    "use strict";
-  }
-});
-
-// src/server/wasm.ts
-import fs3 from "fs/promises";
-import path3 from "path";
-import { pathToFileURL as pathToFileURL2 } from "url";
-async function initNodeWasm() {
-  if (initialized)
-    return;
-  try {
-    globalThis.TextEncoder = globalThis.TextEncoder || TextEncoder;
-    globalThis.TextDecoder = globalThis.TextDecoder || TextDecoder;
-    initialized = true;
-  } catch (error) {
-    console.error("[WASM] Failed to initialize Node.js WASM environment:", error);
-    throw error;
-  }
-}
-async function loadGoRuntime(goWasmPath) {
-  if (typeof globalThis.Go === "function") {
-    return globalThis.Go;
-  }
-  const possiblePaths = [
-    goWasmPath,
-    "./wasm_exec.cjs",
-    "./wasm_exec.js",
-    "./public/wasm_exec.cjs",
-    "./public/wasm_exec.js",
-    "./src/wasm_exec.cjs",
-    "./src/wasm_exec.js",
-    path3.join(process.cwd(), "wasm_exec.cjs"),
-    path3.join(process.cwd(), "wasm_exec.js"),
-    path3.join(process.cwd(), "public", "wasm_exec.cjs"),
-    path3.join(process.cwd(), "public", "wasm_exec.js"),
-    path3.join(process.cwd(), "src", "wasm_exec.cjs"),
-    path3.join(process.cwd(), "src", "wasm_exec.js")
-  ].filter(Boolean);
-  for (const wasmExecPath of possiblePaths) {
-    try {
-      const resolvedPath = path3.resolve(wasmExecPath);
-      try {
-        const stats = await fs3.stat(resolvedPath);
-        if (!stats.isFile()) {
-          continue;
-        }
-      } catch (statError) {
-        continue;
-      }
-      const wasmExecUrl = pathToFileURL2(resolvedPath).href;
-      if (globalThis.Go) {
-        delete globalThis.Go;
-      }
-      await import(wasmExecUrl);
-      if (typeof globalThis.Go === "function") {
-        console.log(`[WASM] Loaded Go runtime from: ${resolvedPath}`);
-        return globalThis.Go;
-      } else {
-        console.warn(`[WASM] File found but Go class not exported: ${resolvedPath}`);
-      }
-    } catch (error) {
-      console.warn(`[WASM] Error loading from ${wasmExecPath}:`, error.message);
-      continue;
-    }
-  }
-  throw new Error(
-    `[WASM] Could not find wasm_exec.js. Please ensure you have the Go WASM runtime file available.
-You can get it from: https://github.com/golang/go/blob/master/misc/wasm/wasm_exec.js
-Searched paths: ${possiblePaths.join(", ")}`
-  );
-}
-async function loadGoWasmFromFile(wasmFilePath, options = {}) {
-  try {
-    await initNodeWasm();
-    if (options.debug) {
-      console.log("[WASM] Loading WASM from file:", wasmFilePath);
-    }
-    const GoRuntime = await loadGoRuntime(options.goWasmPath);
-    const go = new GoRuntime();
-    const wasmBuffer = await fs3.readFile(wasmFilePath);
-    const wasmModule = await WebAssembly.compile(new Uint8Array(wasmBuffer));
-    const baseImports = go.importObject;
-    const finalImportObject = {
-      ...baseImports,
-      ...options.importObject
-    };
-    if (options.debug) {
-      console.log("[WASM] Available import modules:", Object.keys(finalImportObject));
-      for (const [moduleName, moduleExports] of Object.entries(finalImportObject)) {
-        if (typeof moduleExports === "object" && moduleExports !== null) {
-          const exportNames = Object.keys(moduleExports);
-          console.log(`[WASM] ${moduleName} import functions:`, exportNames);
-        }
-      }
-    }
-    const instance = await WebAssembly.instantiate(wasmModule, finalImportObject);
-    if (options.debug) {
-      console.log("[WASM] WASM instance created, starting Go runtime...");
-    }
-    const runPromise = go.run(instance);
-    if (options.debug) {
-      console.log("[WASM] Go runtime started, waiting for initialization...");
-    }
-    await new Promise((resolve) => setTimeout(resolve, 2e3));
-    if (options.debug) {
-      console.log("[WASM] Scanning global object for Go functions...");
-    }
-    const functions = {};
-    const globalObj = globalThis;
-    const allKeys = Object.getOwnPropertyNames(globalObj);
-    const goKeys = allKeys.filter((key) => key.startsWith("go"));
-    if (options.debug) {
-      console.log('[WASM] All keys starting with "go":', goKeys);
-    }
-    for (const key of goKeys) {
-      if (typeof globalObj[key] === "function") {
-        functions[key] = globalObj[key];
-        if (options.debug) {
-          console.log(`[WASM] Found function: ${key}`);
-        }
-      }
-    }
-    const wasmInstance = {
-      instance,
-      module: wasmModule,
-      exports: instance.exports,
-      functions
-    };
-    if (options.onLoad) {
-      options.onLoad(wasmInstance);
-    }
-    if (options.debug) {
-      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
-      console.log("[WASM] Final function list:", Object.keys(functions));
-    }
-    runPromise.catch((error) => {
-      if (options.debug) {
-        console.log("[WASM] Go program finished with error:", error);
-      }
-    });
-    return wasmInstance;
-  } catch (error) {
-    console.error("[WASM] Failed to load Go WASM module:", error);
-    throw error;
-  }
-}
-var initialized;
-var init_wasm = __esm({
-  "src/server/wasm.ts"() {
-    "use strict";
-    initialized = false;
-  }
-});
-
-// src/server/index.ts
-var server_exports = {};
-__export(server_exports, {
-  ApiRouter: () => ApiRouter,
-  AuthService: () => AuthService,
-  Database: () => Database,
-  Server: () => Server,
-  createDevServer: () => createDevServer,
-  createProductionServer: () => createProductionServer,
-  createServer: () => createServer,
-  default: () => server_default,
-  ensureDirectory: () => ensureDirectory,
-  errorHandler: () => errorHandler,
-  generateDocument: () => generateDocument,
-  generateErrorPage: () => generateErrorPage,
-  generateLoadingPage: () => generateLoadingPage,
-  generateToken: () => generateToken,
-  getEnvironmentInfo: () => getEnvironmentInfo,
-  getPagination: () => getPagination,
-  getRequestIp: () => getRequestIp,
-  hashString: () => hashString,
-  initNodeWasm: () => initNodeWasm,
-  isDirectoryEmpty: () => isDirectoryEmpty,
-  loadGoWasmFromFile: () => loadGoWasmFromFile,
-  notFoundHandler: () => notFoundHandler,
-  parseCookies: () => parseCookies,
-  rateLimit: () => rateLimit,
-  readJsonFile: () => readJsonFile,
-  renderComponent: () => renderComponent,
-  renderToString: () => renderToString,
-  requestLogger: () => requestLogger,
-  safeJsonParse: () => safeJsonParse,
-  sendError: () => sendError,
-  sendSuccess: () => sendSuccess,
-  validateFields: () => validateFields,
-  validateFileUpload: () => validateFileUpload,
-  writeJsonFile: () => writeJsonFile
-});
-import path4 from "path";
-import fs4 from "fs";
-import { pathToFileURL as pathToFileURL3 } from "url";
-function getComponentName(filePath, pagesDir) {
-  try {
-    const relativePath = path4.relative(pagesDir, filePath);
-    const withoutExt = relativePath.replace(/\.[^/.]+$/, "");
-    const cleanPath = withoutExt.replace(/\/index$/, "");
-    return `/pages/${cleanPath}`;
-  } catch (e) {
-    return "";
-  }
-}
-function createServer(config = {}) {
-  return new Server(config);
-}
-function createDevServer(options = {}) {
-  return new Server({
-    port: options.port || 3e3,
-    enableCors: options.enableCors !== false,
-    apiDir: "./src/api",
-    pagesDir: "./src/pages",
-    staticDir: "./public"
-  });
-}
-function createProductionServer(config) {
-  const server = new Server({
-    ...config,
-    // Fix the PORT parsing
-    port: config.port || (process.env.PORT ? parseInt(process.env.PORT) : 8080)
-  });
-  server.addShutdownHandler();
-  return server;
-}
-function getRequestIp(req) {
-  return req.ip || req.headers["x-forwarded-for"]?.split(",")[0].trim() || req.socket.remoteAddress || "";
-}
-function parseCookies(req) {
-  const cookies = {};
-  const cookieHeader = req.headers.cookie;
-  if (cookieHeader) {
-    cookieHeader.split(";").forEach((cookie) => {
-      const [name, value] = cookie.split("=").map((c) => c.trim());
-      cookies[name] = value;
-    });
-  }
-  return cookies;
-}
-var Server, renderComponent, server_default;
-var init_server = __esm({
-  "src/server/index.ts"() {
-    "use strict";
-    init_server_renderer();
-    init_database();
-    init_auth();
-    init_api_router();
-    init_middleware();
-    init_utils();
-    init_templates();
-    init_wasm();
-    init_wasm();
-    init_utils();
-    init_templates();
-    init_database();
-    init_auth();
-    init_api_router();
-    init_middleware();
-    Server = class {
-      constructor(config = {}) {
-        __publicField(this, "app");
-        __publicField(this, "server", null);
-        __publicField(this, "config");
-        __publicField(this, "db", null);
-        __publicField(this, "auth", null);
-        __publicField(this, "initialized", false);
-        this.config = {
-          port: 3e3,
-          apiDir: "./api",
-          pagesDir: "./pages",
-          staticDir: "./public",
-          enableCors: true,
-          ...config
-        };
-      }
-      async initializeApp() {
-        if (this.initialized)
-          return;
-        try {
-          const express = await import("express");
-          this.app = express.default();
-          this.app.use(express.default.json());
-          this.app.use(express.default.urlencoded({ extended: true }));
-          if (this.config.enableCors) {
-            try {
-              const cors = await import("cors");
-              this.app.use(cors.default(this.config.corsOptions));
-            } catch (error) {
-              console.warn("CORS not available - install with: npm install cors @types/cors");
-            }
-          }
-          if (this.config.db) {
-            this.db = new Database(this.config.db);
-          }
-          if (this.config.auth) {
-            this.auth = new AuthService({
-              secret: this.config.auth.secret,
-              expiresIn: this.config.auth.expiresIn
-            });
-            this.app.use(this.auth.initialize());
-          }
-          const staticPath = path4.resolve(process.cwd(), this.config.staticDir);
-          if (fs4.existsSync(staticPath)) {
-            this.app.use(express.default.static(staticPath));
-          }
-          this.setupApiRoutes();
-          this.setupPageRoutes();
-          this.app.use(notFoundHandler);
-          this.app.use(errorHandler);
-          this.initialized = true;
-        } catch (error) {
-          if (error.code === "MODULE_NOT_FOUND" && error.message.includes("express")) {
-            throw new Error("Express not installed. Run: npm install express @types/express");
-          }
-          throw error;
-        }
-      }
-      async setupApiRoutes() {
-        const apiRouter = new ApiRouter(this.config.apiDir, this.auth);
-        await apiRouter.initialize();
-        if (!apiRouter.isInitialized() || !apiRouter.router) {
-          console.warn("\u26A0\uFE0F API router not initialized properly - skipping API routes");
-          return;
-        }
-        console.log("\u2705 Setting up API routes...");
-        this.app.use("/api", requestLogger, apiRouter.router);
-        this.app.get("/api-docs", (req, res) => {
-          const apiDocs = this.generateApiDocs();
-          res.json(apiDocs);
-        });
-      }
-      generateApiDocs() {
-        const apiDir = path4.resolve(process.cwd(), this.config.apiDir);
-        const docs = { endpoints: [] };
-        if (fs4.existsSync(apiDir)) {
-          this.scanApiDirectory(apiDir, "", docs.endpoints);
-        }
-        return docs;
-      }
-      scanApiDirectory(dirPath, routePrefix, endpoints) {
-        const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
-        for (const entry of entries) {
-          const fullPath = path4.join(dirPath, entry.name);
-          if (entry.isDirectory()) {
-            this.scanApiDirectory(fullPath, `${routePrefix}/${entry.name}`, endpoints);
-          } else if (entry.name.endsWith(".js") || entry.name.endsWith(".ts")) {
-            const routePath = this.getRoutePath(entry.name, routePrefix);
-            endpoints.push({
-              path: routePath,
-              file: path4.relative(process.cwd(), fullPath),
-              methods: this.detectApiMethods(fullPath)
-            });
-          }
-        }
-      }
-      getRoutePath(filename, routePrefix) {
-        const baseName = path4.basename(filename, path4.extname(filename));
-        if (baseName === "index") {
-          return routePrefix || "/";
-        }
-        const paramMatch = baseName.match(/^\[(.+)\]$/);
-        if (paramMatch) {
-          return `${routePrefix}/:${paramMatch[1]}`;
-        }
-        return `${routePrefix}/${baseName}`;
-      }
-      detectApiMethods(filePath) {
-        try {
-          const content = fs4.readFileSync(filePath, "utf8");
-          const methods = ["get", "post", "put", "delete", "patch", "options"];
-          return methods.filter(
-            (method) => new RegExp(`export (async )?function ${method}\\s*\\(`).test(content) || new RegExp(`export const ${method}\\s*=`).test(content)
-          );
-        } catch (error) {
-          return [];
-        }
-      }
-      setupPageRoutes() {
-        const pagesPath = path4.resolve(process.cwd(), this.config.pagesDir);
-        if (!fs4.existsSync(pagesPath)) {
-          return;
-        }
-        this.app.get("*", async (req, res) => {
-          try {
-            const { html, statusCode } = await this.renderPage(req.path);
-            res.status(statusCode || 200).send(html);
-          } catch (error) {
-            console.error("Error rendering page:", error);
-            const errorHtml = generateErrorPage(500, "Server Error");
-            res.status(500).send(errorHtml);
-          }
-        });
-      }
-      async renderPage(routePath) {
-        try {
-          const pagesDir = this.config.pagesDir ? path4.resolve(process.cwd(), this.config.pagesDir) : "";
-          if (!pagesDir || !fs4.existsSync(pagesDir)) {
-            return {
-              html: generateErrorPage(404, "Pages directory not found"),
-              statusCode: 404
-            };
-          }
-          let normalizedPath = routePath;
-          if (!normalizedPath.startsWith("/")) {
-            normalizedPath = "/" + normalizedPath;
-          }
-          if (normalizedPath === "/") {
-            normalizedPath = "/index";
-          }
-          let pagePath = "";
-          const possiblePaths = [
-            path4.join(pagesDir, `${normalizedPath}.js`),
-            path4.join(pagesDir, `${normalizedPath}.ts`),
-            path4.join(pagesDir, `${normalizedPath}.jsx`),
-            path4.join(pagesDir, `${normalizedPath}.tsx`),
-            path4.join(pagesDir, `${normalizedPath}/index.js`),
-            path4.join(pagesDir, `${normalizedPath}/index.ts`),
-            path4.join(pagesDir, `${normalizedPath}/index.jsx`),
-            path4.join(pagesDir, `${normalizedPath}/index.tsx`)
-          ];
-          for (const p of possiblePaths) {
-            if (fs4.existsSync(p)) {
-              pagePath = p;
-              break;
-            }
-          }
-          if (!pagePath) {
-            return {
-              html: generateErrorPage(404, `Page not found: ${normalizedPath}`),
-              statusCode: 404
-            };
-          }
-          try {
-            const absolutePath = path4.isAbsolute(pagePath) ? pagePath : path4.resolve(pagePath);
-            const fileUrl = pathToFileURL3(absolutePath).href;
-            const urlWithTimestamp = `${fileUrl}?t=${Date.now()}`;
-            const pageModule = await import(urlWithTimestamp);
-            if (!pageModule || !pageModule.default) {
-              throw new Error(`No default export found in ${pagePath}`);
-            }
-            const PageComponent = pageModule.default;
-            const initialProps = {
-              // Provide any initial props here
-              path: normalizedPath,
-              query: {},
-              // Could be parsed from URL
-              api: { serverTime: (/* @__PURE__ */ new Date()).toISOString() }
-            };
-            const renderResult = await renderComponent(PageComponent, initialProps);
-            if (!renderResult.success) {
-              return {
-                html: generateErrorPage(500, "Failed to render page", renderResult.error instanceof Error ? renderResult.error : new Error("Unknown error")),
-                statusCode: 500
-              };
-            }
-            const htmlContent = renderResult.html;
-            let pageTitle = "My App";
-            try {
-              if (typeof PageComponent.getTitle === "function") {
-                pageTitle = PageComponent.getTitle(initialProps);
-              } else if (PageComponent.title) {
-                pageTitle = PageComponent.title;
-              }
-            } catch (e) {
-            }
-            const componentName = getComponentName(pagePath, pagesDir);
-            const fullHtml = generateDocument(htmlContent, {
-              title: pageTitle,
-              // Get description from component if available
-              description: typeof PageComponent.getDescription === "function" ? PageComponent.getDescription(initialProps) : PageComponent.description || "",
-              // Add scripts for client-side hydration
-              scripts: ["/client.js"],
-              // Add any custom meta tags
-              meta: typeof PageComponent.getMeta === "function" ? PageComponent.getMeta(initialProps) : {},
-              // Add custom styles
-              styles: ["/styles.css"],
-              // Add initial data for client-side hydration
-              initialData: initialProps,
-              // Add component information for hydration
-              componentName
-            });
-            return { html: fullHtml, statusCode: 200 };
-          } catch (error) {
-            console.error("Error rendering page:", error);
-            return {
-              html: generateErrorPage(500, "Error rendering page", error instanceof Error ? error : new Error("Unknown error")),
-              statusCode: 500
-            };
-          }
-        } catch (error) {
-          console.error("Error finding page:", error);
-          return {
-            html: generateErrorPage(500, "Server error", error instanceof Error ? error : new Error("Unknown error")),
-            statusCode: 500
-          };
-        }
-      }
-      getExpressApp() {
-        return this.app;
-      }
-      getDatabase() {
-        return this.db;
-      }
-      getAuth() {
-        return this.auth;
-      }
-      async start() {
-        await this.initializeApp();
-        return new Promise((resolve) => {
-          this.server = this.app.listen(this.config.port, () => {
-            console.log(`Server running at http://localhost:${this.config.port}`);
-            resolve();
-          });
-        });
-      }
-      stop() {
-        return new Promise((resolve, reject) => {
-          if (!this.server) {
-            return resolve();
-          }
-          this.server.close((err) => {
-            if (err)
-              return reject(err);
-            this.server = null;
-            resolve();
-          });
-        });
-      }
-      restart() {
-        return this.stop().then(() => this.start());
-      }
-      enableSSR(options = {}) {
-        if (!fs4.existsSync(path4.resolve(process.cwd(), this.config.pagesDir))) {
-          fs4.mkdirSync(path4.resolve(process.cwd(), this.config.pagesDir), { recursive: true });
-        }
-        if (options.hydratable) {
-          const staticDir = path4.resolve(process.cwd(), this.config.staticDir);
-          if (!fs4.existsSync(staticDir)) {
-            fs4.mkdirSync(staticDir, { recursive: true });
-          }
-          const clientJsPath = path4.join(staticDir, "client.js");
-          if (!fs4.existsSync(clientJsPath)) {
-            const clientJsContent = `
-          // Auto-generated hydration script
-          import { hydrate } from 'baraqex';
-
-          // Find SSR content and hydrate it
-          document.addEventListener('DOMContentLoaded', () => {
-            const ssrRoots = document.querySelectorAll('[data-ssr-root]');
-            ssrRoots.forEach(root => {
-              const componentPath = root.getAttribute('data-component');
-              if (componentPath) {
-                import(componentPath).then(module => {
-                  hydrate(module.default, root);
-                });
-              }
-            });
-          });
-        `;
-            fs4.writeFileSync(clientJsPath, clientJsContent);
-          }
-        }
-      }
-      registerPlugin(plugin) {
-        plugin(this);
-      }
-      addShutdownHandler() {
-        const gracefulShutdown = async () => {
-          console.log("Received shutdown signal, closing server...");
-          try {
-            await this.stop();
-            if (this.db) {
-              await this.db.disconnect();
-            }
-            console.log("Server shut down gracefully");
-            process.exit(0);
-          } catch (error) {
-            console.error("Error during shutdown:", error);
-            process.exit(1);
-          }
-        };
-        process.on("SIGTERM", gracefulShutdown);
-        process.on("SIGINT", gracefulShutdown);
-      }
-    };
-    renderComponent = (Component2, props = {}) => {
-      try {
-        const html = renderToString(Component2(props));
-        return {
-          html: typeof html === "string" ? html : String(html),
-          success: true
-        };
-      } catch (error) {
-        console.error("Error rendering component:", error);
-        return {
-          html: `<div class="error">Error rendering component</div>`,
-          success: false,
-          error
-        };
-      }
-    };
-    server_default = {
-      Server,
-      createServer,
-      createDevServer,
-      createProductionServer,
-      rateLimit,
-      requestLogger,
-      errorHandler,
-      notFoundHandler,
-      loadGoWasmFromFile,
-      // Template utilities
-      templates: templates_exports,
-      // Server utilities
-      utils: utils_exports,
-      // Additional exports
-      renderComponent,
-      renderToString,
-      getRequestIp,
-      parseCookies,
-      Database,
-      AuthService,
-      ApiRouter
-    };
-  }
-});
-
-// src/server-renderer.ts
-var server_renderer_exports = {};
-__export(server_renderer_exports, {
-  renderToString: () => renderToString2
-});
-function renderToString2(component) {
-  try {
-    if (typeof component === "function") {
-      const result = component();
-      if (typeof result === "string") {
-        return result;
-      }
-      if (result && typeof result === "object") {
-        return JSON.stringify(result);
-      }
-      return String(result || "");
-    }
-    if (typeof component === "string") {
-      return component;
-    }
-    return String(component || "");
-  } catch (error) {
-    console.error("Error in renderToString:", error);
-    return "<div>Error rendering component</div>";
-  }
-}
-var init_server_renderer2 = __esm({
-  "src/server-renderer.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/batch.ts
-var isBatching = false;
-var syncQueue = [];
-var asyncQueue = [];
-async function batchUpdates(fn) {
-  if (isBatching) {
-    if (fn.constructor.name === "AsyncFunction") {
-      asyncQueue.push(fn);
-    } else {
-      syncQueue.push(fn);
-    }
-    return;
-  }
-  isBatching = true;
-  try {
-    const result = fn();
-    if (result instanceof Promise) {
-      await result;
-    }
-    while (syncQueue.length > 0) {
-      const nextFn = syncQueue.shift();
-      nextFn();
-    }
-    while (asyncQueue.length > 0) {
-      const nextFn = asyncQueue.shift();
-      await nextFn();
-    }
-  } finally {
-    isBatching = false;
-  }
-}
-function getIsBatching() {
-  return isBatching;
-}
-
-// src/core/index.ts
-init_context();
-init_hooks();
-
-// src/core/jsx-runtime.ts
-init_hooks();
-var isBrowser = typeof document !== "undefined";
-function jsx(type, props, key) {
-  const processedProps = { ...props };
-  if (key !== void 0) {
-    processedProps.key = key;
-  }
-  if (arguments.length > 3) {
-    processedProps.children = Array.prototype.slice.call(arguments, 3);
-  }
-  return { type, props: processedProps, key: processedProps.key };
-}
-var jsxs = jsx;
-function jsxDEV(type, props, key, _isStaticChildren, _source, _self) {
-  return jsx(type, props, key);
-}
-var Fragment = ({ children }) => children;
-function assertBrowser(method) {
-  if (!isBrowser) {
-    throw new Error(
-      `[baraqex] ${method}() can only be called in a browser environment. Use renderToString() for server-side rendering.`
-    );
-  }
-}
-function createTextNode(text) {
-  return document.createTextNode(text);
-}
-function applyProps(element, props) {
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children")
-      continue;
-    if (key === "className") {
-      element.setAttribute("class", String(value));
-    } else if (key === "htmlFor") {
-      element.setAttribute("for", String(value));
-    } else if (key.startsWith("on") && typeof value === "function") {
-      const eventName = key.slice(2).toLowerCase();
-      element.addEventListener(eventName, value);
-    } else if (key === "style" && typeof value === "object") {
-      Object.assign(element.style, value);
-    } else if (key === "dangerouslySetInnerHTML" && value && value.__html) {
-      element.innerHTML = value.__html;
-    } else if (key === "ref") {
-      if (typeof value === "function") {
-        value(element);
-      } else if (value && typeof value === "object" && "current" in value) {
-        value.current = element;
-      }
-    } else if (value !== false && value != null) {
-      if (value === true) {
-        element.setAttribute(key, "");
-      } else {
-        element.setAttribute(key, String(value));
-      }
-    }
-  }
-}
-async function createElement(vnode) {
-  assertBrowser("createElement");
-  if (vnode == null || typeof vnode === "boolean") {
-    return createTextNode("");
-  }
-  if (typeof vnode === "number" || typeof vnode === "string") {
-    return createTextNode(String(vnode));
-  }
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      const node = await createElement(child);
-      fragment.appendChild(node);
-    }
-    return fragment;
-  }
-  if (typeof vnode === "object" && "type" in vnode && vnode.props !== void 0) {
-    const { type, props } = vnode;
-    if (typeof type === "function") {
-      if (type === Fragment) {
-        const children2 = props?.children;
-        if (children2 == null)
-          return createTextNode("");
-        return createElement(children2);
-      }
-      const root = getCurrentRoot() ?? void 0;
-      const renderId = prepareRender(root);
-      try {
-        const result = type(props || {});
-        return await createElement(result);
-      } finally {
-        finishRender();
-      }
-    }
-    const element = document.createElement(type);
-    applyProps(element, props || {});
-    const children = props?.children;
-    if (children != null) {
-      const childArray = Array.isArray(children) ? children : [children];
-      for (const child of childArray) {
-        const childNode = await createElement(child);
-        element.appendChild(childNode);
-      }
-    }
-    return element;
-  }
-  return createTextNode(String(vnode));
-}
-function createElementSync(vnode) {
-  assertBrowser("createElementSync");
-  if (vnode == null || typeof vnode === "boolean") {
-    return createTextNode("");
-  }
-  if (typeof vnode === "number" || typeof vnode === "string") {
-    return createTextNode(String(vnode));
-  }
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      fragment.appendChild(createElementSync(child));
-    }
-    return fragment;
-  }
-  if (typeof vnode === "object" && "type" in vnode) {
-    const { type, props } = vnode;
-    if (typeof type === "function") {
-      if (type === Fragment) {
-        return createElementSync(props?.children);
-      }
-      const result = type(props || {});
-      return createElementSync(result);
-    }
-    const element = document.createElement(type);
-    applyProps(element, props || {});
-    const children = props?.children;
-    if (children != null) {
-      const childArray = Array.isArray(children) ? children : [children];
-      for (const child of childArray) {
-        element.appendChild(createElementSync(child));
-      }
-    }
-    return element;
-  }
-  return createTextNode(String(vnode));
-}
-
-// src/core/renderer.ts
-init_hooks();
-var isBrowser2 = typeof document !== "undefined";
-var rootMap = /* @__PURE__ */ new WeakMap();
-async function render(element, container) {
-  if (!isBrowser2) {
-    throw new Error(
-      "[baraqex] render() can only be called in a browser. Use renderToString() for server-side rendering."
-    );
-  }
-  if (!container) {
-    throw new Error("[baraqex] render() requires a container element");
-  }
-  let root = rootMap.get(container);
-  if (!root) {
-    root = createRootState();
-    rootMap.set(container, root);
-  }
-  await batchUpdates(async () => {
-    prepareRender(root);
-    try {
-      setRenderCallback(render, element, container);
-      const domNode = await createElement(element);
-      container.textContent = "";
-      container.appendChild(domNode);
-    } finally {
-      finishRender();
-    }
-  });
-}
-async function hydrate(element, container) {
-  await render(element, container);
-}
-function createRoot(container) {
-  const root = createRootState();
-  rootMap.set(container, root);
-  return {
-    render: (element) => render(element, container),
-    unmount: () => {
-      cleanupRoot(root);
-      rootMap.delete(container);
-      container.textContent = "";
-    }
-  };
-}
-function hasRoot(container) {
-  return rootMap.has(container);
-}
-
-// src/core/index.ts
-init_server_renderer();
 
 // src/core/vdom.ts
 var isBrowser3 = typeof document !== "undefined";
@@ -2417,8 +982,6 @@ function useEvent(event, handler, options = {}) {
 }
 
 // src/core/router.ts
-init_context();
-init_hooks();
 var RouterContext = createContext({
   pathname: "/",
   search: "",
@@ -2660,7 +1223,6 @@ function useMatch(pattern) {
 }
 
 // src/core/forms.ts
-init_hooks();
 function validateFieldValue(value, rules, allValues) {
   if (rules.required) {
     const isEmpty2 = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
@@ -2891,8 +1453,6 @@ var patterns = {
 };
 
 // src/core/store.ts
-init_context();
-init_hooks();
 function createStore(reducer, initialState, middlewares = []) {
   let state = initialState;
   let listeners = /* @__PURE__ */ new Set();
@@ -3024,740 +1584,1563 @@ function createSlice(config) {
         return reducers[key](state, action);
       }
     }
-    return state;
+    return state;
+  };
+  return {
+    name,
+    reducer,
+    actions
+  };
+}
+
+// src/core/lifecycle-events.ts
+var LifecycleEvents = /* @__PURE__ */ ((LifecycleEvents2) => {
+  LifecycleEvents2["APP_INIT"] = "app:init";
+  LifecycleEvents2["APP_MOUNTED"] = "app:mounted";
+  LifecycleEvents2["APP_UPDATED"] = "app:updated";
+  LifecycleEvents2["APP_ERROR"] = "app:error";
+  LifecycleEvents2["APP_DESTROYED"] = "app:destroyed";
+  LifecycleEvents2["COMPONENT_CREATED"] = "component:created";
+  LifecycleEvents2["COMPONENT_MOUNTED"] = "component:mounted";
+  LifecycleEvents2["COMPONENT_UPDATED"] = "component:updated";
+  LifecycleEvents2["COMPONENT_ERROR"] = "component:error";
+  LifecycleEvents2["COMPONENT_UNMOUNTED"] = "component:unmounted";
+  LifecycleEvents2["ROUTER_BEFORE_CHANGE"] = "router:before-change";
+  LifecycleEvents2["ROUTER_AFTER_CHANGE"] = "router:after-change";
+  LifecycleEvents2["ROUTER_ERROR"] = "router:error";
+  LifecycleEvents2["STORE_INITIALIZED"] = "store:initialized";
+  LifecycleEvents2["STORE_BEFORE_ACTION"] = "store:before-action";
+  LifecycleEvents2["STORE_AFTER_ACTION"] = "store:after-action";
+  LifecycleEvents2["STORE_ERROR"] = "store:error";
+  return LifecycleEvents2;
+})(LifecycleEvents || {});
+function emitAppInit(data) {
+  eventBus.emit("app:init" /* APP_INIT */, data);
+}
+function emitAppMounted(rootElement) {
+  eventBus.emit("app:mounted" /* APP_MOUNTED */, rootElement);
+}
+function emitAppUpdated() {
+  eventBus.emit("app:updated" /* APP_UPDATED */);
+}
+function emitAppError(error) {
+  eventBus.emit("app:error" /* APP_ERROR */, error);
+}
+function emitAppDestroyed() {
+  eventBus.emit("app:destroyed" /* APP_DESTROYED */);
+}
+function emitComponentCreated(info) {
+  eventBus.emit("component:created" /* COMPONENT_CREATED */, info);
+}
+function emitComponentMounted(info, element) {
+  eventBus.emit("component:mounted" /* COMPONENT_MOUNTED */, info, element);
+}
+function emitComponentUpdated(info, prevProps, newProps) {
+  eventBus.emit("component:updated" /* COMPONENT_UPDATED */, info, prevProps, newProps);
+}
+function emitComponentError(info, error) {
+  eventBus.emit("component:error" /* COMPONENT_ERROR */, info, error);
+}
+function emitComponentUnmounted(info) {
+  eventBus.emit("component:unmounted" /* COMPONENT_UNMOUNTED */, info);
+}
+function emitRouterBeforeChange(info) {
+  return new Promise((resolve) => {
+    let prevented = false;
+    const prevent = () => {
+      prevented = true;
+    };
+    eventBus.emit("router:before-change" /* ROUTER_BEFORE_CHANGE */, info, prevent);
+    resolve(!prevented);
+  });
+}
+function emitRouterAfterChange(info) {
+  eventBus.emit("router:after-change" /* ROUTER_AFTER_CHANGE */, info);
+}
+function emitRouterError(error, info) {
+  eventBus.emit("router:error" /* ROUTER_ERROR */, error, info);
+}
+function emitStoreInitialized(state) {
+  eventBus.emit("store:initialized" /* STORE_INITIALIZED */, state);
+}
+function emitStoreBeforeAction(actionType, payload, state) {
+  eventBus.emit("store:before-action" /* STORE_BEFORE_ACTION */, actionType, payload, state);
+}
+function emitStoreAfterAction(info) {
+  eventBus.emit("store:after-action" /* STORE_AFTER_ACTION */, info);
+}
+function emitStoreError(error, actionType, payload) {
+  eventBus.emit("store:error" /* STORE_ERROR */, error, actionType, payload);
+}
+function onAppInit(handler) {
+  return eventBus.on("app:init" /* APP_INIT */, handler);
+}
+function onAppMounted(handler) {
+  return eventBus.on("app:mounted" /* APP_MOUNTED */, handler);
+}
+function onAppUpdated(handler) {
+  return eventBus.on("app:updated" /* APP_UPDATED */, handler);
+}
+function onAppError(handler) {
+  return eventBus.on("app:error" /* APP_ERROR */, handler);
+}
+function onAppDestroyed(handler) {
+  return eventBus.on("app:destroyed" /* APP_DESTROYED */, handler);
+}
+function onComponentCreated(handler) {
+  return eventBus.on("component:created" /* COMPONENT_CREATED */, handler);
+}
+function onComponentMounted(handler) {
+  return eventBus.on("component:mounted" /* COMPONENT_MOUNTED */, handler);
+}
+function onComponentUpdated(handler) {
+  return eventBus.on("component:updated" /* COMPONENT_UPDATED */, handler);
+}
+function onComponentError(handler) {
+  return eventBus.on("component:error" /* COMPONENT_ERROR */, handler);
+}
+function onComponentUnmounted(handler) {
+  return eventBus.on("component:unmounted" /* COMPONENT_UNMOUNTED */, handler);
+}
+function onRouterBeforeChange(handler) {
+  return eventBus.on("router:before-change" /* ROUTER_BEFORE_CHANGE */, handler);
+}
+function onRouterAfterChange(handler) {
+  return eventBus.on("router:after-change" /* ROUTER_AFTER_CHANGE */, handler);
+}
+function onRouterError(handler) {
+  return eventBus.on("router:error" /* ROUTER_ERROR */, handler);
+}
+function onStoreInitialized(handler) {
+  return eventBus.on("store:initialized" /* STORE_INITIALIZED */, handler);
+}
+function onStoreBeforeAction(handler) {
+  return eventBus.on("store:before-action" /* STORE_BEFORE_ACTION */, handler);
+}
+function onStoreAfterAction(handler) {
+  return eventBus.on("store:after-action" /* STORE_AFTER_ACTION */, handler);
+}
+function onStoreError(handler) {
+  return eventBus.on("store:error" /* STORE_ERROR */, handler);
+}
+
+// src/core/utils.ts
+function debounce(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  const { leading = false, trailing = true } = options;
+  const invokeFunc = (time) => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const shouldInvoke = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || timeSinceLastInvoke >= wait;
+  };
+  const trailingEdge = (time) => {
+    timeoutId = null;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = null;
+    lastThis = null;
+    return result;
+  };
+  const remainingWait = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return timeWaiting;
+  };
+  const timerExpired = () => {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timeoutId = setTimeout(timerExpired, remainingWait(time));
+    return result;
+  };
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timeoutId === null) {
+        lastInvokeTime = time;
+        timeoutId = setTimeout(timerExpired, wait);
+        if (leading) {
+          return invokeFunc(time);
+        }
+      }
+    }
+    if (timeoutId === null) {
+      timeoutId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = void 0;
+    timeoutId = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      return trailingEdge(Date.now());
+    }
+    return result;
+  };
+  return debounced;
+}
+function throttle(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime = 0;
+  const { leading = true, trailing = true } = options;
+  const invokeFunc = () => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = Date.now();
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastCallTime);
+    lastArgs = args;
+    lastThis = this;
+    if (remaining <= 0 || remaining > wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (leading || lastCallTime !== 0) {
+        return invokeFunc();
+      }
+    }
+    if (!timeoutId && trailing) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        if (trailing && lastArgs) {
+          invokeFunc();
+        }
+      }, remaining);
+    }
+    return result;
   };
-  return {
-    name,
-    reducer,
-    actions
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = null;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = 0;
   };
+  return throttled;
 }
-
-// src/core/lifecycle-events.ts
-var LifecycleEvents = /* @__PURE__ */ ((LifecycleEvents2) => {
-  LifecycleEvents2["APP_INIT"] = "app:init";
-  LifecycleEvents2["APP_MOUNTED"] = "app:mounted";
-  LifecycleEvents2["APP_UPDATED"] = "app:updated";
-  LifecycleEvents2["APP_ERROR"] = "app:error";
-  LifecycleEvents2["APP_DESTROYED"] = "app:destroyed";
-  LifecycleEvents2["COMPONENT_CREATED"] = "component:created";
-  LifecycleEvents2["COMPONENT_MOUNTED"] = "component:mounted";
-  LifecycleEvents2["COMPONENT_UPDATED"] = "component:updated";
-  LifecycleEvents2["COMPONENT_ERROR"] = "component:error";
-  LifecycleEvents2["COMPONENT_UNMOUNTED"] = "component:unmounted";
-  LifecycleEvents2["ROUTER_BEFORE_CHANGE"] = "router:before-change";
-  LifecycleEvents2["ROUTER_AFTER_CHANGE"] = "router:after-change";
-  LifecycleEvents2["ROUTER_ERROR"] = "router:error";
-  LifecycleEvents2["STORE_INITIALIZED"] = "store:initialized";
-  LifecycleEvents2["STORE_BEFORE_ACTION"] = "store:before-action";
-  LifecycleEvents2["STORE_AFTER_ACTION"] = "store:after-action";
-  LifecycleEvents2["STORE_ERROR"] = "store:error";
-  return LifecycleEvents2;
-})(LifecycleEvents || {});
-function emitAppInit(data) {
-  eventBus.emit("app:init" /* APP_INIT */, data);
-}
-function emitAppMounted(rootElement) {
-  eventBus.emit("app:mounted" /* APP_MOUNTED */, rootElement);
-}
-function emitAppUpdated() {
-  eventBus.emit("app:updated" /* APP_UPDATED */);
-}
-function emitAppError(error) {
-  eventBus.emit("app:error" /* APP_ERROR */, error);
-}
-function emitAppDestroyed() {
-  eventBus.emit("app:destroyed" /* APP_DESTROYED */);
-}
-function emitComponentCreated(info) {
-  eventBus.emit("component:created" /* COMPONENT_CREATED */, info);
-}
-function emitComponentMounted(info, element) {
-  eventBus.emit("component:mounted" /* COMPONENT_MOUNTED */, info, element);
-}
-function emitComponentUpdated(info, prevProps, newProps) {
-  eventBus.emit("component:updated" /* COMPONENT_UPDATED */, info, prevProps, newProps);
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+  }
+  return clonedObj;
 }
-function emitComponentError(info, error) {
-  eventBus.emit("component:error" /* COMPONENT_ERROR */, info, error);
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        target[key] = deepMerge(targetValue, sourceValue);
+      } else {
+        target[key] = deepClone(sourceValue);
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
 }
-function emitComponentUnmounted(info) {
-  eventBus.emit("component:unmounted" /* COMPONENT_UNMOUNTED */, info);
+function memoize(fn, options = {}) {
+  const { maxSize = 100, keyGenerator = (...args) => JSON.stringify(args) } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = keyGenerator(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    if (cache.size >= maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) {
+        cache.delete(firstKey);
+      }
+    }
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  memoized.clear = () => cache.clear();
+  return memoized;
 }
-function emitRouterBeforeChange(info) {
-  return new Promise((resolve) => {
-    let prevented = false;
-    const prevent = () => {
-      prevented = true;
-    };
-    eventBus.emit("router:before-change" /* ROUTER_BEFORE_CHANGE */, info, prevent);
-    resolve(!prevented);
+function uuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
   });
 }
-function emitRouterAfterChange(info) {
-  eventBus.emit("router:after-change" /* ROUTER_AFTER_CHANGE */, info);
-}
-function emitRouterError(error, info) {
-  eventBus.emit("router:error" /* ROUTER_ERROR */, error, info);
-}
-function emitStoreInitialized(state) {
-  eventBus.emit("store:initialized" /* STORE_INITIALIZED */, state);
-}
-function emitStoreBeforeAction(actionType, payload, state) {
-  eventBus.emit("store:before-action" /* STORE_BEFORE_ACTION */, actionType, payload, state);
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  const tokens = {
+    "YYYY": String(d.getFullYear()),
+    "YY": String(d.getFullYear()).slice(-2),
+    "MM": pad(d.getMonth() + 1),
+    "M": String(d.getMonth() + 1),
+    "DD": pad(d.getDate()),
+    "D": String(d.getDate()),
+    "HH": pad(d.getHours()),
+    "H": String(d.getHours()),
+    "hh": pad(d.getHours() % 12 || 12),
+    "h": String(d.getHours() % 12 || 12),
+    "mm": pad(d.getMinutes()),
+    "m": String(d.getMinutes()),
+    "ss": pad(d.getSeconds()),
+    "s": String(d.getSeconds()),
+    "SSS": pad(d.getMilliseconds(), 3),
+    "A": d.getHours() < 12 ? "AM" : "PM",
+    "a": d.getHours() < 12 ? "am" : "pm"
+  };
+  let result = format;
+  for (const token in tokens) {
+    result = result.replace(new RegExp(token, "g"), tokens[token]);
+  }
+  return result;
 }
-function emitStoreAfterAction(info) {
-  eventBus.emit("store:after-action" /* STORE_AFTER_ACTION */, info);
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
 }
-function emitStoreError(error, actionType, payload) {
-  eventBus.emit("store:error" /* STORE_ERROR */, error, actionType, payload);
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  return keysA.every((key) => deepEqual(a[key], b[key]));
 }
-function onAppInit(handler) {
-  return eventBus.on("app:init" /* APP_INIT */, handler);
+function escapeHtml2(str) {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
 }
-function onAppMounted(handler) {
-  return eventBus.on("app:mounted" /* APP_MOUNTED */, handler);
+function unescapeHtml(str) {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => htmlUnescapes[entity] || entity);
 }
-function onAppUpdated(handler) {
-  return eventBus.on("app:updated" /* APP_UPDATED */, handler);
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function onAppError(handler) {
-  return eventBus.on("app:error" /* APP_ERROR */, handler);
+function camelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toLowerCase());
 }
-function onAppDestroyed(handler) {
-  return eventBus.on("app:destroyed" /* APP_DESTROYED */, handler);
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
 }
-function onComponentCreated(handler) {
-  return eventBus.on("component:created" /* COMPONENT_CREATED */, handler);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function onComponentMounted(handler) {
-  return eventBus.on("component:mounted" /* COMPONENT_MOUNTED */, handler);
+async function retry(fn, options = {}) {
+  const { retries = 3, delay = 1e3, backoff = 2, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        if (onRetry) {
+          onRetry(lastError, attempt + 1);
+        }
+        await sleep(delay * Math.pow(backoff, attempt));
+      }
+    }
+  }
+  throw lastError;
 }
-function onComponentUpdated(handler) {
-  return eventBus.on("component:updated" /* COMPONENT_UPDATED */, handler);
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
 }
-function onComponentError(handler) {
-  return eventBus.on("component:error" /* COMPONENT_ERROR */, handler);
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
 }
-function onComponentUnmounted(handler) {
-  return eventBus.on("component:unmounted" /* COMPONENT_UNMOUNTED */, handler);
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
 }
-function onRouterBeforeChange(handler) {
-  return eventBus.on("router:before-change" /* ROUTER_BEFORE_CHANGE */, handler);
+function groupBy(array, key) {
+  return array.reduce((result, item) => {
+    const groupKey = typeof key === "function" ? key(item) : String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {});
 }
-function onRouterAfterChange(handler) {
-  return eventBus.on("router:after-change" /* ROUTER_AFTER_CHANGE */, handler);
+function isEmpty(value) {
+  if (value === null || value === void 0)
+    return true;
+  if (typeof value === "string")
+    return value.trim() === "";
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value instanceof Map || value instanceof Set)
+    return value.size === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return false;
 }
-function onRouterError(handler) {
-  return eventBus.on("router:error" /* ROUTER_ERROR */, handler);
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
 }
-function onStoreInitialized(handler) {
-  return eventBus.on("store:initialized" /* STORE_INITIALIZED */, handler);
+function get(obj, path5, defaultValue) {
+  const keys = Array.isArray(path5) ? path5 : path5.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result === null || result === void 0) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
 }
-function onStoreBeforeAction(handler) {
-  return eventBus.on("store:before-action" /* STORE_BEFORE_ACTION */, handler);
+function set(obj, path5, value) {
+  const keys = Array.isArray(path5) ? path5 : path5.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return obj;
 }
-function onStoreAfterAction(handler) {
-  return eventBus.on("store:after-action" /* STORE_AFTER_ACTION */, handler);
+
+// src/core/errors.ts
+var BaraqexError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "hint");
+    __publicField(this, "docs");
+    __publicField(this, "originalCause");
+    this.name = "BaraqexError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.docs = options.docs;
+    this.originalCause = options.cause;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Format error for console output with helpful hints
+   */
+  format() {
+    let output = `
+\u274C ${this.name}: ${this.message}
+`;
+    output += `   Code: ${this.code}
+`;
+    if (this.hint) {
+      output += `   \u{1F4A1} Hint: ${this.hint}
+`;
+    }
+    if (this.docs) {
+      output += `   \u{1F4DA} Docs: ${this.docs}
+`;
+    }
+    return output;
+  }
+};
+var ConfigError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "CONFIG_ERROR",
+      hint: options?.hint || "Check your baraqex.config.js or server configuration",
+      docs: "https://baraqex.tech/docs/configuration",
+      cause: options?.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var DatabaseError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "DATABASE_ERROR",
+      hint: options?.hint || "Verify your database connection string and credentials",
+      docs: "https://baraqex.tech/docs/database",
+      cause: options?.cause
+    });
+    __publicField(this, "dbType");
+    this.name = "DatabaseError";
+    this.dbType = options?.dbType;
+  }
+};
+var AuthError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "AUTH_ERROR",
+      hint: options?.hint || "Check your JWT secret and token configuration",
+      docs: "https://baraqex.tech/docs/authentication",
+      cause: options?.cause
+    });
+    this.name = "AuthError";
+  }
+};
+var WasmError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "WASM_ERROR",
+      hint: options?.hint || "Ensure your .wasm file is accessible and properly compiled",
+      docs: "https://baraqex.tech/docs/webassembly",
+      cause: options?.cause
+    });
+    this.name = "WasmError";
+  }
+};
+var RouterError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "ROUTER_ERROR",
+      hint: options?.hint || "Check your API route file structure and exports",
+      docs: "https://baraqex.tech/docs/routing",
+      cause: options?.cause
+    });
+    this.name = "RouterError";
+  }
+};
+var ValidationError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      hint: options?.hint,
+      cause: options?.cause
+    });
+    __publicField(this, "field");
+    __publicField(this, "value");
+    this.name = "ValidationError";
+    this.field = options?.field;
+    this.value = options?.value;
+  }
+};
+function formatError(error) {
+  if (error instanceof BaraqexError) {
+    return error.format();
+  }
+  if (error instanceof Error) {
+    return `
+\u274C Error: ${error.message}
+`;
+  }
+  return `
+\u274C Unknown error: ${String(error)}
+`;
 }
-function onStoreError(handler) {
-  return eventBus.on("store:error" /* STORE_ERROR */, handler);
+function withErrorHandling(fn, errorHandler2) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (errorHandler2) {
+        errorHandler2(error);
+      } else {
+        console.error(formatError(error));
+      }
+      throw error;
+    }
+  };
 }
 
-// src/core/utils.ts
-function debounce(func, wait, options = {}) {
-  let timeoutId = null;
-  let lastArgs = null;
-  let lastThis = null;
-  let result;
-  let lastCallTime;
-  let lastInvokeTime = 0;
-  const { leading = false, trailing = true } = options;
-  const invokeFunc = (time) => {
-    const args = lastArgs;
-    const thisArg = lastThis;
-    lastArgs = null;
-    lastThis = null;
-    lastInvokeTime = time;
-    result = func.apply(thisArg, args);
-    return result;
-  };
-  const shouldInvoke = (time) => {
-    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || timeSinceLastInvoke >= wait;
-  };
-  const trailingEdge = (time) => {
-    timeoutId = null;
-    if (trailing && lastArgs) {
-      return invokeFunc(time);
+// src/wasm.ts
+async function loadGoWasm(wasmUrl, options = {}) {
+  if (typeof window === "undefined") {
+    throw new Error("loadGoWasm() is for browser use only. Use loadGoWasmFromFile() in Node.js.");
+  }
+  try {
+    if (!window.Go) {
+      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
     }
-    lastArgs = null;
-    lastThis = null;
-    return result;
-  };
-  const remainingWait = (time) => {
-    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
-    const timeSinceLastInvoke = time - lastInvokeTime;
-    const timeWaiting = wait - timeSinceLastCall;
-    return timeWaiting;
-  };
-  const timerExpired = () => {
-    const time = Date.now();
-    if (shouldInvoke(time)) {
-      return trailingEdge(time);
+    if (options.debug) {
+      console.log("[WASM] Loading WASM from:", wasmUrl);
     }
-    timeoutId = setTimeout(timerExpired, remainingWait(time));
-    return result;
-  };
-  const debounced = function(...args) {
-    const time = Date.now();
-    const isInvoking = shouldInvoke(time);
-    lastArgs = args;
-    lastThis = this;
-    lastCallTime = time;
-    if (isInvoking) {
-      if (timeoutId === null) {
-        lastInvokeTime = time;
-        timeoutId = setTimeout(timerExpired, wait);
-        if (leading) {
-          return invokeFunc(time);
+    const response = await fetch(wasmUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch WASM file: ${response.status}`);
+    }
+    const wasmBytes = await response.arrayBuffer();
+    const go = new window.Go();
+    const wasmModule = await WebAssembly.instantiate(wasmBytes, go.importObject);
+    go.run(wasmModule.instance);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (options.debug) {
+      console.log("[WASM] Go program started, checking for registered functions...");
+    }
+    const functions = {};
+    for (const key in window) {
+      if (typeof window[key] === "function" && key.startsWith("go")) {
+        functions[key] = window[key];
+        if (options.debug) {
+          console.log(`[WASM] Found function: ${key}`);
         }
       }
     }
-    if (timeoutId === null) {
-      timeoutId = setTimeout(timerExpired, wait);
-    }
-    return result;
-  };
-  debounced.cancel = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
+    const wasmInstance = {
+      instance: wasmModule.instance,
+      module: wasmModule,
+      exports: wasmModule.instance.exports,
+      functions
+    };
+    if (options.onLoad) {
+      options.onLoad(wasmInstance);
     }
-    lastInvokeTime = 0;
-    lastArgs = null;
-    lastThis = null;
-    lastCallTime = void 0;
-    timeoutId = null;
-  };
-  debounced.flush = () => {
-    if (timeoutId !== null) {
-      return trailingEdge(Date.now());
+    if (options.debug) {
+      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
     }
-    return result;
-  };
-  return debounced;
+    return wasmInstance;
+  } catch (error) {
+    console.error("[WASM] Error loading Go WASM module:", error);
+    throw error;
+  }
 }
-function throttle(func, wait, options = {}) {
-  let timeoutId = null;
-  let lastArgs = null;
-  let lastThis = null;
-  let result;
-  let lastCallTime = 0;
-  const { leading = true, trailing = true } = options;
-  const invokeFunc = () => {
-    const args = lastArgs;
-    const thisArg = lastThis;
-    lastArgs = null;
-    lastThis = null;
-    lastCallTime = Date.now();
-    result = func.apply(thisArg, args);
-    return result;
+function callWasmFunction(funcName, ...args) {
+  if (typeof window === "undefined") {
+    throw new Error("callWasmFunction() is for browser use only.");
+  }
+  const func = window[funcName];
+  if (typeof func !== "function") {
+    throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
+  }
+  return func(...args);
+}
+function isWasmReady() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return !!(window.Go && Object.keys(window).some(
+    (key) => key.startsWith("go") && typeof window[key] === "function"
+  ));
+}
+function getWasmFunctions() {
+  if (typeof window === "undefined") {
+    return [];
+  }
+  return Object.keys(window).filter(
+    (key) => key.startsWith("go") && typeof window[key] === "function"
+  );
+}
+function useGoWasm(wasmUrl, options = {}) {
+  if (typeof window === "undefined") {
+    throw new Error("useGoWasm() is for browser use only.");
+  }
+  return {
+    loadWasm: () => loadGoWasm(wasmUrl, options),
+    callFunction: callWasmFunction,
+    isReady: isWasmReady,
+    getFunctions: getWasmFunctions
   };
-  const throttled = function(...args) {
-    const now = Date.now();
-    const remaining = wait - (now - lastCallTime);
-    lastArgs = args;
-    lastThis = this;
-    if (remaining <= 0 || remaining > wait) {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
+}
+
+// src/server/index.ts
+import path4 from "path";
+import fs4 from "fs";
+
+// src/server/database.ts
+var Database = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "mongoClient", null);
+    __publicField(this, "mongoDb", null);
+    __publicField(this, "mysqlPool", null);
+    __publicField(this, "pgPool", null);
+    this.config = config;
+  }
+  async connect() {
+    switch (this.config.type) {
+      case "mongodb":
+        await this.connectMongo();
+        break;
+      case "mysql":
+        await this.connectMysql();
+        break;
+      case "postgres":
+        await this.connectPostgres();
+        break;
+      default:
+        throw new Error(`Unsupported database type: ${this.config.type}`);
+    }
+  }
+  async connectMongo() {
+    try {
+      const { MongoClient } = await import("mongodb");
+      this.mongoClient = new MongoClient(this.config.url);
+      await this.mongoClient.connect();
+      this.mongoDb = this.mongoClient.db();
+      console.log("Connected to MongoDB");
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("MongoDB driver not installed. Run: npm install mongodb");
       }
-      if (leading || lastCallTime !== 0) {
-        return invokeFunc();
+      console.error("MongoDB connection error:", error);
+      throw error;
+    }
+  }
+  async connectMysql() {
+    try {
+      const mysql = await import("mysql2/promise");
+      this.mysqlPool = mysql.createPool(this.config.url);
+      await this.mysqlPool.getConnection();
+      console.log("Connected to MySQL");
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("MySQL driver not installed. Run: npm install mysql2");
       }
+      console.error("MySQL connection error:", error);
+      throw error;
     }
-    if (!timeoutId && trailing) {
-      timeoutId = setTimeout(() => {
-        timeoutId = null;
-        if (trailing && lastArgs) {
-          invokeFunc();
+  }
+  async connectPostgres() {
+    try {
+      const pg = await import("pg");
+      this.pgPool = new pg.Pool({ connectionString: this.config.url });
+      const client = await this.pgPool.connect();
+      client.release();
+      console.log("Connected to PostgreSQL");
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("PostgreSQL driver not installed. Run: npm install pg @types/pg");
+      }
+      console.error("PostgreSQL connection error:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.mongoClient) {
+      await this.mongoClient.close();
+      this.mongoClient = null;
+      this.mongoDb = null;
+    }
+    if (this.mysqlPool) {
+      await this.mysqlPool.end();
+      this.mysqlPool = null;
+    }
+    if (this.pgPool) {
+      await this.pgPool.end();
+      this.pgPool = null;
+    }
+  }
+  // Database-specific methods
+  getMongoDb() {
+    return this.mongoDb;
+  }
+  getMysqlPool() {
+    return this.mysqlPool;
+  }
+  getPgPool() {
+    return this.pgPool;
+  }
+  // Generic query method
+  async query(sql, values) {
+    switch (this.config.type) {
+      case "mongodb":
+        throw new Error("For MongoDB, use getMongoDb() instead of query()");
+      case "mysql":
+        if (!this.mysqlPool)
+          throw new Error("MySQL not connected");
+        const [rows] = await this.mysqlPool.execute(sql, values || []);
+        return rows;
+      case "postgres":
+        if (!this.pgPool)
+          throw new Error("PostgreSQL not connected");
+        const result = await this.pgPool.query(sql, values || []);
+        return result.rows;
+      default:
+        throw new Error(`Unsupported database type: ${this.config.type}`);
+    }
+  }
+};
+
+// src/server/auth.ts
+var AuthService = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "jwtPromise", null);
+    this.config = {
+      expiresIn: "24h",
+      ...config
+    };
+  }
+  async getJwt() {
+    if (!this.jwtPromise) {
+      this.jwtPromise = import("jsonwebtoken").catch((error) => {
+        this.jwtPromise = null;
+        if (error.code === "MODULE_NOT_FOUND") {
+          throw new Error(
+            "jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken"
+          );
         }
-      }, remaining);
+        throw error;
+      });
+    }
+    return this.jwtPromise;
+  }
+  async hashPassword(password) {
+    try {
+      const bcrypt = await import("bcryptjs");
+      return bcrypt.hash(password, 10);
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("bcryptjs not installed. Run: npm install bcryptjs @types/bcryptjs");
+      }
+      throw error;
+    }
+  }
+  async comparePasswords(password, hashedPassword) {
+    try {
+      const bcrypt = await import("bcryptjs");
+      return bcrypt.compare(password, hashedPassword);
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("bcryptjs not installed. Run: npm install bcryptjs @types/bcryptjs");
+      }
+      throw error;
     }
-    return result;
-  };
-  throttled.cancel = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
+  }
+  async generateToken(user) {
+    const jwt = await this.getJwt();
+    const options = {};
+    if (this.config.expiresIn) {
+      options.expiresIn = this.config.expiresIn;
     }
-    timeoutId = null;
-    lastArgs = null;
-    lastThis = null;
-    lastCallTime = 0;
-  };
-  return throttled;
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object") {
-    return obj;
+    return jwt.sign(
+      { id: user.id, username: user.username, roles: user.roles || [] },
+      this.config.secret,
+      options
+    );
   }
-  if (obj instanceof Date) {
-    return new Date(obj.getTime());
+  async verifyToken(token) {
+    try {
+      const jwt = await this.getJwt();
+      return jwt.verify(token, this.config.secret);
+    } catch {
+      return null;
+    }
   }
-  if (obj instanceof RegExp) {
-    return new RegExp(obj.source, obj.flags);
+  initialize() {
+    return async (req, res, next) => {
+      const token = this.extractToken(req);
+      if (token) {
+        const decoded = await this.verifyToken(token);
+        if (decoded) {
+          req.user = decoded;
+        }
+      }
+      next();
+    };
   }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => deepClone(item));
+  requireAuth() {
+    return (req, res, next) => {
+      if (!req.user) {
+        return res.status(401).json({ message: "Unauthorized" });
+      }
+      return next();
+    };
   }
-  if (obj instanceof Map) {
-    const clonedMap = /* @__PURE__ */ new Map();
-    obj.forEach((value, key) => {
-      clonedMap.set(deepClone(key), deepClone(value));
-    });
-    return clonedMap;
+  requireRoles(roles) {
+    return (req, res, next) => {
+      if (!req.user) {
+        return res.status(401).json({ message: "Unauthorized" });
+      }
+      const userRoles = req.user.roles || [];
+      const hasRequiredRole = roles.some((role) => userRoles.includes(role));
+      if (!hasRequiredRole) {
+        return res.status(403).json({ message: "Forbidden" });
+      }
+      return next();
+    };
   }
-  if (obj instanceof Set) {
-    const clonedSet = /* @__PURE__ */ new Set();
-    obj.forEach((value) => {
-      clonedSet.add(deepClone(value));
-    });
-    return clonedSet;
+  extractToken(req) {
+    if (req.headers.authorization && req.headers.authorization.startsWith("Bearer ")) {
+      return req.headers.authorization.substring(7);
+    }
+    return null;
   }
-  const clonedObj = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      clonedObj[key] = deepClone(obj[key]);
+};
+
+// src/server/api-router.ts
+import path from "path";
+import fs from "fs";
+import { pathToFileURL } from "url";
+var ApiRouter = class {
+  constructor(apiDir, auth = null) {
+    __publicField(this, "router", null);
+    __publicField(this, "apiDir");
+    __publicField(this, "auth");
+    __publicField(this, "initialized", false);
+    this.apiDir = path.resolve(process.cwd(), apiDir);
+    this.auth = auth;
+  }
+  async initialize() {
+    if (this.initialized && this.router)
+      return;
+    try {
+      const express = await import("express");
+      this.router = express.default.Router();
+      this.setupRoutes();
+      this.initialized = true;
+      console.log("\u2705 API Router initialized successfully");
+    } catch (error) {
+      console.error("\u274C Failed to initialize API Router:", error);
+      if (error.code === "MODULE_NOT_FOUND") {
+        throw new Error("Express not installed. Run: npm install express @types/express");
+      }
+      throw error;
     }
   }
-  return clonedObj;
-}
-function deepMerge(target, ...sources) {
-  if (!sources.length)
-    return target;
-  const source = sources.shift();
-  if (source === void 0)
-    return target;
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      const targetValue = target[key];
-      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
-        target[key] = deepMerge(targetValue, sourceValue);
-      } else {
-        target[key] = deepClone(sourceValue);
+  isInitialized() {
+    return this.initialized && this.router !== null;
+  }
+  setupRoutes() {
+    if (!fs.existsSync(this.apiDir)) {
+      console.log(`API directory not found: ${this.apiDir}`);
+      return;
+    }
+    this.scanDirectory(this.apiDir, "");
+  }
+  scanDirectory(dirPath, routePrefix) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        this.scanDirectory(fullPath, `${routePrefix}/${entry.name}`);
+      } else if (this.isRouteFile(entry.name)) {
+        const routePath = this.getRoutePath(entry.name, routePrefix);
+        this.registerRoute(fullPath, routePath);
       }
     }
   }
-  return deepMerge(target, ...sources);
-}
-function memoize(fn, options = {}) {
-  const { maxSize = 100, keyGenerator = (...args) => JSON.stringify(args) } = options;
-  const cache = /* @__PURE__ */ new Map();
-  const memoized = function(...args) {
-    const key = keyGenerator(...args);
-    if (cache.has(key)) {
-      return cache.get(key);
+  isRouteFile(filename) {
+    return filename.endsWith(".js") || filename.endsWith(".ts") || filename.endsWith(".mjs");
+  }
+  getRoutePath(filename, routePrefix) {
+    const baseName = path.basename(filename, path.extname(filename));
+    if (baseName === "index") {
+      return routePrefix || "/";
     }
-    const result = fn(...args);
-    if (cache.size >= maxSize) {
-      const firstKey = cache.keys().next().value;
-      if (firstKey !== void 0) {
-        cache.delete(firstKey);
+    const paramMatch = baseName.match(/^\[(.+)\]$/);
+    if (paramMatch) {
+      return `${routePrefix}/:${paramMatch[1]}`;
+    }
+    return `${routePrefix}/${baseName}`;
+  }
+  async registerRoute(filePath, routePath) {
+    try {
+      const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
+      const fileUrl = pathToFileURL(absolutePath).href;
+      const urlWithTimestamp = `${fileUrl}?t=${Date.now()}`;
+      const routeModule = await import(urlWithTimestamp);
+      if (!this.isValidRouteModule(routeModule)) {
+        console.warn(`Invalid route module: ${filePath}`);
+        return;
+      }
+      console.log(`Registering API route: ${routePath}`);
+      const middleware = routeModule.middleware || [];
+      for (const method of ["get", "post", "put", "delete", "patch", "options"]) {
+        const handler = routeModule[method];
+        if (typeof handler === "function") {
+          const routerMethod = this.router[method];
+          routerMethod.call(
+            this.router,
+            routePath,
+            ...middleware,
+            this.wrapHandler(handler)
+          );
+        }
       }
+    } catch (error) {
+      console.error(`Error registering route (${filePath}):`, error);
     }
-    cache.set(key, result);
-    return result;
-  };
-  memoized.cache = cache;
-  memoized.clear = () => cache.clear();
-  return memoized;
-}
-function uuid() {
-  if (typeof crypto !== "undefined" && crypto.randomUUID) {
-    return crypto.randomUUID();
   }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
+  isValidRouteModule(module) {
+    if (!module)
+      return false;
+    return ["get", "post", "put", "delete", "patch", "options"].some((method) => typeof module[method] === "function");
+  }
+  wrapHandler(handler) {
+    return async (req, res, next) => {
+      try {
+        await handler(req, res, next);
+      } catch (error) {
+        next(error);
+      }
+    };
+  }
+};
+
+// src/server/middleware.ts
+var requestLogger = (req, res, next) => {
+  console.log(`${(/* @__PURE__ */ new Date()).toISOString()} - ${req.method} ${req.url}`);
+  next();
+};
+var errorHandler = (err, req, res, _next) => {
+  console.error(err.stack);
+  res.status(500).json({
+    error: {
+      message: "Internal Server Error",
+      ...process.env.NODE_ENV !== "production" ? { details: err.message, stack: err.stack } : {}
+    }
   });
-}
-function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
-  const d = date instanceof Date ? date : new Date(date);
-  if (isNaN(d.getTime())) {
-    return "Invalid Date";
+};
+var notFoundHandler = (req, res) => {
+  res.status(404).json({
+    error: {
+      message: `Not Found - ${req.method} ${req.url}`
+    }
+  });
+};
+function rateLimit(options) {
+  const requests = /* @__PURE__ */ new Map();
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [ip, times] of requests) {
+      const valid = times.filter((t) => now - t < options.windowMs);
+      if (valid.length === 0) {
+        requests.delete(ip);
+      } else {
+        requests.set(ip, valid);
+      }
+    }
+  }, options.windowMs);
+  if (cleanupInterval.unref) {
+    cleanupInterval.unref();
   }
-  const pad = (n, len = 2) => String(n).padStart(len, "0");
-  const tokens = {
-    "YYYY": String(d.getFullYear()),
-    "YY": String(d.getFullYear()).slice(-2),
-    "MM": pad(d.getMonth() + 1),
-    "M": String(d.getMonth() + 1),
-    "DD": pad(d.getDate()),
-    "D": String(d.getDate()),
-    "HH": pad(d.getHours()),
-    "H": String(d.getHours()),
-    "hh": pad(d.getHours() % 12 || 12),
-    "h": String(d.getHours() % 12 || 12),
-    "mm": pad(d.getMinutes()),
-    "m": String(d.getMinutes()),
-    "ss": pad(d.getSeconds()),
-    "s": String(d.getSeconds()),
-    "SSS": pad(d.getMilliseconds(), 3),
-    "A": d.getHours() < 12 ? "AM" : "PM",
-    "a": d.getHours() < 12 ? "am" : "pm"
+  return (req, res, next) => {
+    const ip = req.ip || req.socket?.remoteAddress || "unknown";
+    const now = Date.now();
+    const reqTimes = (requests.get(ip) || []).filter((time) => now - time < options.windowMs);
+    reqTimes.push(now);
+    requests.set(ip, reqTimes);
+    if (reqTimes.length > options.max) {
+      return res.status(429).json({
+        error: {
+          message: "Too Many Requests",
+          retryAfter: Math.ceil(options.windowMs / 1e3)
+        }
+      });
+    }
+    return next();
   };
-  let result = format;
-  for (const token in tokens) {
-    result = result.replace(new RegExp(token, "g"), tokens[token]);
+}
+
+// src/server/utils.ts
+import crypto2 from "crypto";
+import fs2 from "fs/promises";
+import path2 from "path";
+function safeJsonParse(json, fallback) {
+  try {
+    return JSON.parse(json);
+  } catch (error) {
+    return fallback;
   }
-  return result;
 }
-function shallowEqual(a, b) {
-  if (a === b)
-    return true;
-  if (!a || !b)
-    return false;
-  if (typeof a !== "object" || typeof b !== "object")
-    return false;
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length)
-    return false;
-  for (const key of keysA) {
-    if (a[key] !== b[key])
-      return false;
+function hashString(input, salt = "") {
+  return crypto2.createHash("sha256").update(input + salt).digest("hex");
+}
+function getPagination(req) {
+  const page = Math.max(1, parseInt(req.query.page) || 1);
+  const rawLimit = parseInt(req.query.limit);
+  let limit;
+  if (isNaN(rawLimit) || rawLimit <= 0) {
+    limit = 20;
+  } else {
+    limit = Math.max(1, Math.min(100, rawLimit));
   }
-  return true;
+  const skip = (page - 1) * limit;
+  return { page, limit, skip };
+}
+function sendSuccess(res, data, message = "Success") {
+  return res.json({
+    success: true,
+    message,
+    data
+  });
+}
+function sendError(res, message = "An error occurred", statusCode = 400, errors) {
+  return res.status(statusCode).json({
+    success: false,
+    message,
+    errors: errors || void 0
+  });
+}
+function validateFields(req, requiredFields) {
+  const missing = requiredFields.filter((field) => {
+    const value = req.body[field];
+    return value === void 0 || value === null || value === "";
+  });
+  return {
+    valid: missing.length === 0,
+    missing
+  };
 }
-function deepEqual(a, b) {
-  if (a === b)
-    return true;
-  if (a === null || b === null)
-    return false;
-  if (typeof a !== typeof b)
-    return false;
-  if (typeof a !== "object")
-    return false;
-  if (Array.isArray(a) !== Array.isArray(b))
-    return false;
-  if (Array.isArray(a)) {
-    if (a.length !== b.length)
-      return false;
-    return a.every((item, index) => deepEqual(item, b[index]));
+function validateFileUpload(file, options = {}) {
+  if (!file) {
+    return { valid: false, error: "No file provided" };
   }
-  if (a instanceof Date && b instanceof Date) {
-    return a.getTime() === b.getTime();
+  if (options.maxSize && file.size > options.maxSize) {
+    return {
+      valid: false,
+      error: `File too large. Maximum size allowed is ${options.maxSize / 1024 / 1024}MB`
+    };
   }
-  if (a instanceof RegExp && b instanceof RegExp) {
-    return a.source === b.source && a.flags === b.flags;
+  if (options.allowedTypes && options.allowedTypes.length > 0) {
+    const fileType = file.mimetype;
+    if (!options.allowedTypes.includes(fileType)) {
+      return {
+        valid: false,
+        error: `Invalid file type. Allowed types: ${options.allowedTypes.join(", ")}`
+      };
+    }
   }
-  const keysA = Object.keys(a);
-  const keysB = Object.keys(b);
-  if (keysA.length !== keysB.length)
-    return false;
-  return keysA.every((key) => deepEqual(a[key], b[key]));
-}
-function escapeHtml2(str) {
-  const htmlEscapes = {
-    "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#39;"
-  };
-  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+  return { valid: true };
 }
-function unescapeHtml(str) {
-  const htmlUnescapes = {
-    "&amp;": "&",
-    "&lt;": "<",
-    "&gt;": ">",
-    "&quot;": '"',
-    "&#39;": "'"
+function getEnvironmentInfo() {
+  return {
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    memory: process.memoryUsage(),
+    uptime: process.uptime(),
+    env: process.env.NODE_ENV || "development"
   };
-  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => htmlUnescapes[entity] || entity);
-}
-function capitalize(str) {
-  return str.charAt(0).toUpperCase() + str.slice(1);
 }
-function camelCase(str) {
-  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toLowerCase());
+async function isDirectoryEmpty(dirPath) {
+  try {
+    const files = await fs2.readdir(dirPath);
+    return files.length === 0;
+  } catch (error) {
+    return true;
+  }
 }
-function kebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+async function ensureDirectory(dirPath) {
+  try {
+    await fs2.access(dirPath);
+  } catch (error) {
+    await fs2.mkdir(dirPath, { recursive: true });
+  }
 }
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+async function writeJsonFile(filePath, data) {
+  await ensureDirectory(path2.dirname(filePath));
+  await fs2.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
 }
-async function retry(fn, options = {}) {
-  const { retries = 3, delay = 1e3, backoff = 2, onRetry } = options;
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (attempt < retries) {
-        if (onRetry) {
-          onRetry(lastError, attempt + 1);
-        }
-        await sleep(delay * Math.pow(backoff, attempt));
-      }
-    }
+async function readJsonFile(filePath, defaultValue) {
+  try {
+    const data = await fs2.readFile(filePath, "utf8");
+    return safeJsonParse(data, defaultValue);
+  } catch (error) {
+    return defaultValue;
   }
-  throw lastError;
 }
-function deferred() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
+
+// src/server/templates.ts
+function generateDocument(content, options = {}) {
+  const {
+    title = "Baraqex App",
+    description = "",
+    lang = "en",
+    charset = "UTF-8",
+    viewport = "width=device-width, initial-scale=1.0",
+    scripts = [],
+    styles = [],
+    meta = {},
+    bodyClasses = "",
+    htmlAttrs = {},
+    bodyAttrs = {},
+    initialData = {},
+    componentName = ""
+  } = options;
+  const htmlAttributes = Object.entries(htmlAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
+  const bodyAttributes = Object.entries(bodyAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
+  const metaTags = [
+    `<meta charset="${charset}">`,
+    `<meta name="viewport" content="${viewport}">`,
+    description ? `<meta name="description" content="${escapeHtml3(description)}">` : ""
+  ];
+  Object.entries(meta).forEach(([name, content2]) => {
+    metaTags.push(`<meta name="${escapeHtml3(name)}" content="${escapeHtml3(content2)}">`);
   });
-  return { promise, resolve, reject };
-}
-function pick(obj, keys) {
-  const result = {};
-  for (const key of keys) {
-    if (key in obj) {
-      result[key] = obj[key];
+  const scriptTags = scripts.map((src) => {
+    if (src.startsWith("<script")) {
+      return src;
     }
-  }
-  return result;
-}
-function omit(obj, keys) {
-  const result = { ...obj };
-  for (const key of keys) {
-    delete result[key];
-  }
-  return result;
+    return `<script src="${escapeHtml3(src)}" ${src.endsWith(".js") ? 'type="module"' : ""} defer></script>`;
+  });
+  const styleTags = styles.map((href) => {
+    if (href.startsWith("<style")) {
+      return href;
+    }
+    return `<link rel="stylesheet" href="${escapeHtml3(href)}">`;
+  });
+  const initialDataScript = Object.keys(initialData).length > 0 ? `<script id="__APP_DATA__" type="application/json">${escapeHtml3(JSON.stringify(initialData))}</script>` : "";
+  return `<!DOCTYPE html>
+<html lang="${lang}" ${htmlAttributes}>
+<head>
+  ${metaTags.filter(Boolean).join("\n  ")}
+  <title>${escapeHtml3(title)}</title>
+  ${styleTags.join("\n  ")}
+</head>
+<body class="${bodyClasses}" ${bodyAttributes}>
+  <div id="app-root" data-ssr-root${componentName ? ` data-component="${escapeHtml3(componentName)}"` : ""}>${content}</div>
+  ${initialDataScript}
+  ${scriptTags.join("\n  ")}
+</body>
+</html>`;
 }
-function groupBy(array, key) {
-  return array.reduce((result, item) => {
-    const groupKey = typeof key === "function" ? key(item) : String(item[key]);
-    if (!result[groupKey]) {
-      result[groupKey] = [];
+function generateErrorPage(statusCode, message, error) {
+  const errorMessages = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error"
+  };
+  const title = `${statusCode} - ${errorMessages[statusCode] || "Error"}`;
+  const isDev = process.env.NODE_ENV !== "production";
+  const errorDetails = isDev && error ? `
+    <div class="error-details">
+      <pre>${escapeHtml3(error.stack || error.message)}</pre>
+    </div>
+  ` : "";
+  const content = `
+    <div class="error-container">
+      <h1>${statusCode}</h1>
+      <h2>${escapeHtml3(errorMessages[statusCode] || "Error")}</h2>
+      <p>${escapeHtml3(message)}</p>
+      ${errorDetails}
+      <a href="/" class="home-link">Back to Home</a>
+    </div>
+  `;
+  const styles = [`<style>
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      min-height: 100vh;
+      margin: 0;
+      background-color: #f7f7f7;
+      color: #333;
+    }
+    .error-container {
+      text-align: center;
+      padding: 2rem;
+      border-radius: 8px;
+      background-color: white;
+      box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+      max-width: 600px;
+      width: 100%;
+    }
+    h1 {
+      font-size: 6rem;
+      margin: 0;
+      color: #e74c3c;
+    }
+    h2 {
+      margin-top: 0;
+      margin-bottom: 1rem;
+      color: #333;
+    }
+    .error-details {
+      text-align: left;
+      margin: 2rem 0;
+      padding: 1rem;
+      background-color: #f8f8f8;
+      border-radius: 4px;
+      overflow: auto;
+    }
+    pre {
+      margin: 0;
+      font-family: monospace;
+      font-size: 0.85rem;
+      white-space: pre-wrap;
     }
-    result[groupKey].push(item);
-    return result;
-  }, {});
-}
-function isEmpty(value) {
-  if (value === null || value === void 0)
-    return true;
-  if (typeof value === "string")
-    return value.trim() === "";
-  if (Array.isArray(value))
-    return value.length === 0;
-  if (value instanceof Map || value instanceof Set)
-    return value.size === 0;
-  if (typeof value === "object")
-    return Object.keys(value).length === 0;
-  return false;
-}
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-function get(obj, path5, defaultValue) {
-  const keys = Array.isArray(path5) ? path5 : path5.split(".");
-  let result = obj;
-  for (const key of keys) {
-    if (result === null || result === void 0) {
-      return defaultValue;
+    .home-link {
+      display: inline-block;
+      margin-top: 1.5rem;
+      padding: 0.75rem 1.5rem;
+      background-color: #3498db;
+      color: white;
+      text-decoration: none;
+      border-radius: 4px;
+      transition: background-color 0.2s;
     }
-    result = result[key];
-  }
-  return result === void 0 ? defaultValue : result;
-}
-function set(obj, path5, value) {
-  const keys = Array.isArray(path5) ? path5 : path5.split(".");
-  let current = obj;
-  for (let i = 0; i < keys.length - 1; i++) {
-    const key = keys[i];
-    if (!(key in current) || typeof current[key] !== "object") {
-      current[key] = {};
+    .home-link:hover {
+      background-color: #2980b9;
     }
-    current = current[key];
-  }
-  current[keys[keys.length - 1]] = value;
-  return obj;
+  </style>`];
+  return generateDocument(content, {
+    title,
+    description: `Error ${statusCode}: ${errorMessages[statusCode] || "Error"}`,
+    bodyClasses: "error-page",
+    styles
+  });
+}
+function escapeHtml3(text) {
+  return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
 
-// src/core/errors.ts
-var BaraqexError = class extends Error {
-  constructor(message, options) {
-    super(message);
-    __publicField(this, "code");
-    __publicField(this, "hint");
-    __publicField(this, "docs");
-    __publicField(this, "originalCause");
-    this.name = "BaraqexError";
-    this.code = options.code;
-    this.hint = options.hint;
-    this.docs = options.docs;
-    this.originalCause = options.cause;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  /**
-   * Format error for console output with helpful hints
-   */
-  format() {
-    let output = `
-\u274C ${this.name}: ${this.message}
-`;
-    output += `   Code: ${this.code}
-`;
-    if (this.hint) {
-      output += `   \u{1F4A1} Hint: ${this.hint}
-`;
-    }
-    if (this.docs) {
-      output += `   \u{1F4DA} Docs: ${this.docs}
-`;
-    }
-    return output;
-  }
-};
-var ConfigError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "CONFIG_ERROR",
-      hint: options?.hint || "Check your baraqex.config.js or server configuration",
-      docs: "https://baraqex.tech/docs/configuration",
-      cause: options?.cause
-    });
-    this.name = "ConfigError";
-  }
-};
-var DatabaseError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "DATABASE_ERROR",
-      hint: options?.hint || "Verify your database connection string and credentials",
-      docs: "https://baraqex.tech/docs/database",
-      cause: options?.cause
-    });
-    __publicField(this, "dbType");
-    this.name = "DatabaseError";
-    this.dbType = options?.dbType;
-  }
-};
-var AuthError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "AUTH_ERROR",
-      hint: options?.hint || "Check your JWT secret and token configuration",
-      docs: "https://baraqex.tech/docs/authentication",
-      cause: options?.cause
-    });
-    this.name = "AuthError";
-  }
-};
-var WasmError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "WASM_ERROR",
-      hint: options?.hint || "Ensure your .wasm file is accessible and properly compiled",
-      docs: "https://baraqex.tech/docs/webassembly",
-      cause: options?.cause
-    });
-    this.name = "WasmError";
-  }
-};
-var RouterError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "ROUTER_ERROR",
-      hint: options?.hint || "Check your API route file structure and exports",
-      docs: "https://baraqex.tech/docs/routing",
-      cause: options?.cause
-    });
-    this.name = "RouterError";
-  }
-};
-var ValidationError = class extends BaraqexError {
-  constructor(message, options) {
-    super(message, {
-      code: "VALIDATION_ERROR",
-      hint: options?.hint,
-      cause: options?.cause
-    });
-    __publicField(this, "field");
-    __publicField(this, "value");
-    this.name = "ValidationError";
-    this.field = options?.field;
-    this.value = options?.value;
-  }
-};
-function formatError(error) {
-  if (error instanceof BaraqexError) {
-    return error.format();
-  }
-  if (error instanceof Error) {
-    return `
-\u274C Error: ${error.message}
-`;
+// src/server/wasm.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var initialized = false;
+async function initNodeWasm() {
+  if (initialized)
+    return;
+  try {
+    globalThis.TextEncoder = globalThis.TextEncoder || TextEncoder;
+    globalThis.TextDecoder = globalThis.TextDecoder || TextDecoder;
+    initialized = true;
+  } catch (error) {
+    console.error("[WASM] Failed to initialize Node.js WASM environment:", error);
+    throw error;
   }
-  return `
-\u274C Unknown error: ${String(error)}
-`;
 }
-function withErrorHandling(fn, errorHandler3) {
-  return async (...args) => {
+async function loadGoRuntime(goWasmPath) {
+  if (typeof globalThis.Go === "function") {
+    return globalThis.Go;
+  }
+  const possiblePaths = [
+    goWasmPath,
+    "./wasm_exec.cjs",
+    "./wasm_exec.js",
+    "./public/wasm_exec.cjs",
+    "./public/wasm_exec.js",
+    "./src/wasm_exec.cjs",
+    "./src/wasm_exec.js",
+    path3.join(process.cwd(), "wasm_exec.cjs"),
+    path3.join(process.cwd(), "wasm_exec.js"),
+    path3.join(process.cwd(), "public", "wasm_exec.cjs"),
+    path3.join(process.cwd(), "public", "wasm_exec.js"),
+    path3.join(process.cwd(), "src", "wasm_exec.cjs"),
+    path3.join(process.cwd(), "src", "wasm_exec.js")
+  ].filter(Boolean);
+  for (const wasmExecPath of possiblePaths) {
     try {
-      return await fn(...args);
-    } catch (error) {
-      if (errorHandler3) {
-        errorHandler3(error);
+      const resolvedPath = path3.resolve(wasmExecPath);
+      try {
+        const stats = await fs3.stat(resolvedPath);
+        if (!stats.isFile()) {
+          continue;
+        }
+      } catch (statError) {
+        continue;
+      }
+      const wasmExecUrl = pathToFileURL2(resolvedPath).href;
+      if (globalThis.Go) {
+        delete globalThis.Go;
+      }
+      await import(wasmExecUrl);
+      if (typeof globalThis.Go === "function") {
+        console.log(`[WASM] Loaded Go runtime from: ${resolvedPath}`);
+        return globalThis.Go;
       } else {
-        console.error(formatError(error));
+        console.warn(`[WASM] File found but Go class not exported: ${resolvedPath}`);
       }
-      throw error;
+    } catch (error) {
+      console.warn(`[WASM] Error loading from ${wasmExecPath}:`, error.message);
+      continue;
     }
-  };
-}
-
-// src/wasm.ts
-async function loadGoWasm(wasmUrl, options = {}) {
-  if (typeof window === "undefined") {
-    throw new Error("loadGoWasm() is for browser use only. Use loadGoWasmFromFile() in Node.js.");
   }
+  throw new Error(
+    `[WASM] Could not find wasm_exec.js. Please ensure you have the Go WASM runtime file available.
+You can get it from: https://github.com/golang/go/blob/master/misc/wasm/wasm_exec.js
+Searched paths: ${possiblePaths.join(", ")}`
+  );
+}
+async function loadGoWasmFromFile(wasmFilePath, options = {}) {
   try {
-    if (!window.Go) {
-      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
+    await initNodeWasm();
+    if (options.debug) {
+      console.log("[WASM] Loading WASM from file:", wasmFilePath);
     }
+    const GoRuntime = await loadGoRuntime(options.goWasmPath);
+    const go = new GoRuntime();
+    const wasmBuffer = await fs3.readFile(wasmFilePath);
+    const wasmModule = await WebAssembly.compile(new Uint8Array(wasmBuffer));
+    const baseImports = go.importObject;
+    const finalImportObject = {
+      ...baseImports,
+      ...options.importObject
+    };
     if (options.debug) {
-      console.log("[WASM] Loading WASM from:", wasmUrl);
+      console.log("[WASM] Available import modules:", Object.keys(finalImportObject));
+      for (const [moduleName, moduleExports] of Object.entries(finalImportObject)) {
+        if (typeof moduleExports === "object" && moduleExports !== null) {
+          const exportNames = Object.keys(moduleExports);
+          console.log(`[WASM] ${moduleName} import functions:`, exportNames);
+        }
+      }
     }
-    const response = await fetch(wasmUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch WASM file: ${response.status}`);
+    const instance = await WebAssembly.instantiate(wasmModule, finalImportObject);
+    if (options.debug) {
+      console.log("[WASM] WASM instance created, starting Go runtime...");
     }
-    const wasmBytes = await response.arrayBuffer();
-    const go = new window.Go();
-    const wasmModule = await WebAssembly.instantiate(wasmBytes, go.importObject);
-    go.run(wasmModule.instance);
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    const runPromise = go.run(instance);
     if (options.debug) {
-      console.log("[WASM] Go program started, checking for registered functions...");
+      console.log("[WASM] Go runtime started, waiting for initialization...");
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    if (options.debug) {
+      console.log("[WASM] Scanning global object for Go functions...");
     }
     const functions = {};
-    for (const key in window) {
-      if (typeof window[key] === "function" && key.startsWith("go")) {
-        functions[key] = window[key];
+    const globalObj = globalThis;
+    const allKeys = Object.getOwnPropertyNames(globalObj);
+    const goKeys = allKeys.filter((key) => key.startsWith("go"));
+    if (options.debug) {
+      console.log('[WASM] All keys starting with "go":', goKeys);
+    }
+    for (const key of goKeys) {
+      if (typeof globalObj[key] === "function") {
+        functions[key] = globalObj[key];
         if (options.debug) {
           console.log(`[WASM] Found function: ${key}`);
         }
       }
     }
     const wasmInstance = {
-      instance: wasmModule.instance,
+      instance,
       module: wasmModule,
-      exports: wasmModule.instance.exports,
+      exports: instance.exports,
       functions
     };
     if (options.onLoad) {
@@ -3765,50 +3148,396 @@ async function loadGoWasm(wasmUrl, options = {}) {
     }
     if (options.debug) {
       console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
+      console.log("[WASM] Final function list:", Object.keys(functions));
     }
+    runPromise.catch((error) => {
+      if (options.debug) {
+        console.log("[WASM] Go program finished with error:", error);
+      }
+    });
     return wasmInstance;
   } catch (error) {
-    console.error("[WASM] Error loading Go WASM module:", error);
+    console.error("[WASM] Failed to load Go WASM module:", error);
     throw error;
   }
 }
-function callWasmFunction(funcName, ...args) {
-  if (typeof window === "undefined") {
-    throw new Error("callWasmFunction() is for browser use only.");
-  }
-  const func = window[funcName];
-  if (typeof func !== "function") {
-    throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
+
+// src/server/index.ts
+import { pathToFileURL as pathToFileURL3 } from "url";
+function getComponentName(filePath, pagesDir) {
+  try {
+    const relativePath = path4.relative(pagesDir, filePath);
+    const withoutExt = relativePath.replace(/\.[^/.]+$/, "");
+    const cleanPath = withoutExt.replace(/\/index$/, "");
+    return `/pages/${cleanPath}`;
+  } catch (e) {
+    return "";
   }
-  return func(...args);
 }
-function isWasmReady() {
-  if (typeof window === "undefined") {
-    return false;
+var Server = class {
+  constructor(config = {}) {
+    __publicField(this, "app");
+    __publicField(this, "server", null);
+    __publicField(this, "config");
+    __publicField(this, "db", null);
+    __publicField(this, "auth", null);
+    __publicField(this, "initialized", false);
+    this.config = {
+      port: 3e3,
+      apiDir: "./api",
+      pagesDir: "./pages",
+      staticDir: "./public",
+      enableCors: true,
+      ...config
+    };
   }
-  return !!(window.Go && Object.keys(window).some(
-    (key) => key.startsWith("go") && typeof window[key] === "function"
-  ));
-}
-function getWasmFunctions() {
-  if (typeof window === "undefined") {
-    return [];
+  async initializeApp() {
+    if (this.initialized)
+      return;
+    try {
+      const express = await import("express");
+      this.app = express.default();
+      this.app.use(express.default.json());
+      this.app.use(express.default.urlencoded({ extended: true }));
+      if (this.config.enableCors) {
+        try {
+          const cors = await import("cors");
+          this.app.use(cors.default(this.config.corsOptions));
+        } catch (error) {
+          console.warn("CORS not available - install with: npm install cors @types/cors");
+        }
+      }
+      if (this.config.db) {
+        this.db = new Database(this.config.db);
+      }
+      if (this.config.auth) {
+        this.auth = new AuthService({
+          secret: this.config.auth.secret,
+          expiresIn: this.config.auth.expiresIn
+        });
+        this.app.use(this.auth.initialize());
+      }
+      const staticPath = path4.resolve(process.cwd(), this.config.staticDir);
+      if (fs4.existsSync(staticPath)) {
+        this.app.use(express.default.static(staticPath));
+      }
+      this.setupApiRoutes();
+      this.setupPageRoutes();
+      this.app.use(notFoundHandler);
+      this.app.use(errorHandler);
+      this.initialized = true;
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND" && error.message.includes("express")) {
+        throw new Error("Express not installed. Run: npm install express @types/express");
+      }
+      throw error;
+    }
   }
-  return Object.keys(window).filter(
-    (key) => key.startsWith("go") && typeof window[key] === "function"
-  );
-}
-function useGoWasm(wasmUrl, options = {}) {
-  if (typeof window === "undefined") {
-    throw new Error("useGoWasm() is for browser use only.");
+  async setupApiRoutes() {
+    const apiRouter = new ApiRouter(this.config.apiDir, this.auth);
+    await apiRouter.initialize();
+    if (!apiRouter.isInitialized() || !apiRouter.router) {
+      console.warn("\u26A0\uFE0F API router not initialized properly - skipping API routes");
+      return;
+    }
+    console.log("\u2705 Setting up API routes...");
+    this.app.use("/api", requestLogger, apiRouter.router);
+    this.app.get("/api-docs", (req, res) => {
+      const apiDocs = this.generateApiDocs();
+      res.json(apiDocs);
+    });
   }
-  return {
-    loadWasm: () => loadGoWasm(wasmUrl, options),
-    callFunction: callWasmFunction,
-    isReady: isWasmReady,
-    getFunctions: getWasmFunctions
-  };
+  generateApiDocs() {
+    const apiDir = path4.resolve(process.cwd(), this.config.apiDir);
+    const docs = { endpoints: [] };
+    if (fs4.existsSync(apiDir)) {
+      this.scanApiDirectory(apiDir, "", docs.endpoints);
+    }
+    return docs;
+  }
+  scanApiDirectory(dirPath, routePrefix, endpoints) {
+    const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path4.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        this.scanApiDirectory(fullPath, `${routePrefix}/${entry.name}`, endpoints);
+      } else if (entry.name.endsWith(".js") || entry.name.endsWith(".ts")) {
+        const routePath = this.getRoutePath(entry.name, routePrefix);
+        endpoints.push({
+          path: routePath,
+          file: path4.relative(process.cwd(), fullPath),
+          methods: this.detectApiMethods(fullPath)
+        });
+      }
+    }
+  }
+  getRoutePath(filename, routePrefix) {
+    const baseName = path4.basename(filename, path4.extname(filename));
+    if (baseName === "index") {
+      return routePrefix || "/";
+    }
+    const paramMatch = baseName.match(/^\[(.+)\]$/);
+    if (paramMatch) {
+      return `${routePrefix}/:${paramMatch[1]}`;
+    }
+    return `${routePrefix}/${baseName}`;
+  }
+  detectApiMethods(filePath) {
+    try {
+      const content = fs4.readFileSync(filePath, "utf8");
+      const methods = ["get", "post", "put", "delete", "patch", "options"];
+      return methods.filter(
+        (method) => new RegExp(`export (async )?function ${method}\\s*\\(`).test(content) || new RegExp(`export const ${method}\\s*=`).test(content)
+      );
+    } catch (error) {
+      return [];
+    }
+  }
+  setupPageRoutes() {
+    const pagesPath = path4.resolve(process.cwd(), this.config.pagesDir);
+    if (!fs4.existsSync(pagesPath)) {
+      return;
+    }
+    this.app.get("*", async (req, res) => {
+      try {
+        const { html, statusCode } = await this.renderPage(req.path);
+        res.status(statusCode || 200).send(html);
+      } catch (error) {
+        console.error("Error rendering page:", error);
+        const errorHtml = generateErrorPage(500, "Server Error");
+        res.status(500).send(errorHtml);
+      }
+    });
+  }
+  async renderPage(routePath) {
+    try {
+      const pagesDir = this.config.pagesDir ? path4.resolve(process.cwd(), this.config.pagesDir) : "";
+      if (!pagesDir || !fs4.existsSync(pagesDir)) {
+        return {
+          html: generateErrorPage(404, "Pages directory not found"),
+          statusCode: 404
+        };
+      }
+      let normalizedPath = routePath;
+      if (!normalizedPath.startsWith("/")) {
+        normalizedPath = "/" + normalizedPath;
+      }
+      if (normalizedPath === "/") {
+        normalizedPath = "/index";
+      }
+      let pagePath = "";
+      const possiblePaths = [
+        path4.join(pagesDir, `${normalizedPath}.js`),
+        path4.join(pagesDir, `${normalizedPath}.ts`),
+        path4.join(pagesDir, `${normalizedPath}.jsx`),
+        path4.join(pagesDir, `${normalizedPath}.tsx`),
+        path4.join(pagesDir, `${normalizedPath}/index.js`),
+        path4.join(pagesDir, `${normalizedPath}/index.ts`),
+        path4.join(pagesDir, `${normalizedPath}/index.jsx`),
+        path4.join(pagesDir, `${normalizedPath}/index.tsx`)
+      ];
+      for (const p of possiblePaths) {
+        if (fs4.existsSync(p)) {
+          pagePath = p;
+          break;
+        }
+      }
+      if (!pagePath) {
+        return {
+          html: generateErrorPage(404, `Page not found: ${normalizedPath}`),
+          statusCode: 404
+        };
+      }
+      try {
+        const absolutePath = path4.isAbsolute(pagePath) ? pagePath : path4.resolve(pagePath);
+        const fileUrl = pathToFileURL3(absolutePath).href;
+        const urlWithTimestamp = `${fileUrl}?t=${Date.now()}`;
+        const pageModule = await import(urlWithTimestamp);
+        if (!pageModule || !pageModule.default) {
+          throw new Error(`No default export found in ${pagePath}`);
+        }
+        const PageComponent = pageModule.default;
+        const initialProps = {
+          // Provide any initial props here
+          path: normalizedPath,
+          query: {},
+          // Could be parsed from URL
+          api: { serverTime: (/* @__PURE__ */ new Date()).toISOString() }
+        };
+        const renderResult = await renderComponent(PageComponent, initialProps);
+        if (!renderResult.success) {
+          return {
+            html: generateErrorPage(500, "Failed to render page", renderResult.error instanceof Error ? renderResult.error : new Error("Unknown error")),
+            statusCode: 500
+          };
+        }
+        const htmlContent = renderResult.html;
+        let pageTitle = "My App";
+        try {
+          if (typeof PageComponent.getTitle === "function") {
+            pageTitle = PageComponent.getTitle(initialProps);
+          } else if (PageComponent.title) {
+            pageTitle = PageComponent.title;
+          }
+        } catch (e) {
+        }
+        const componentName = getComponentName(pagePath, pagesDir);
+        const fullHtml = generateDocument(htmlContent, {
+          title: pageTitle,
+          // Get description from component if available
+          description: typeof PageComponent.getDescription === "function" ? PageComponent.getDescription(initialProps) : PageComponent.description || "",
+          // Add scripts for client-side hydration
+          scripts: ["/client.js"],
+          // Add any custom meta tags
+          meta: typeof PageComponent.getMeta === "function" ? PageComponent.getMeta(initialProps) : {},
+          // Add custom styles
+          styles: ["/styles.css"],
+          // Add initial data for client-side hydration
+          initialData: initialProps,
+          // Add component information for hydration
+          componentName
+        });
+        return { html: fullHtml, statusCode: 200 };
+      } catch (error) {
+        console.error("Error rendering page:", error);
+        return {
+          html: generateErrorPage(500, "Error rendering page", error instanceof Error ? error : new Error("Unknown error")),
+          statusCode: 500
+        };
+      }
+    } catch (error) {
+      console.error("Error finding page:", error);
+      return {
+        html: generateErrorPage(500, "Server error", error instanceof Error ? error : new Error("Unknown error")),
+        statusCode: 500
+      };
+    }
+  }
+  getExpressApp() {
+    return this.app;
+  }
+  getDatabase() {
+    return this.db;
+  }
+  getAuth() {
+    return this.auth;
+  }
+  async start() {
+    await this.initializeApp();
+    return new Promise((resolve) => {
+      this.server = this.app.listen(this.config.port, () => {
+        console.log(`Server running at http://localhost:${this.config.port}`);
+        resolve();
+      });
+    });
+  }
+  stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        return resolve();
+      }
+      this.server.close((err) => {
+        if (err)
+          return reject(err);
+        this.server = null;
+        resolve();
+      });
+    });
+  }
+  restart() {
+    return this.stop().then(() => this.start());
+  }
+  enableSSR(options = {}) {
+    if (!fs4.existsSync(path4.resolve(process.cwd(), this.config.pagesDir))) {
+      fs4.mkdirSync(path4.resolve(process.cwd(), this.config.pagesDir), { recursive: true });
+    }
+    if (options.hydratable) {
+      const staticDir = path4.resolve(process.cwd(), this.config.staticDir);
+      if (!fs4.existsSync(staticDir)) {
+        fs4.mkdirSync(staticDir, { recursive: true });
+      }
+      const clientJsPath = path4.join(staticDir, "client.js");
+      if (!fs4.existsSync(clientJsPath)) {
+        const clientJsContent = `
+          // Auto-generated hydration script
+          import { hydrate } from 'baraqex';
+
+          // Find SSR content and hydrate it
+          document.addEventListener('DOMContentLoaded', () => {
+            const ssrRoots = document.querySelectorAll('[data-ssr-root]');
+            ssrRoots.forEach(root => {
+              const componentPath = root.getAttribute('data-component');
+              if (componentPath) {
+                import(componentPath).then(module => {
+                  hydrate(module.default, root);
+                });
+              }
+            });
+          });
+        `;
+        fs4.writeFileSync(clientJsPath, clientJsContent);
+      }
+    }
+  }
+  registerPlugin(plugin) {
+    plugin(this);
+  }
+  addShutdownHandler() {
+    const gracefulShutdown = async () => {
+      console.log("Received shutdown signal, closing server...");
+      try {
+        await this.stop();
+        if (this.db) {
+          await this.db.disconnect();
+        }
+        console.log("Server shut down gracefully");
+        process.exit(0);
+      } catch (error) {
+        console.error("Error during shutdown:", error);
+        process.exit(1);
+      }
+    };
+    process.on("SIGTERM", gracefulShutdown);
+    process.on("SIGINT", gracefulShutdown);
+  }
+};
+function createServer(config = {}) {
+  return new Server(config);
+}
+function createDevServer(options = {}) {
+  return new Server({
+    port: options.port || 3e3,
+    enableCors: options.enableCors !== false,
+    apiDir: "./src/api",
+    pagesDir: "./src/pages",
+    staticDir: "./public"
+  });
+}
+function createProductionServer(config) {
+  const server = new Server({
+    ...config,
+    // Fix the PORT parsing
+    port: config.port || (process.env.PORT ? parseInt(process.env.PORT) : 8080)
+  });
+  server.addShutdownHandler();
+  return server;
 }
+var renderComponent = (Component2, props = {}) => {
+  try {
+    const html = renderToString(Component2(props));
+    return {
+      html: typeof html === "string" ? html : String(html),
+      success: true
+    };
+  } catch (error) {
+    console.error("Error rendering component:", error);
+    return {
+      html: `<div class="error">Error rendering component</div>`,
+      success: false,
+      error
+    };
+  }
+};
 
 // src/index.ts
 var safeJsonParse2 = (json, fallback) => {
@@ -3818,7 +3547,7 @@ var safeJsonParse2 = (json, fallback) => {
     return fallback;
   }
 };
-var generateToken2 = (length = 32) => {
+var generateToken = (length = 32) => {
   const array = new Uint8Array(length);
   if (typeof crypto !== "undefined" && crypto.getRandomValues) {
     crypto.getRandomValues(array);
@@ -3831,7 +3560,7 @@ var generateToken2 = (length = 32) => {
 };
 var generateDocument2 = (content, options = {}) => `<!DOCTYPE html><html><head><title>${options.title || "App"}</title></head><body>${content}</body></html>`;
 var generateErrorPage2 = (code, message) => `<div>Error ${code}: ${message}</div>`;
-var generateLoadingPage2 = (message = "Loading...") => `<div>${message}</div>`;
+var generateLoadingPage = (message = "Loading...") => `<div>${message}</div>`;
 var fallbackRenderToString = (component) => {
   try {
     if (typeof component === "function") {
@@ -3843,113 +3572,15 @@ var fallbackRenderToString = (component) => {
     return "<div>Error rendering component</div>";
   }
 };
-function createLazyLoader(importFn, fallback) {
-  let cached = null;
-  let loading = null;
-  async function ensure() {
-    if (cached)
-      return cached;
-    if (!loading) {
-      loading = importFn().then((mod) => {
-        cached = mod;
-        return mod;
-      });
-    }
-    return loading;
-  }
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (cached?.[prop] !== void 0) {
-        return cached[prop];
-      }
-      if (fallback && fallback[prop]) {
-        return fallback[prop];
-      }
-      return async (...args) => {
-        const mod = await ensure();
-        const fn = mod[prop];
-        if (typeof fn !== "function") {
-          throw new Error(
-            `[baraqex] '${prop}' is not exported from the server module.`
-          );
-        }
-        return fn(...args);
-      };
-    }
-  });
-}
-var notAvailable = (name) => () => {
-  throw new Error(
-    `[baraqex] ${name} is only available in a Node.js environment with Express installed. Run: npm install express @types/express`
-  );
-};
-var serverNotFound = {
-  createServer: notAvailable("createServer"),
-  createDevServer: notAvailable("createDevServer"),
-  createProductionServer: notAvailable("createProductionServer"),
-  Server: notAvailable("Server"),
-  renderComponent: notAvailable("renderComponent"),
-  Database: notAvailable("Database"),
-  AuthService: notAvailable("AuthService"),
-  ApiRouter: notAvailable("ApiRouter"),
-  requestLogger: notAvailable("requestLogger"),
-  errorHandler: notAvailable("errorHandler"),
-  notFoundHandler: notAvailable("notFoundHandler"),
-  rateLimit: notAvailable("rateLimit"),
-  initNodeWasm: notAvailable("initNodeWasm"),
-  loadGoWasmFromFile: notAvailable("loadGoWasmFromFile")
-};
-var isNode = typeof process !== "undefined" && !!process.versions?.node;
-var isBrowser4 = typeof window !== "undefined";
-var serverModules = createLazyLoader(
-  () => Promise.all([
-    Promise.resolve().then(() => (init_server(), server_exports)),
-    Promise.resolve().then(() => (init_utils(), utils_exports)),
-    Promise.resolve().then(() => (init_templates(), templates_exports)),
-    Promise.resolve().then(() => (init_server_renderer2(), server_renderer_exports))
-  ]).then(([server, utils, templates, renderer]) => ({
-    ...server,
-    ...utils,
-    ...templates,
-    ...renderer
-  })),
-  isNode && !isBrowser4 ? serverNotFound : serverNotFound
-);
-var lazy = (name) => (...args) => serverModules[name](...args);
-var createServer2 = lazy("createServer");
-var createDevServer2 = lazy("createDevServer");
-var createProductionServer2 = lazy("createProductionServer");
-var BaraqexServer = serverModules.Server;
-var Database2 = serverModules.Database;
-var AuthService2 = serverModules.AuthService;
-var ApiRouter2 = serverModules.ApiRouter;
-var requestLogger2 = lazy("requestLogger");
-var errorHandler2 = lazy("errorHandler");
-var notFoundHandler2 = lazy("notFoundHandler");
-var rateLimit2 = lazy("rateLimit");
-var initNodeWasm3 = lazy("initNodeWasm");
-var loadGoWasmFromFile2 = lazy("loadGoWasmFromFile");
-var hashString2 = lazy("hashString");
-var getPagination2 = lazy("getPagination");
-var sendSuccess2 = lazy("sendSuccess");
-var sendError2 = lazy("sendError");
-var validateFields2 = lazy("validateFields");
-var validateFileUpload2 = lazy("validateFileUpload");
-var getEnvironmentInfo2 = lazy("getEnvironmentInfo");
-var isDirectoryEmpty2 = lazy("isDirectoryEmpty");
-var ensureDirectory2 = lazy("ensureDirectory");
-var writeJsonFile2 = lazy("writeJsonFile");
-var readJsonFile2 = lazy("readJsonFile");
-var renderComponent2 = lazy("renderComponent");
 export {
-  ApiRouter2 as ApiRouter,
+  ApiRouter,
   AuthError,
-  AuthService2 as AuthService,
+  AuthService,
   BaraqexError,
-  BaraqexServer,
+  Server as BaraqexServer,
   Component,
   ConfigError,
-  Database2 as Database,
+  Database,
   DatabaseError,
   Fragment,
   LifecycleEvents,
@@ -3980,14 +3611,14 @@ export {
   createAction,
   createClassComponent,
   createContext,
-  createDevServer2 as createDevServer,
+  createDevServer,
   createElement,
   createElementSync,
   createEventBus,
-  createProductionServer2 as createProductionServer,
+  createProductionServer,
   createRoot,
   createRootState,
-  createServer2 as createServer,
+  createServer,
   createSlice,
   createStore,
   debounce,
@@ -4014,8 +3645,8 @@ export {
   emitStoreBeforeAction,
   emitStoreError,
   emitStoreInitialized,
-  ensureDirectory2 as ensureDirectory,
-  errorHandler2 as errorHandler,
+  ensureDirectory,
+  errorHandler,
   escapeHtml2 as escapeHtml,
   eventBus,
   fallbackRenderToString,
@@ -4023,21 +3654,21 @@ export {
   formatDate,
   generateDocument2 as generateDocument,
   generateErrorPage2 as generateErrorPage,
-  generateLoadingPage2 as generateLoadingPage,
-  generateToken2 as generateToken,
+  generateLoadingPage,
+  generateToken,
   get,
   getContextValue,
   getCurrentRoot,
-  getEnvironmentInfo2 as getEnvironmentInfo,
+  getEnvironmentInfo,
   getIsBatching,
-  getPagination2 as getPagination,
+  getPagination,
   getWasmFunctions,
   groupBy,
   hasRoot,
-  hashString2 as hashString,
+  hashString,
   hydrate,
-  initNodeWasm3 as initNodeWasm,
-  isDirectoryEmpty2 as isDirectoryEmpty,
+  initNodeWasm,
+  isDirectoryEmpty,
   isEmpty,
   isWasmReady,
   jsx,
@@ -4045,10 +3676,10 @@ export {
   jsxs,
   kebabCase,
   loadGoWasm,
-  loadGoWasmFromFile2 as loadGoWasmFromFile,
+  loadGoWasmFromFile,
   logger,
   memoize,
-  notFoundHandler2 as notFoundHandler,
+  notFoundHandler,
   omit,
   onAppDestroyed,
   onAppError,
@@ -4070,18 +3701,18 @@ export {
   patterns,
   pick,
   prepareRender,
-  rateLimit2 as rateLimit,
-  readJsonFile2 as readJsonFile,
+  rateLimit,
+  readJsonFile,
   render,
-  renderComponent2 as renderComponent,
+  renderComponent,
   renderToStream,
   renderToString,
   renderToStringWithData,
-  requestLogger2 as requestLogger,
+  requestLogger,
   retry,
   safeJsonParse2 as safeJsonParse,
-  sendError2 as sendError,
-  sendSuccess2 as sendSuccess,
+  sendError,
+  sendSuccess,
   set,
   setCurrentRoot,
   shallowEqual,
@@ -4114,9 +3745,9 @@ export {
   useState,
   useStore,
   uuid,
-  validateFields2 as validateFields,
-  validateFileUpload2 as validateFileUpload,
+  validateFields,
+  validateFileUpload,
   withErrorHandling,
-  writeJsonFile2 as writeJsonFile
+  writeJsonFile
 };
 //# sourceMappingURL=index.js.map