baraqex 1.0.47 → 1.0.49

package/dist/server.js

@@ -1,4 +1,7 @@
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -6,524 +9,116 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+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 });
 };
-
-// src/server/index.ts
-import path4 from "path";
-import fs4 from "fs";
-import { renderToString } from "frontend-hamroun";
-
-// src/server/database.ts
-var Database = class {
-  constructor(config) {
-    this.mongoClient = null;
-    this.mongoDb = null;
-    this.mysqlPool = null;
-    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 = class {
-  constructor(config) {
-    this.config = {
-      expiresIn: "24h",
-      ...config
-    };
-  }
-  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;
-    }
-  }
-  generateToken(user) {
-    try {
-      const jwt = __require("jsonwebtoken");
-      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
-      );
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error("jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken");
-      }
-      throw error;
-    }
-  }
-  verifyToken(token) {
-    try {
-      const jwt = __require("jsonwebtoken");
-      return jwt.verify(token, this.config.secret);
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error("jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken");
-      }
-      return null;
-    }
-  }
-  // Express middleware for authentication
-  initialize() {
-    return (req, res, next) => {
-      const token = this.extractToken(req);
-      if (token) {
-        const decoded = this.verifyToken(token);
-        if (decoded) {
-          req.user = decoded;
-        }
-      }
-      next();
-    };
-  }
-  // Express middleware for requiring authentication
-  requireAuth() {
-    return (req, res, next) => {
-      if (!req.user) {
-        return res.status(401).json({ message: "Unauthorized" });
-      }
-      return next();
-    };
-  }
-  // Express middleware for requiring specific roles
-  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;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
+  return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-// src/server/api-router.ts
-import path from "path";
-import fs from "fs";
-import { pathToFileURL } from "url";
-var ApiRouter = class {
-  constructor(apiDir, auth = null) {
-    this.router = null;
-    this.apiDir = path.resolve(process.cwd(), apiDir);
-    this.auth = auth;
-    this.initializeRouter();
-  }
-  async initializeRouter() {
-    try {
-      const express = await import("express");
-      this.router = express.default.Router();
-      this.setupRoutes();
-    } catch (error) {
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new Error("Express not installed. Run: npm install express @types/express");
-      }
-      throw error;
-    }
+// 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.");
   }
-  setupRoutes() {
-    if (!fs.existsSync(this.apiDir)) {
-      console.log(`API directory not found: ${this.apiDir}`);
-      return;
+  try {
+    if (!window.Go) {
+      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
     }
-    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);
-      }
+    if (options.debug) {
+      console.log("[WASM] Loading WASM from:", wasmUrl);
     }
-  }
-  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 response = await fetch(wasmUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch WASM file: ${response.status}`);
     }
-    const paramMatch = baseName.match(/^\[(.+)\]$/);
-    if (paramMatch) {
-      return `${routePrefix}/:${paramMatch[1]}`;
+    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...");
     }
-    return `${routePrefix}/${baseName}`;
-  }
-  async registerRoute(filePath, routePath) {
-    try {
-      const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(filePath);
-      const fileUrl = pathToFileURL(absolutePath).href;
-      if (process.platform === "win32") {
-        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)
-            );
-          }
-        }
-      } else {
-        const routeModule = await import(fileUrl);
-        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)
-            );
-          }
+    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}`);
         }
       }
-    } 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);
-      }
+    const wasmInstance = {
+      instance: wasmModule.instance,
+      module: wasmModule,
+      exports: wasmModule.instance.exports,
+      functions
     };
-  }
-};
-
-// 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 } : {}
-    }
-  });
-};
-var notFoundHandler = (req, res) => {
-  res.status(404).json({
-    error: {
-      message: `Not Found - ${req.method} ${req.url}`
+    if (options.onLoad) {
+      options.onLoad(wasmInstance);
     }
-  });
-};
-function rateLimit(options) {
-  const requests = /* @__PURE__ */ new Map();
-  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)
-        }
-      });
+    if (options.debug) {
+      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
     }
-    return next();
-  };
-}
-
-// 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 crypto from "crypto";
-import fs2 from "fs/promises";
-import path2 from "path";
-function safeJsonParse(json, fallback) {
-  try {
-    return JSON.parse(json);
+    return wasmInstance;
   } catch (error) {
-    return fallback;
-  }
-}
-function generateToken(length = 32) {
-  return crypto.randomBytes(length).toString("hex");
-}
-function hashString(input, salt = "") {
-  return crypto.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));
+    console.error("[WASM] Error loading Go WASM module:", error);
+    throw error;
   }
