baraqex 1.0.49 → 1.0.51

package/dist/server.js

@@ -1,7 +1,4 @@
 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) {
@@ -9,116 +6,524 @@ 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 });
 };
-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 });
+
+// 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}`);
+    }
   }
-  return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 
-// 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.");
+// src/server/auth.ts
+var AuthService = class {
+  constructor(config) {
+    this.config = {
+      expiresIn: "24h",
+      ...config
+    };
   }
-  try {
-    if (!window.Go) {
-      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
+  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;
     }
-    if (options.debug) {
-      console.log("[WASM] Loading WASM from:", wasmUrl);
+  }
+  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;
     }
-    const response = await fetch(wasmUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch WASM file: ${response.status}`);
+  }
+  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;
     }
-    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...");
+  }
+  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;
     }
-    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}`);
+  }
+  // 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;
         }
       }
-    }
-    const wasmInstance = {
-      instance: wasmModule.instance,
-      module: wasmModule,
-      exports: wasmModule.instance.exports,
-      functions
+      next();
     };
-    if (options.onLoad) {
-      options.onLoad(wasmInstance);
+  }
+  // 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);
     }
-    if (options.debug) {
-      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
+    return null;
+  }
+};
+
+// 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;
     }
-    return wasmInstance;
-  } catch (error) {
-    console.error("[WASM] Error loading Go WASM module:", error);
-    throw error;
   }
-}
-function callWasmFunction(funcName, ...args) {
-  if (typeof window === "undefined") {
-    throw new Error("callWasmFunction() is for browser use only.");
+  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;
+      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");
   }
-  const func = window[funcName];
-  if (typeof func !== "function") {
-    throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
+  wrapHandler(handler) {
+    return async (req, res, next) => {
+      try {
+        await handler(req, res, next);
+      } catch (error) {
+        next(error);
+      }
+    };
   }
-  return func(...args);
+};
+
+// 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}`
+    }
+  });
+};
+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)
+        }
+      });
+    }
+    return next();
+  };
 }
-function isWasmReady() {
-  if (typeof window === "undefined") {
-    return false;
+
+// 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);
+  } catch (error) {
+    return fallback;
   }
-  return !!(window.Go && Object.keys(window).some(
-    (key) => key.startsWith("go") && typeof window[key] === "function"
-  ));
 }
-function getWasmFunctions() {
-  if (typeof window === "undefined") {
-    return [];
+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));
   }
-  return Object.keys(window).filter(
-    (key) => key.startsWith("go") && typeof window[key] === "function"
-  );
+  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 useGoWasm(wasmUrl, options = {}) {
-  if (typeof window === "undefined") {
-    throw new Error("useGoWasm() is for browser use only.");
+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 {
-    loadWasm: () => loadGoWasm(wasmUrl, options),
-    callFunction: callWasmFunction,
-    isReady: isWasmReady,
-    getFunctions: getWasmFunctions
+    nodeVersion: process.version,
+    platform: process.platform,
+    arch: process.arch,
+    memory: process.memoryUsage(),
+    uptime: process.uptime(),
+    env: process.env.NODE_ENV || "development"
   };
 }
-var init_wasm = __esm({
-  "src/wasm.ts"() {
-    "use strict";
+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;
+  }
+}
 
 // src/server/templates.ts
 var templates_exports = {};
@@ -312,762 +717,13 @@ 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";
-async function initNodeWasm2() {
+var initialized = false;
+async function initNodeWasm() {
   if (initialized)
     return;
   try {
@@ -1131,9 +787,9 @@ You can get it from: https://github.com/golang/go/blob/master/misc/wasm/wasm_exe
 Searched paths: ${possiblePaths.join(", ")}`
   );
 }
-async function loadGoWasmFromFile2(wasmFilePath, options = {}) {
+async function loadGoWasmFromFile(wasmFilePath, options = {}) {
   try {
-    await initNodeWasm2();
+    await initNodeWasm();
     if (options.debug) {
       console.log("[WASM] Loading WASM from file:", wasmFilePath);
     }
@@ -1206,55 +862,8 @@ async function loadGoWasmFromFile2(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);
@@ -1265,349 +874,276 @@ function getComponentName(filePath, pagesDir) {
     return "";
   }
 }
-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;
-    });
+var Server = class {
+  constructor(config = {}) {
+    this.server = null;
+    this.db = null;
+    this.auth = null;
+    this.config = {
+      port: 3e3,
+      apiDir: "./api",
+      pagesDir: "./pages",
+      staticDir: "./public",
+      enableCors: true,
+      ...config
+    };
+    this.initializeApp();
   }
-  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;
-        }
+  async initializeApp() {
+    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 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");
+          const cors = await import("cors");
+          this.app.use(cors.default(this.config.corsOptions));
         } 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;
+          console.warn("CORS not available - install with: npm install cors @types/cors");
         }
       }
-      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);
+      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());
       }
-      generateApiDocs() {
-        const apiDir = path4.resolve(process.cwd(), this.config.apiDir);
-        const docs = { endpoints: [] };
-        if (fs4.existsSync(apiDir)) {
-          this.scanApiDirectory(apiDir, "", docs.endpoints);
-        }
-        return docs;
+      const staticPath = path4.resolve(process.cwd(), this.config.staticDir);
+      if (fs4.existsSync(staticPath)) {
+        this.app.use(express.default.static(staticPath));
       }
-      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)
-            });
-          }
-        }
+      this.setupApiRoutes();
+      this.setupPageRoutes();
+      this.app.use(notFoundHandler);
+      this.app.use(errorHandler);
+    } catch (error) {
+      if (error.code === "MODULE_NOT_FOUND" && error.message.includes("express")) {
+        throw new Error("Express not installed. Run: npm install express @types/express");
       }
-      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}`;
+      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)
+        });
       }
-      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 [];
-        }
+    }
+  }
+  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);
       }