-  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`
-    };
+function callWasmFunction(funcName, ...args) {
+  if (typeof window === "undefined") {
+    throw new Error("callWasmFunction() is for browser use only.");
   }
-  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 func = window[funcName];
+  if (typeof func !== "function") {
+    throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
   }
-  return { valid: true };
+  return func(...args);
 }
-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;
+function isWasmReady() {
+  if (typeof window === "undefined") {
+    return false;
   }
+  return !!(window.Go && Object.keys(window).some(
+    (key) => key.startsWith("go") && typeof window[key] === "function"
+  ));
 }
-async function ensureDirectory(dirPath) {
-  try {
-    await fs2.access(dirPath);
-  } catch (error) {
-    await fs2.mkdir(dirPath, { recursive: true });
+function getWasmFunctions() {
+  if (typeof window === "undefined") {
+    return [];
   }
+  return Object.keys(window).filter(
+    (key) => key.startsWith("go") && typeof window[key] === "function"
+  );
 }
-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;
+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
+  };
 }
+var init_wasm = __esm({
+  "src/wasm.ts"() {
+    "use strict";
+  }
+});
 
 // src/server/templates.ts
 var templates_exports = {};
@@ -717,13 +312,762 @@ function generateLoadingPage(message = "Loading...") {
 function escapeHtml(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/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 fs from "fs/promises";
+import path 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 fs.readdir(dirPath);
+    return files.length === 0;
+  } catch (error) {
+    return true;
+  }
+}
+async function ensureDirectory(dirPath) {
+  try {
+    await fs.access(dirPath);
+  } catch (error) {
+    await fs.mkdir(dirPath, { recursive: true });
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await ensureDirectory(path.dirname(filePath));
+  await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+async function readJsonFile(filePath, defaultValue) {
+  try {
+    const data = await fs.readFile(filePath, "utf8");
+    return safeJsonParse(data, defaultValue);
+  } catch (error) {
+    return defaultValue;
+  }
+}
+var init_utils = __esm({
+  "src/server/utils.ts"() {
+    "use strict";
+  }
+});
+
+// src/server-renderer.ts
+var server_renderer_exports = {};
+__export(server_renderer_exports, {
+  renderToString: () => renderToString
+});
+function renderToString(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_renderer = __esm({
+  "src/server-renderer.ts"() {
+    "use strict";
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ApiRouter: () => ApiRouter,
+  AuthService: () => AuthService,
+  BaraqexServer: () => BaraqexServer,
+  Database: () => Database,
+  baraqexRenderToString: () => baraqexRenderToString,
+  callWasmFunction: () => callWasmFunction,
+  createBaraqexServer: () => createBaraqexServer,
+  createDevServer: () => createDevServer,
+  createProductionServer: () => createProductionServer,
+  createServer: () => createServer,
+  ensureDirectory: () => ensureDirectory2,
+  errorHandler: () => errorHandler,
+  generateDocument: () => generateDocument,
+  generateErrorPage: () => generateErrorPage,
+  generateLoadingPage: () => generateLoadingPage,
+  generateToken: () => generateToken2,
+  getEnvironmentInfo: () => getEnvironmentInfo2,
+  getPagination: () => getPagination2,
+  getWasmFunctions: () => getWasmFunctions,
+  hashString: () => hashString2,
+  initNodeWasm: () => initNodeWasm,
+  isDirectoryEmpty: () => isDirectoryEmpty2,
+  isWasmReady: () => isWasmReady,
+  loadGoWasm: () => loadGoWasm,
+  loadGoWasmFromFile: () => loadGoWasmFromFile,
+  notFoundHandler: () => notFoundHandler,
+  rateLimit: () => rateLimit,
+  readJsonFile: () => readJsonFile2,
+  renderComponent: () => renderComponent,
+  requestLogger: () => requestLogger,
+  safeJsonParse: () => safeJsonParse2,
+  sendError: () => sendError2,
+  sendSuccess: () => sendSuccess2,
+  useGoWasm: () => useGoWasm,
+  validateFields: () => validateFields2,
+  validateFileUpload: () => validateFileUpload2,
+  writeJsonFile: () => writeJsonFile2
+});
+import * as frontend_hamroun_star from "frontend-hamroun";
+function createBaraqexServer(options = {}) {
+  return new Promise((resolve, reject) => {
+    const checkServer = () => {
+      if (createDevServer && typeof createDevServer === "function") {
+        resolve(createDevServer(options));
+      } else if (isNode) {
+        setTimeout(checkServer, 100);
+      } else {
+        reject(new Error("Server functionality not available in browser environment"));
+      }
+    };
+    checkServer();
+  });
+}
+var isNode, isBrowser, BaraqexServer, createServer, createDevServer, createProductionServer, renderComponent, Database, AuthService, ApiRouter, requestLogger, errorHandler, notFoundHandler, rateLimit, initNodeWasm, loadGoWasmFromFile, safeJsonParse2, generateToken2, hashString2, getPagination2, sendSuccess2, sendError2, validateFields2, validateFileUpload2, getEnvironmentInfo2, isDirectoryEmpty2, ensureDirectory2, writeJsonFile2, readJsonFile2, baraqexRenderToString;
+var init_src = __esm({
+  "src/index.ts"() {
+    "use strict";
+    __reExport(src_exports, frontend_hamroun_star);
+    init_wasm();
+    init_templates();
+    isNode = typeof process !== "undefined" && process.versions?.node;
+    isBrowser = typeof window !== "undefined";
+    BaraqexServer = null;
+    createServer = null;
+    createDevServer = null;
+    createProductionServer = null;
+    renderComponent = null;
+    Database = null;
+    AuthService = null;
+    ApiRouter = null;
+    requestLogger = null;
+    errorHandler = null;
+    notFoundHandler = null;
+    rateLimit = null;
+    initNodeWasm = null;
+    loadGoWasmFromFile = null;
+    safeJsonParse2 = (json, fallback) => {
+      try {
+        return JSON.parse(json);
+      } catch {
+        return fallback;
+      }
+    };
+    generateToken2 = (length = 32) => {
+      const array = new Uint8Array(length);
+      if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+        crypto.getRandomValues(array);
+      } else {
+        for (let i = 0; i < array.length; i++) {
+          array[i] = Math.floor(Math.random() * 256);
+        }
+      }
+      return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+    };
+    hashString2 = null;
+    getPagination2 = null;
+    sendSuccess2 = null;
+    sendError2 = null;
+    validateFields2 = null;
+    validateFileUpload2 = null;
+    getEnvironmentInfo2 = null;
+    isDirectoryEmpty2 = null;
+    ensureDirectory2 = null;
+    writeJsonFile2 = null;
+    readJsonFile2 = null;
+    baraqexRenderToString = null;
+    if (isNode && !isBrowser) {
+      Promise.resolve().then(async () => {
+        try {
+          try {
+            await import("express");
+          } catch {
+            console.warn("Express not available - server functionality disabled");
+            return;
+          }
+          const serverModule = await Promise.resolve().then(() => (init_server(), server_exports));
+          Object.assign(exports, {
+            BaraqexServer: serverModule.Server,
+            createServer: serverModule.createServer,
+            createDevServer: serverModule.createDevServer,
+            createProductionServer: serverModule.createProductionServer,
+            renderComponent: serverModule.renderComponent,
+            Database: serverModule.Database,
+            AuthService: serverModule.AuthService,
+            ApiRouter: serverModule.ApiRouter,
+            requestLogger: serverModule.requestLogger,
+            errorHandler: serverModule.errorHandler,
+            notFoundHandler: serverModule.notFoundHandler,
+            rateLimit: serverModule.rateLimit,
+            initNodeWasm: serverModule.initNodeWasm,
+            loadGoWasmFromFile: serverModule.loadGoWasmFromFile
+          });
+          BaraqexServer = serverModule.Server;
+          createServer = serverModule.createServer;
+          createDevServer = serverModule.createDevServer;
+          createProductionServer = serverModule.createProductionServer;
+          renderComponent = serverModule.renderComponent;
+          Database = serverModule.Database;
+          AuthService = serverModule.AuthService;
+          ApiRouter = serverModule.ApiRouter;
+          requestLogger = serverModule.requestLogger;
+          errorHandler = serverModule.errorHandler;
+          notFoundHandler = serverModule.notFoundHandler;
+          rateLimit = serverModule.rateLimit;
+          initNodeWasm = serverModule.initNodeWasm;
+          loadGoWasmFromFile = serverModule.loadGoWasmFromFile;
+          const utilsModule = await Promise.resolve().then(() => (init_utils(), utils_exports));
+          safeJsonParse2 = utilsModule.safeJsonParse;
+          generateToken2 = utilsModule.generateToken;
+          hashString2 = utilsModule.hashString;
+          getPagination2 = utilsModule.getPagination;
+          sendSuccess2 = utilsModule.sendSuccess;
+          sendError2 = utilsModule.sendError;
+          validateFields2 = utilsModule.validateFields;
+          validateFileUpload2 = utilsModule.validateFileUpload;
+          getEnvironmentInfo2 = utilsModule.getEnvironmentInfo;
+          isDirectoryEmpty2 = utilsModule.isDirectoryEmpty;
+          ensureDirectory2 = utilsModule.ensureDirectory;
+          writeJsonFile2 = utilsModule.writeJsonFile;
+          readJsonFile2 = utilsModule.readJsonFile;
+          const rendererModule = await Promise.resolve().then(() => (init_server_renderer(), server_renderer_exports));
+          baraqexRenderToString = rendererModule.renderToString;
+          console.log("\u2705 Baraqex server modules loaded successfully");
+        } catch (error) {
+          console.warn("Server modules not available:", error.message);
+        }
+      });
+    }
+    console.log("Baraqex - powered by Frontend Hamroun Framework with additional utilities");
+  }
+});
+
+// src/server/database.ts
+var Database2;
+var init_database = __esm({
+  "src/server/database.ts"() {
+    "use strict";
+    Database2 = class {
+      constructor(config) {
+        this.mongoClient = null;
+        this.mongoDb = null;
+        this.mysqlPool = null;
+        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 AuthService2;
+var init_auth = __esm({
+  "src/server/auth.ts"() {
+    "use strict";
+    AuthService2 = class {
+      constructor(config) {
+        this.config = {
+          expiresIn: "24h",
+          ...config
+        };
+      }
+      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;
+        }
+      }
+      generateToken(user) {
+        try {
+          const jwt = __require("jsonwebtoken");
+          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
+          );
+        } catch (error) {
+          if (error.code === "MODULE_NOT_FOUND") {
+            throw new Error("jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken");
+          }
+          throw error;
+        }
+      }
+      verifyToken(token) {
+        try {
+          const jwt = __require("jsonwebtoken");
+          return jwt.verify(token, this.config.secret);
+        } catch (error) {
+          if (error.code === "MODULE_NOT_FOUND") {
+            throw new Error("jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken");
+          }
+          return null;
+        }
+      }
+      // Express middleware for authentication
+      initialize() {
+        return (req, res, next) => {
+          const token = this.extractToken(req);
+          if (token) {
+            const decoded = this.verifyToken(token);
+            if (decoded) {
+              req.user = decoded;
+            }
+          }
+          next();
+        };
+      }
+      // Express middleware for requiring authentication
+      requireAuth() {
+        return (req, res, next) => {
+          if (!req.user) {
+            return res.status(401).json({ message: "Unauthorized" });
+          }
+          return next();
+        };
+      }
+      // Express middleware for requiring specific roles
+      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 path2 from "path";
+import fs2 from "fs";
+import { pathToFileURL } from "url";
+var ApiRouter2;
+var init_api_router = __esm({
+  "src/server/api-router.ts"() {
+    "use strict";
+    ApiRouter2 = class {
+      constructor(apiDir, auth = null) {
+        this.router = null;
+        this.apiDir = path2.resolve(process.cwd(), apiDir);
+        this.auth = auth;
+        this.initializeRouter();
+      }
+      async initializeRouter() {
+        try {
+          const express = await import("express");
+          this.router = express.default.Router();
+          this.setupRoutes();
+        } catch (error) {
+          if (error.code === "MODULE_NOT_FOUND") {
+            throw new Error("Express not installed. Run: npm install express @types/express");
+          }
+          throw error;
+        }
+      }
+      setupRoutes() {
+        if (!fs2.existsSync(this.apiDir)) {
+          console.log(`API directory not found: ${this.apiDir}`);
+          return;
+        }
+        this.scanDirectory(this.apiDir, "");
+      }
+      scanDirectory(dirPath, routePrefix) {
+        const entries = fs2.readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path2.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 = path2.basename(filename, path2.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 = path2.isAbsolute(filePath) ? filePath : path2.resolve(filePath);
+          const fileUrl = pathToFileURL(absolutePath).href;
+          if (process.platform === "win32") {
+            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)
+                );
+              }
+            }
+          } else {
+            const routeModule = await import(fileUrl);
+            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 rateLimit2(options) {
+  const requests = /* @__PURE__ */ new Map();
+  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 requestLogger2, errorHandler2, notFoundHandler2;
+var init_middleware = __esm({
+  "src/server/middleware.ts"() {
+    "use strict";
+    requestLogger2 = (req, res, next) => {
+      console.log(`${(/* @__PURE__ */ new Date()).toISOString()} - ${req.method} ${req.url}`);
+      next();
+    };
+    errorHandler2 = (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 } : {}
+        }
+      });
+    };
+    notFoundHandler2 = (req, res) => {
+      res.status(404).json({
+        error: {
+          message: `Not Found - ${req.method} ${req.url}`
+        }
+      });
+    };
+  }
+});
 
 // 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() {
+async function initNodeWasm2() {
   if (initialized)
     return;
   try {
@@ -787,9 +1131,9 @@ You can get it from: https://github.com/golang/go/blob/master/misc/wasm/wasm_exe
 Searched paths: ${possiblePaths.join(", ")}`
   );
 }
-async function loadGoWasmFromFile(wasmFilePath, options = {}) {
+async function loadGoWasmFromFile2(wasmFilePath, options = {}) {
   try {
-    await initNodeWasm();
+    await initNodeWasm2();
     if (options.debug) {
       console.log("[WASM] Loading WASM from file:", wasmFilePath);
     }
@@ -862,8 +1206,55 @@ async function loadGoWasmFromFile(wasmFilePath, options = {}) {
     throw error;
   }
 }
+var initialized;
+var init_wasm2 = __esm({
+  "src/server/wasm.ts"() {
+    "use strict";
+    initialized = false;
+  }
+});
 
 // src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  ApiRouter: () => ApiRouter2,
+  AuthService: () => AuthService2,
+  Database: () => Database2,
+  Server: () => Server,
+  createDevServer: () => createDevServer2,
+  createProductionServer: () => createProductionServer2,
+  createServer: () => createServer2,
+  default: () => server_default,
+  ensureDirectory: () => ensureDirectory,
+  errorHandler: () => errorHandler2,
+  generateDocument: () => generateDocument,
+  generateErrorPage: () => generateErrorPage,
+  generateLoadingPage: () => generateLoadingPage,
+  generateToken: () => generateToken,
+  getEnvironmentInfo: () => getEnvironmentInfo,
+  getPagination: () => getPagination,
+  getRequestIp: () => getRequestIp,
+  hashString: () => hashString,
+  initNodeWasm: () => initNodeWasm2,
+  isDirectoryEmpty: () => isDirectoryEmpty,
+  loadGoWasmFromFile: () => loadGoWasmFromFile2,
+  notFoundHandler: () => notFoundHandler2,
+  parseCookies: () => parseCookies,
+  rateLimit: () => rateLimit2,
+  readJsonFile: () => readJsonFile,
+  renderComponent: () => renderComponent2,
+  renderToString: () => src_exports.renderToString,
+  requestLogger: () => requestLogger2,
+  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);
@@ -874,291 +1265,349 @@ function getComponentName(filePath, pagesDir) {
     return "";
   }
 }