-      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
+        };
       }
-      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, "Server error", error instanceof Error ? error : new Error("Unknown error")),
-            statusCode: 500
-          };
-        }
+      let normalizedPath = routePath;
+      if (!normalizedPath.startsWith("/")) {
+        normalizedPath = "/" + normalizedPath;
       }
-      getExpressApp() {
-        return this.app;
+      if (normalizedPath === "/") {
+        normalizedPath = "/index";
       }
-      getDatabase() {
-        return this.db;
+      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;
+        }
       }
-      getAuth() {
-        return this.auth;
+      if (!pagePath) {
+        return {
+          html: generateErrorPage(404, `Page not found: ${normalizedPath}`),
+          statusCode: 404
+        };
       }
-      async start() {
-        while (!this.initialized) {
-          await new Promise((resolve) => setTimeout(resolve, 50));
+      try {
+        const pageModule = await import(pagePath);
+        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
+          };
         }
-        return new Promise((resolve, reject) => {
-          if (!this.app) {
-            reject(new Error("Server not initialized. Express app is missing."));
-            return;
+        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;
           }
-          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);
-          });
+        } 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
+        };
       }
-      stop() {
-        return new Promise((resolve, reject) => {
-          if (!this.server) {
-            return resolve();
-          }
-          this.server.close((err) => {
-            if (err)
-              return reject(err);
-            this.server = null;
-            resolve();
-          });
-        });
+    } 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;
+  }
+  start() {
+    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();
       }
-      restart() {
-        return this.stop().then(() => this.start());
+      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 });
       }
-      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 = `
+      const clientJsPath = path4.join(staticDir, "client.js");
+      if (!fs4.existsSync(clientJsPath)) {
+        const clientJsContent = `
           // Auto-generated hydration script
           import { hydrate } from 'frontend-hamroun';
           
@@ -1624,88 +1160,119 @@ var init_server = __esm({
             });
           });
         `;
-            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);
+        fs4.writeFileSync(clientJsPath, clientJsContent);
       }
-    };
-    renderComponent2 = async (Component, props = {}) => {
+    }
+  }
+  registerPlugin(plugin) {
+    plugin(this);
+  }
+  addShutdownHandler() {
+    const gracefulShutdown = async () => {
+      console.log("Received shutdown signal, closing server...");
       try {
-        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
-        };
+        await this.stop();
+        if (this.db) {
+          await this.db.disconnect();
+        }
+        console.log("Server shut down gracefully");
+        process.exit(0);
       } 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
-        };
+        console.error("Error during shutdown:", error);
+        process.exit(1);
       }
     };
-    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
+    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
     };
   }
-});
-init_server();
-var export_renderToString = src_exports.renderToString;
+};
+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
+};
 export {
-  ApiRouter2 as ApiRouter,
-  AuthService2 as AuthService,
-  Database2 as Database,
+  ApiRouter,
+  AuthService,
+  Database,
   Server,
-  createDevServer2 as createDevServer,
-  createProductionServer2 as createProductionServer,
-  createServer2 as createServer,
+  createDevServer,
+  createProductionServer,
+  createServer,
   server_default as default,
   ensureDirectory,
-  errorHandler2 as errorHandler,
+  errorHandler,
   generateDocument,
   generateErrorPage,
   generateLoadingPage,
@@ -1714,16 +1281,16 @@ export {
   getPagination,
   getRequestIp,
   hashString,
-  initNodeWasm2 as initNodeWasm,
+  initNodeWasm,
   isDirectoryEmpty,
-  loadGoWasmFromFile2 as loadGoWasmFromFile,
-  notFoundHandler2 as notFoundHandler,
+  loadGoWasmFromFile,
+  notFoundHandler,
   parseCookies,
-  rateLimit2 as rateLimit,
+  rateLimit,
   readJsonFile,
-  renderComponent2 as renderComponent,
-  export_renderToString as renderToString,
-  requestLogger2 as requestLogger,
+  renderComponent,
+  renderToString,
+  requestLogger,
   safeJsonParse,
   sendError,
   sendSuccess,