-var Server = class {
-  constructor(config = {}) {
-    this.server = null;
-    this.db = null;
-    this.auth = null;
-    this.initialized = false;
-    this.config = {
-      port: 3e3,
-      apiDir: "./api",
-      pagesDir: "./pages",
-      staticDir: "./public",
-      enableCors: true,
-      ...config
-    };
+function createServer2(config = {}) {
+  return new Server(config);
+}
+function createDevServer2(options = {}) {
+  return new Server({
+    port: options.port || 3e3,
+    enableCors: options.enableCors !== false,
+    apiDir: "./src/api",
+    pagesDir: "./src/pages",
+    staticDir: "./public"
+  });
+}
+function createProductionServer2(config) {
+  const server = new Server({
+    ...config,
+    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;
+    });
   }
-  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) {
+  return cookies;
+}
+var Server, renderComponent2, server_default;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    init_src();
+    init_database();
+    init_auth();
+    init_api_router();
+    init_middleware();
+    init_utils();
+    init_templates();
+    init_wasm2();
+    init_wasm2();
+    init_utils();
+    init_templates();
+    init_database();
+    init_auth();
+    init_api_router();
+    init_middleware();
+    Server = class {
+      constructor(config = {}) {
+        this.server = null;
+        this.db = null;
+        this.auth = null;
+        this.initialized = false;
+        this.config = {
+          port: 3e3,
+          apiDir: "./api",
+          pagesDir: "./pages",
+          staticDir: "./public",
+          enableCors: true,
+          ...config
+        };
+        this.initializeApp().catch((error) => {
+          console.error("Failed to initialize server:", error);
+        });
+      }
+      async initializeApp() {
+        if (this.initialized) {
+          return;
+        }
         try {
-          const cors = await import("cors");
-          this.app.use(cors.default(this.config.corsOptions));
+          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 Database2(this.config.db);
+          }
+          if (this.config.auth) {
+            this.auth = new AuthService2({
+              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(notFoundHandler2);
+          this.app.use(errorHandler2);
+          this.initialized = true;
+          console.log("\u2705 Baraqex server initialized successfully");
         } catch (error) {
-          console.warn("CORS not available - install with: npm install cors @types/cors");
+          if (error.code === "MODULE_NOT_FOUND" && error.message.includes("express")) {
+            throw new Error("Express not installed. Run: npm install express @types/express");
+          }
+          throw error;
         }
       }
-      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;
-      console.log("Server initialized successfully");
-    } 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;
-    }
-  }
-  setupApiRoutes() {
-    const apiRouter = new ApiRouter(this.config.apiDir, this.auth);
-    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)
+      setupApiRoutes() {
+        const apiRouter = new ApiRouter2(this.config.apiDir, this.auth);
+        this.app.use("/api", requestLogger2, apiRouter.router);
+        this.app.get("/api-docs", (req, res) => {
+          const apiDocs = this.generateApiDocs();
+          res.json(apiDocs);
         });
       }
-    }
-  }
-  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;
+      generateApiDocs() {
+        const apiDir = path4.resolve(process.cwd(), this.config.apiDir);
+        const docs = { endpoints: [] };
+        if (fs4.existsSync(apiDir)) {
+          this.scanApiDirectory(apiDir, "", docs.endpoints);
+        }
+        return docs;
       }
-      if (normalizedPath === "/") {
-        normalizedPath = "/index";
+      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)
+            });
+          }
+        }
       }
-      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;
+      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}`;
       }
-      if (!pagePath) {
-        return {
-          html: generateErrorPage(404, `Page not found: ${normalizedPath}`),
-          statusCode: 404
-        };
+      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 [];
+        }
       }
-      try {
-        const pageModule = await import(pagePath);
-        if (!pageModule || !pageModule.default) {
-          throw new Error(`No default export found in ${pagePath}`);
+      setupPageRoutes() {
+        const pagesPath = path4.resolve(process.cwd(), this.config.pagesDir);
+        if (!fs4.existsSync(pagesPath)) {
+          return;
         }
-        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) {
+        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.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 renderComponent2(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, "Failed to render page", renderResult.error instanceof Error ? renderResult.error : new Error("Unknown error")),
+            html: generateErrorPage(500, "Server error", error instanceof Error ? 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) {
+      }
+      getExpressApp() {
+        return this.app;
+      }
+      getDatabase() {
+        return this.db;
+      }
+      getAuth() {
+        return this.auth;
+      }
+      async start() {
+        while (!this.initialized) {
+          await new Promise((resolve) => setTimeout(resolve, 50));
         }
-        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 new Promise((resolve, reject) => {
+          if (!this.app) {
+            reject(new Error("Server not initialized. Express app is missing."));
+            return;
+          }
+          this.server = this.app.listen(this.config.port, () => {
+            console.log(`\u{1F680} Server running at http://localhost:${this.config.port}`);
+            resolve();
+          });
+          this.server.on("error", (error) => {
+            reject(error);
+          });
         });
-        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() {
-    if (!this.initialized) {
-      await this.initializeApp();
-    }
-    return new Promise((resolve, reject) => {
-      if (!this.app) {
-        reject(new Error("Server not initialized. Express app is missing."));
-        return;
       }
-      this.server = this.app.listen(this.config.port, () => {
-        console.log(`Server running at http://localhost:${this.config.port}`);
-        resolve();
-      });
-      this.server.on("error", (error) => {
-        reject(error);
-      });
-    });
-  }
-  stop() {
-    return new Promise((resolve, reject) => {
-      if (!this.server) {
-        return 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();
+          });
+        });
       }
-      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 });
+      restart() {
+        return this.stop().then(() => this.start());
       }
-      const clientJsPath = path4.join(staticDir, "client.js");
-      if (!fs4.existsSync(clientJsPath)) {
-        const clientJsContent = `
+      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 'frontend-hamroun';
           
@@ -1175,119 +1624,88 @@ var Server = class {
             });
           });
         `;
-        fs4.writeFileSync(clientJsPath, clientJsContent);
+            fs4.writeFileSync(clientJsPath, clientJsContent);
+          }
+        }
       }
-    }
-  }
-  registerPlugin(plugin) {
-    plugin(this);
-  }
-  addShutdownHandler() {
-    const gracefulShutdown = async () => {
-      console.log("Received shutdown signal, closing server...");
+      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);
+      }
+    };
+    renderComponent2 = async (Component, props = {}) => {
       try {
-        await this.stop();
-        if (this.db) {
-          await this.db.disconnect();
-        }
-        console.log("Server shut down gracefully");
-        process.exit(0);
+        const { jsx, renderToString: renderToString3 } = await import("frontend-hamroun");
+        const element = jsx(Component, props);
+        const html = renderToString3(element);
+        return {
+          html: typeof html === "string" ? html : String(html),
+          success: true
+        };
       } catch (error) {
-        console.error("Error during shutdown:", error);
-        process.exit(1);
+        console.error("Error rendering component:", error);
+        return {
+          html: `<div class="error">Error rendering component: ${error instanceof Error ? error.message : "Unknown error"}</div>`,
+          success: false,
+          error
+        };
       }
     };
-    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;
-}
-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 renderComponent = async (Component, props = {}) => {
-  try {
-    const { jsx, renderToString: renderToString2 } = await import("frontend-hamroun");
-    const element = jsx(Component, props);
-    const html = renderToString2(element);
-    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: ${error instanceof Error ? error.message : "Unknown error"}</div>`,
-      success: false,
-      error
+    server_default = {
+      Server,
+      createServer: createServer2,
+      createDevServer: createDevServer2,
+      createProductionServer: createProductionServer2,
+      rateLimit: rateLimit2,
+      requestLogger: requestLogger2,
+      errorHandler: errorHandler2,
+      notFoundHandler: notFoundHandler2,
+      loadGoWasmFromFile: loadGoWasmFromFile2,
+      // Template utilities
+      templates: templates_exports,
+      // Server utilities
+      utils: utils_exports,
+      // Additional exports
+      renderComponent: renderComponent2,
+      renderToString: src_exports.renderToString,
+      getRequestIp,
+      parseCookies,
+      Database: Database2,
+      AuthService: AuthService2,
+      ApiRouter: ApiRouter2
     };
   }
-};
-var 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
-};
+});
+init_server();
+var export_renderToString = src_exports.renderToString;
 export {
-  ApiRouter,
-  AuthService,
-  Database,
+  ApiRouter2 as ApiRouter,
+  AuthService2 as AuthService,
+  Database2 as Database,
   Server,
-  createDevServer,
-  createProductionServer,
-  createServer,
+  createDevServer2 as createDevServer,
+  createProductionServer2 as createProductionServer,
+  createServer2 as createServer,
   server_default as default,
   ensureDirectory,
-  errorHandler,
+  errorHandler2 as errorHandler,
   generateDocument,
   generateErrorPage,
   generateLoadingPage,
@@ -1296,16 +1714,16 @@ export {
   getPagination,
   getRequestIp,
   hashString,
-  initNodeWasm,
+  initNodeWasm2 as initNodeWasm,
   isDirectoryEmpty,
-  loadGoWasmFromFile,
-  notFoundHandler,
+  loadGoWasmFromFile2 as loadGoWasmFromFile,
+  notFoundHandler2 as notFoundHandler,
   parseCookies,
-  rateLimit,
+  rateLimit2 as rateLimit,
   readJsonFile,
-  renderComponent,
-  renderToString,
-  requestLogger,
+  renderComponent2 as renderComponent,
+  export_renderToString as renderToString,
+  requestLogger2 as requestLogger,
   safeJsonParse,
   sendError,
   sendSuccess,