baraqex 1.0.76 → 2.0.1

package/dist/index.js

@@ -1,12 +1,6 @@
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-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) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -14,324 +8,387 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
-// node_modules/frontend-hamroun/dist/index.mjs
-function batchUpdates(fn) {
-  if (isBatching) {
-    queue.push(fn);
-    return;
-  }
-  isBatching = true;
-  try {
-    fn();
-    while (queue.length > 0) {
-      const nextFn = queue.shift();
-      nextFn == null ? void 0 : nextFn();
+// src/core/context.ts
+function createContext(defaultValue) {
+  const id = Symbol("context");
+  contextStacks.set(id, []);
+  const context = {
+    Provider: ({ value, children }) => {
+      const stack = contextStacks.get(id);
+      stack.push(value);
+      const result = children;
+      stack.pop();
+      return result;
+    },
+    Consumer: ({ children }) => {
+      const stack = contextStacks.get(id);
+      const value = stack && stack.length > 0 ? stack[stack.length - 1] : defaultValue;
+      return children(value);
+    },
+    _id: id,
+    _defaultValue: defaultValue,
+    useSelector: (selector) => {
+      const stack = contextStacks.get(id);
+      const value = stack && stack.length > 0 ? stack[stack.length - 1] : defaultValue;
+      return selector(value);
     }
-  } finally {
-    isBatching = false;
+  };
+  return context;
+}
+function useContext(context) {
+  const stack = contextStacks.get(context._id);
+  if (stack && stack.length > 0) {
+    return stack[stack.length - 1];
   }
+  return context._defaultValue;
 }
-function setRenderCallback(callback, element, container) {
-  globalRenderCallback = callback;
-  globalContainer = container;
-  currentElement = element;
+function getContextValue(context) {
+  return useContext(context);
+}
+var contextStacks;
+var init_context = __esm({
+  "src/core/context.ts"() {
+    "use strict";
+    contextStacks = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/core/hooks.ts
+function createRootState() {
+  return {
+    id: ++rootIdCounter,
+    components: /* @__PURE__ */ new Map(),
+    nextComponentId: 0,
+    renderCallback: null,
+    container: null,
+    currentElement: null
+  };
 }
-function prepareRender() {
-  currentRender++;
-  stateIndices.set(currentRender, 0);
-  return currentRender;
+function prepareRender(root, componentId) {
+  if (root) {
+    currentRoot = root;
+  }
+  if (componentId !== void 0) {
+    currentComponentId = componentId;
+  } else if (currentRoot) {
+    currentComponentId = ++currentRoot.nextComponentId;
+  }
+  hookIndex = 0;
+  return currentComponentId || 0;
 }
 function finishRender() {
-  if (isServer) {
-    serverStates.delete(currentRender);
+  currentComponentId = null;
+}
+function getCurrentRoot() {
+  return currentRoot;
+}
+function setCurrentRoot(root) {
+  currentRoot = root;
+}
+function getComponentState(root, compId) {
+  let state = root.components.get(compId);
+  if (!state) {
+    state = { states: [], effects: [], memos: [], refs: [] };
+    root.components.set(compId, state);
   }
-  currentRender = 0;
+  return state;
+}
+function setRenderCallback(callback, element, container) {
+  if (!currentRoot)
+    return;
+  currentRoot.renderCallback = callback;
+  currentRoot.currentElement = element;
+  currentRoot.container = container;
 }
 function useState(initial) {
-  if (!currentRender) {
-    throw new Error("useState must be called within a render");
-  }
-  if (isServer) {
-    if (!serverStates.has(currentRender)) {
-      serverStates.set(currentRender, /* @__PURE__ */ new Map());
-    }
-    const componentState = serverStates.get(currentRender);
-    const index2 = stateIndices.get(currentRender) || 0;
-    if (!componentState.has(index2)) {
-      componentState.set(index2, initial);
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    if (isServer) {
+      return [initial, () => {
+      }];
     }
-    const state2 = componentState.get(index2);
-    const setState2 = (newValue) => {
-    };
-    stateIndices.set(currentRender, index2 + 1);
-    return [state2, setState2];
-  }
-  if (!states.has(currentRender)) {
-    states.set(currentRender, []);
+    console.warn("useState called outside of render context");
+    return [initial, () => {
+    }];
   }
-  const componentStates = states.get(currentRender);
-  const index = stateIndices.get(currentRender);
-  if (index >= componentStates.length) {
-    componentStates.push(initial);
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  if (currentIndex >= compState.states.length) {
+    compState.states.push(initial);
   }
-  const state = componentStates[index];
+  const state = compState.states[currentIndex];
   const setState = (newValue) => {
-    const nextValue = typeof newValue === "function" ? newValue(componentStates[index]) : newValue;
-    if (componentStates[index] === nextValue)
+    const currentState = compState.states[currentIndex];
+    const value = typeof newValue === "function" ? newValue(currentState) : newValue;
+    if (Object.is(currentState, value))
       return;
-    componentStates[index] = nextValue;
-    if (isBatching) {
-      batchUpdates(() => rerender(currentRender));
-    } else {
-      rerender(currentRender);
+    compState.states[currentIndex] = value;
+    if (root.renderCallback && root.container && root.currentElement) {
+      root.renderCallback(root.currentElement, root.container);
     }
   };
-  stateIndices.set(currentRender, index + 1);
   return [state, setState];
 }
 function useEffect(callback, deps) {
-  if (!currentRender)
-    throw new Error("useEffect must be called within a render");
-  const effectIndex = stateIndices.get(currentRender);
-  if (!effects.has(currentRender)) {
-    effects.set(currentRender, []);
-  }
-  const componentEffects = effects.get(currentRender);
-  const prevEffect = componentEffects[effectIndex];
-  if (!prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => dep !== prevEffect.deps[i])) {
-    if (prevEffect == null ? void 0 : prevEffect.cleanup) {
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null || isServer)
+    return;
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevEffect = compState.effects[currentIndex];
+  const shouldRun = !prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => !Object.is(dep, prevEffect.deps?.[i]));
+  if (shouldRun) {
+    if (prevEffect?.cleanup) {
       prevEffect.cleanup();
     }
     queueMicrotask(() => {
-      const cleanup = callback() || void 0;
-      componentEffects[effectIndex] = { cleanup, deps };
+      const cleanup = callback();
+      compState.effects[currentIndex] = {
+        callback,
+        deps,
+        cleanup: typeof cleanup === "function" ? cleanup : void 0
+      };
     });
   }
-  stateIndices.set(currentRender, effectIndex + 1);
+  if (!prevEffect) {
+    compState.effects.push({ callback, deps });
+  }
+}
+function useLayoutEffect(callback, deps) {
+  if (isServer)
+    return;
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null)
+    return;
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevEffect = compState.effects[currentIndex];
+  const shouldRun = !prevEffect || !deps || !prevEffect.deps || deps.some((dep, i) => !Object.is(dep, prevEffect.deps?.[i]));
+  if (shouldRun) {
+    if (prevEffect?.cleanup) {
+      prevEffect.cleanup();
+    }
+    const cleanup = callback();
+    compState.effects[currentIndex] = {
+      callback,
+      deps,
+      cleanup: typeof cleanup === "function" ? cleanup : void 0
+    };
+  }
+  if (!prevEffect) {
+    compState.effects.push({ callback, deps });
+  }
 }
 function useMemo(factory, deps) {
-  if (!currentRender)
-    throw new Error("useMemo must be called within a render");
-  const memoIndex = stateIndices.get(currentRender);
-  if (!memos.has(currentRender)) {
-    memos.set(currentRender, []);
-  }
-  const componentMemos = memos.get(currentRender);
-  const prevMemo = componentMemos[memoIndex];
-  if (!prevMemo || deps && deps.some((dep, i) => !Object.is(dep, prevMemo.deps[i]))) {
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    return factory();
+  }
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  const prevMemo = compState.memos[currentIndex];
+  const shouldRecalculate = !prevMemo || !deps || !prevMemo.deps || deps.some((dep, i) => !Object.is(dep, prevMemo.deps?.[i]));
+  if (shouldRecalculate) {
     const value = factory();
-    componentMemos[memoIndex] = { value, deps };
-    stateIndices.set(currentRender, memoIndex + 1);
+    compState.memos[currentIndex] = { value, deps };
     return value;
   }
-  stateIndices.set(currentRender, memoIndex + 1);
   return prevMemo.value;
 }
+function useCallback(callback, deps) {
+  return useMemo(() => callback, deps);
+}
 function useRef(initial) {
-  if (!currentRender)
-    throw new Error("useRef must be called within a render");
-  const refIndex = stateIndices.get(currentRender);
-  if (!refs.has(currentRender)) {
-    refs.set(currentRender, []);
-  }
-  const componentRefs = refs.get(currentRender);
-  if (refIndex >= componentRefs.length) {
-    const ref2 = { current: initial };
-    componentRefs.push(ref2);
-    stateIndices.set(currentRender, refIndex + 1);
-    return ref2;
-  }
-  const ref = componentRefs[refIndex];
-  stateIndices.set(currentRender, refIndex + 1);
-  return ref;
-}
-async function rerender(rendererId) {
-  try {
-    const componentEffects = effects.get(rendererId);
-    if (componentEffects) {
-      componentEffects.forEach((effect) => {
-        if (effect.cleanup)
-          effect.cleanup();
-      });
-      effects.set(rendererId, []);
-    }
-    if (globalRenderCallback && globalContainer && currentElement) {
-      await globalRenderCallback(currentElement, globalContainer);
-    }
-  } catch (error) {
-    console.error("Error during rerender:", error);
+  const root = currentRoot;
+  const compId = currentComponentId;
+  if (!root || compId === null) {
+    return { current: initial };
   }
+  const compState = getComponentState(root, compId);
+  const currentIndex = hookIndex;
+  hookIndex++;
+  if (compState.refs[currentIndex] === void 0) {
+    compState.refs[currentIndex] = { current: initial };
+  }
+  return compState.refs[currentIndex];
 }
-function useErrorBoundary() {
-  const [error, setError] = useState(null);
-  return [error, () => setError(null)];
-}
-function createContext(defaultValue) {
-  const context = {
-    Provider: ({ value, children }) => {
-      return children;
-    },
-    Consumer: ({ children }) => {
-      return children(defaultValue);
-    },
-    _id: Symbol(),
-    useSelector: (selector) => {
-      return selector(defaultValue);
-    }
+function useReducer(reducer, initialState) {
+  const [state, setState] = useState(initialState);
+  const dispatch = (action) => {
+    setState((prevState) => reducer(prevState, action));
   };
-  return context;
+  return [state, dispatch];
 }
-function useContext(context) {
-  return context;
+function useErrorBoundary() {
+  const [error, setError] = useState(null);
+  const resetError = () => setError(null);
+  return [error, resetError];
 }
-function jsx(type, props) {
-  console.log("JSX Transform:", { type, props });
-  const processedProps = { ...props };
-  if (arguments.length > 2) {
-    processedProps.children = Array.prototype.slice.call(arguments, 2);
+function useId() {
+  const ref = useRef(null);
+  if (ref.current === null) {
+    ref.current = `baraqex-id-${++idCounter}`;
   }
-  return { type, props: processedProps };
+  return ref.current;
 }
-async function createElement(vnode) {
-  var _a;
-  console.log("Creating element from:", vnode);
-  if (vnode == null) {
-    return document.createTextNode("");
-  }
-  if (typeof vnode === "boolean") {
-    return document.createTextNode("");
-  }
-  if (typeof vnode === "number" || typeof vnode === "string") {
-    return document.createTextNode(String(vnode));
-  }
-  if (Array.isArray(vnode)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of vnode) {
-      const node = await createElement(child);
-      fragment.appendChild(node);
-    }
-    return fragment;
-  }
-  if ("type" in vnode && vnode.props !== void 0) {
-    const { type, props } = vnode;
-    if (typeof type === "function") {
-      try {
-        const result = await type(props || {});
-        const node = await createElement(result);
-        if (node instanceof Element) {
-          node.setAttribute("data-component-id", type.name || type.toString());
-        }
-        return node;
-      } catch (error) {
-        console.error("Error rendering component:", error);
-        return document.createTextNode("");
-      }
-    }
-    const element = document.createElement(type);
-    for (const [key, value] of Object.entries(props || {})) {
-      if (key === "children")
-        continue;
-      if (key.startsWith("on") && typeof value === "function") {
-        const eventName = key.toLowerCase().slice(2);
-        const existingHandler = (_a = element.__events) == null ? void 0 : _a[eventName];
-        if (existingHandler) {
-          element.removeEventListener(eventName, existingHandler);
-        }
-        element.addEventListener(eventName, value);
-        if (!element.__events) {
-          element.__events = {};
-        }
-        element.__events[eventName] = value;
-      } else if (key === "style" && typeof value === "object") {
-        Object.assign(element.style, value);
-      } else if (key === "className") {
-        element.setAttribute("class", String(value));
-      } else if (key !== "key" && key !== "ref") {
-        element.setAttribute(key, String(value));
-      }
-    }
-    const children = props == null ? void 0 : props.children;
-    if (children != null) {
-      const childArray = Array.isArray(children) ? children.flat() : [children];
-      for (const child of childArray) {
-        const childNode = await createElement(child);
-        element.appendChild(childNode);
-      }
-    }
-    return element;
+function cleanupHooks(root, compId) {
+  const compState = root.components.get(compId);
+  if (compState) {
+    compState.effects.forEach((effect) => {
+      if (effect.cleanup)
+        effect.cleanup();
+    });
+    root.components.delete(compId);
   }
-  return document.createTextNode(String(vnode));
 }
-async function hydrate(element, container) {
-  isHydrating = true;
+function cleanupRoot(root) {
+  root.components.forEach((compState) => {
+    compState.effects.forEach((effect) => {
+      if (effect.cleanup)
+        effect.cleanup();
+    });
+  });
+  root.components.clear();
+}
+var rootIdCounter, currentRoot, currentComponentId, hookIndex, isServer, idCounter;
+var init_hooks = __esm({
+  "src/core/hooks.ts"() {
+    "use strict";
+    rootIdCounter = 0;
+    currentRoot = null;
+    currentComponentId = null;
+    hookIndex = 0;
+    isServer = typeof window === "undefined";
+    idCounter = 0;
+  }
+});
+
+// src/core/server-renderer.ts
+function renderToString(vnode) {
+  prepareRender();
   try {
-    await render(element, container);
+    return renderNodeToString(vnode);
   } finally {
-    isHydrating = false;
+    finishRender();
   }
 }
-async function render(element, container) {
-  console.log("Rendering to:", container.id);
-  batchUpdates(async () => {
-    const rendererId = prepareRender();
-    try {
-      setRenderCallback(render, element, container);
-      const domNode = await createElement(element);
-      if (!isHydrating) {
-        container.innerHTML = "";
-      }
-      container.appendChild(domNode);
-    } finally {
-      finishRender();
-    }
-  });
+function renderToStringWithData(vnode) {
+  const html = renderToString(vnode);
+  return { html, data: {} };
 }
-function renderToString(vnode) {
-  prepareRender();
-  const html = renderNodeToString(vnode);
-  finishRender();
-  return html;
+async function* renderToStream(vnode) {
+  yield renderToString(vnode);
 }
 function renderNodeToString(vnode) {
-  var _a, _b, _c;
   if (vnode === null || vnode === void 0)
     return "";
   if (typeof vnode === "boolean")
     return "";
   if (typeof vnode === "number" || typeof vnode === "string")
     return escapeHtml(String(vnode));
-  if (typeof vnode.type === "function") {
-    const Component2 = vnode.type;
-    const renderedNode = Component2(vnode.props || {});
-    return renderNodeToString(renderedNode);
+  if (Array.isArray(vnode)) {
+    return vnode.map((child) => renderNodeToString(child)).join("");
+  }
+  if (typeof vnode !== "object" || vnode.type === void 0) {
+    return escapeHtml(String(vnode));
+  }
+  const { type, props } = vnode;
+  if (typeof type === "function") {
+    if (type.name === "Fragment" || type === Symbol.for("react.fragment")) {
+      const children = props?.children;
+      if (children == null)
+        return "";
+      return Array.isArray(children) ? children.map((child) => renderNodeToString(child)).join("") : renderNodeToString(children);
+    }
+    const Component2 = type;
+    try {
+      const renderedNode = Component2(props || {});
+      return renderNodeToString(renderedNode);
+    } catch (error) {
+      console.error("Error rendering component:", error);
+      return `<!-- Error rendering component: ${escapeHtml(String(error))} -->`;
+    }
   }
-  if (typeof vnode.type === "string") {
-    const tag = vnode.type;
+  if (typeof type === "string") {
+    const tag = type;
     let attrs = "";
-    let children = "";
-    if (vnode.props) {
-      for (const [key, value] of Object.entries(vnode.props)) {
+    if (props) {
+      for (const [key, value] of Object.entries(props)) {
         if (key === "children")
           continue;
-        if (key.startsWith("on"))
+        if (key === "dangerouslySetInnerHTML")
+          continue;
+        if (key === "ref")
+          continue;
+        if (value === void 0 || value === null || value === false)
           continue;
-        if (key === "className") {
-          attrs += ` class="${escapeHtml(value)}"`;
+        let attrName = key;
+        let attrValue = value;
+        if (key === "className")
+          attrName = "class";
+        else if (key === "htmlFor")
+          attrName = "for";
+        else if (key === "tabIndex")
+          attrName = "tabindex";
+        if (attrName.startsWith("on") && typeof value === "function")
           continue;
+        if (attrName === "style" && typeof value === "object") {
+          attrValue = Object.entries(value).map(([prop, val]) => {
+            const cssProperty = prop.replace(/([A-Z])/g, "-$1").toLowerCase();
+            return `${cssProperty}: ${val}`;
+          }).join("; ");
         }
-        if (typeof value === "string" || typeof value === "number") {
-          attrs += ` ${key}="${escapeHtml(String(value))}"`;
-        } else if (value === true) {
-          attrs += ` ${key}`;
+        if (value === true) {
+          attrs += ` ${attrName}`;
+        } else {
+          attrs += ` ${attrName}="${escapeHtml(String(attrValue))}"`;
         }
       }
     }
-    const childrenArray = ((_a = vnode.props) == null ? void 0 : _a.children) ? Array.isArray(vnode.props.children) ? vnode.props.children : [vnode.props.children] : [];
+    if (VOID_ELEMENTS.has(tag)) {
+      return `<${tag}${attrs} />`;
+    }
+    if (props?.dangerouslySetInnerHTML?.__html) {
+      return `<${tag}${attrs}>${props.dangerouslySetInnerHTML.__html}</${tag}>`;
+    }
+    let children = "";
+    const childrenArray = props?.children ? Array.isArray(props.children) ? props.children : [props.children] : [];
     for (const child of childrenArray) {
       children += renderNodeToString(child);
     }
-    const selfClosing = [
+    return `<${tag}${attrs}>${children}</${tag}>`;
+  }
+  if (type === Symbol.for("react.fragment")) {
+    const children = props?.children;
+    if (children == null)
+      return "";
+    return Array.isArray(children) ? children.map((child) => renderNodeToString(child)).join("") : renderNodeToString(children);
+  }
+  console.warn("Unknown vnode type:", type);
+  return "";
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+var VOID_ELEMENTS;
+var init_server_renderer = __esm({
+  "src/core/server-renderer.ts"() {
+    "use strict";
+    init_hooks();
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
       "area",
       "base",
       "br",
@@ -346,49 +403,7 @@ function renderNodeToString(vnode) {
       "source",
       "track",
       "wbr"
-    ];
-    if (selfClosing.includes(tag)) {
-      return `<${tag}${attrs}/>`;
-    }
-    return `<${tag}${attrs}>${children}</${tag}>`;
-  }
-  if (vnode.type === Symbol.for("react.fragment")) {
-    let fragmentOutput = "";
-    const children = Array.isArray((_b = vnode.props) == null ? void 0 : _b.children) ? vnode.props.children : ((_c = vnode.props) == null ? void 0 : _c.children) ? [vnode.props.children] : [];
-    for (const child of children) {
-      fragmentOutput += renderNodeToString(child);
-    }
-    return fragmentOutput;
-  }
-  console.warn("Unknown vnode type:", vnode.type);
-  return "";
-}
-function escapeHtml(text) {
-  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
-}
-var isBatching, queue, currentRender, states, stateIndices, effects, memos, refs, globalRenderCallback, globalContainer, currentElement, isServer, serverStates, Fragment, isHydrating, server;
-var init_dist = __esm({
-  "node_modules/frontend-hamroun/dist/index.mjs"() {
-    isBatching = false;
-    queue = [];
-    currentRender = 0;
-    states = /* @__PURE__ */ new Map();
-    stateIndices = /* @__PURE__ */ new Map();
-    effects = /* @__PURE__ */ new Map();
-    memos = /* @__PURE__ */ new Map();
-    refs = /* @__PURE__ */ new Map();
-    globalRenderCallback = null;
-    globalContainer = null;
-    currentElement = null;
-    isServer = typeof window === "undefined";
-    serverStates = /* @__PURE__ */ new Map();
-    Fragment = ({ children }) => children;
-    isHydrating = false;
-    server = {
-      async getServer() {
-        throw new Error("Server module can only be used in Node.js environment");
-      }
-    };
+    ]);
   }
 });
 
@@ -399,10 +414,11 @@ var init_database = __esm({
     "use strict";
     Database = class {
       constructor(config) {
-        this.mongoClient = null;
-        this.mongoDb = null;
-        this.mysqlPool = null;
-        this.pgPool = null;
+        __publicField(this, "config");
+        __publicField(this, "mongoClient", null);
+        __publicField(this, "mongoDb", null);
+        __publicField(this, "mysqlPool", null);
+        __publicField(this, "pgPool", null);
         this.config = config;
       }
       async connect() {
@@ -519,11 +535,27 @@ var init_auth = __esm({
     "use strict";
     AuthService = class {
       constructor(config) {
+        __publicField(this, "config");
+        __publicField(this, "jwtPromise", null);
         this.config = {
           expiresIn: "24h",
           ...config
         };
       }
+      async getJwt() {
+        if (!this.jwtPromise) {
+          this.jwtPromise = import("jsonwebtoken").catch((error) => {
+            this.jwtPromise = null;
+            if (error.code === "MODULE_NOT_FOUND") {
+              throw new Error(
+                "jsonwebtoken not installed. Run: npm install jsonwebtoken @types/jsonwebtoken"
+              );
+            }
+            throw error;
+          });
+        }
+        return this.jwtPromise;
+      }
       async hashPassword(password) {
         try {
           const bcrypt = await import("bcryptjs");
@@ -546,42 +578,31 @@ var init_auth = __esm({
           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;
+      async generateToken(user) {
+        const jwt = await this.getJwt();
+        const options = {};
+        if (this.config.expiresIn) {
+          options.expiresIn = this.config.expiresIn;
         }
+        return jwt.sign(
+          { id: user.id, username: user.username, roles: user.roles || [] },
+          this.config.secret,
+          options
+        );
       }
-      verifyToken(token) {
+      async verifyToken(token) {
         try {
-          const jwt = __require("jsonwebtoken");
+          const jwt = await this.getJwt();
           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");
-          }
+        } catch {
           return null;
         }
       }
-      // Express middleware for authentication
       initialize() {
-        return (req, res, next) => {
+        return async (req, res, next) => {
           const token = this.extractToken(req);
           if (token) {
-            const decoded = this.verifyToken(token);
+            const decoded = await this.verifyToken(token);
             if (decoded) {
               req.user = decoded;
             }
@@ -589,7 +610,6 @@ var init_auth = __esm({
           next();
         };
       }
-      // Express middleware for requiring authentication
       requireAuth() {
         return (req, res, next) => {
           if (!req.user) {
@@ -598,7 +618,6 @@ var init_auth = __esm({
           return next();
         };
       }
-      // Express middleware for requiring specific roles
       requireRoles(roles) {
         return (req, res, next) => {
           if (!req.user) {
@@ -632,8 +651,10 @@ var init_api_router = __esm({
     "use strict";
     ApiRouter = class {
       constructor(apiDir, auth = null) {
-        this.router = null;
-        this.initialized = false;
+        __publicField(this, "router", null);
+        __publicField(this, "apiDir");
+        __publicField(this, "auth");
+        __publicField(this, "initialized", false);
         this.apiDir = path.resolve(process.cwd(), apiDir);
         this.auth = auth;
       }
@@ -739,8 +760,22 @@ var init_api_router = __esm({
 // src/server/middleware.ts
 function rateLimit(options) {
   const requests = /* @__PURE__ */ new Map();
+  const cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [ip, times] of requests) {
+      const valid = times.filter((t) => now - t < options.windowMs);
+      if (valid.length === 0) {
+        requests.delete(ip);
+      } else {
+        requests.set(ip, valid);
+      }
+    }
+  }, options.windowMs);
+  if (cleanupInterval.unref) {
+    cleanupInterval.unref();
+  }
   return (req, res, next) => {
-    const ip = req.ip || req.socket.remoteAddress || "unknown";
+    const 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);
@@ -764,7 +799,7 @@ var init_middleware = __esm({
       console.log(`${(/* @__PURE__ */ new Date()).toISOString()} - ${req.method} ${req.url}`);
       next();
     };
-    errorHandler = (err, req, res, next) => {
+    errorHandler = (err, req, res, _next) => {
       console.error(err.stack);
       res.status(500).json({
         error: {
@@ -925,7 +960,7 @@ __export(templates_exports, {
 });
 function generateDocument(content, options = {}) {
   const {
-    title = "Frontend Hamroun App",
+    title = "Baraqex App",
     description = "",
     lang = "en",
     charset = "UTF-8",
@@ -939,38 +974,38 @@ function generateDocument(content, options = {}) {
     initialData = {},
     componentName = ""
   } = options;
-  const htmlAttributes = Object.entries(htmlAttrs).map(([key, value]) => `${key}="${escapeHtml2(value)}"`).join(" ");
-  const bodyAttributes = Object.entries(bodyAttrs).map(([key, value]) => `${key}="${escapeHtml2(value)}"`).join(" ");
+  const htmlAttributes = Object.entries(htmlAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
+  const bodyAttributes = Object.entries(bodyAttrs).map(([key, value]) => `${key}="${escapeHtml3(value)}"`).join(" ");
   const metaTags = [
     `<meta charset="${charset}">`,
     `<meta name="viewport" content="${viewport}">`,
-    description ? `<meta name="description" content="${escapeHtml2(description)}">` : ""
+    description ? `<meta name="description" content="${escapeHtml3(description)}">` : ""
   ];
   Object.entries(meta).forEach(([name, content2]) => {
-    metaTags.push(`<meta name="${escapeHtml2(name)}" content="${escapeHtml2(content2)}">`);
+    metaTags.push(`<meta name="${escapeHtml3(name)}" content="${escapeHtml3(content2)}">`);
   });
   const scriptTags = scripts.map((src) => {
     if (src.startsWith("<script")) {
       return src;
     }
-    return `<script src="${escapeHtml2(src)}" ${src.endsWith(".js") ? 'type="module"' : ""} defer></script>`;
+    return `<script src="${escapeHtml3(src)}" ${src.endsWith(".js") ? 'type="module"' : ""} defer></script>`;
   });
   const styleTags = styles.map((href) => {
     if (href.startsWith("<style")) {
       return href;
     }
-    return `<link rel="stylesheet" href="${escapeHtml2(href)}">`;
+    return `<link rel="stylesheet" href="${escapeHtml3(href)}">`;
   });
-  const initialDataScript = Object.keys(initialData).length > 0 ? `<script id="__APP_DATA__" type="application/json">${escapeHtml2(JSON.stringify(initialData))}</script>` : "";
+  const initialDataScript = Object.keys(initialData).length > 0 ? `<script id="__APP_DATA__" type="application/json">${escapeHtml3(JSON.stringify(initialData))}</script>` : "";
   return `<!DOCTYPE html>
 <html lang="${lang}" ${htmlAttributes}>
 <head>
   ${metaTags.filter(Boolean).join("\n  ")}
-  <title>${escapeHtml2(title)}</title>
+  <title>${escapeHtml3(title)}</title>
   ${styleTags.join("\n  ")}
 </head>
 <body class="${bodyClasses}" ${bodyAttributes}>
-  <div id="app-root" data-ssr-root${componentName ? ` data-component="${escapeHtml2(componentName)}"` : ""}>${content}</div>
+  <div id="app-root" data-ssr-root${componentName ? ` data-component="${escapeHtml3(componentName)}"` : ""}>${content}</div>
   ${initialDataScript}
   ${scriptTags.join("\n  ")}
 </body>
@@ -988,14 +1023,14 @@ function generateErrorPage(statusCode, message, error) {
   const isDev = process.env.NODE_ENV !== "production";
   const errorDetails = isDev && error ? `
     <div class="error-details">
-      <pre>${escapeHtml2(error.stack || error.message)}</pre>
+      <pre>${escapeHtml3(error.stack || error.message)}</pre>
     </div>
   ` : "";
   const content = `
     <div class="error-container">
       <h1>${statusCode}</h1>
-      <h2>${escapeHtml2(errorMessages[statusCode] || "Error")}</h2>
-      <p>${escapeHtml2(message)}</p>
+      <h2>${escapeHtml3(errorMessages[statusCode] || "Error")}</h2>
+      <p>${escapeHtml3(message)}</p>
       ${errorDetails}
       <a href="/" class="home-link">Back to Home</a>
     </div>
@@ -1069,7 +1104,7 @@ function generateLoadingPage(message = "Loading...") {
   const content = `
     <div class="loading-container">
       <div class="spinner"></div>
-      <p>${escapeHtml2(message)}</p>
+      <p>${escapeHtml3(message)}</p>
     </div>
   `;
   const styles = [`<style>
@@ -1105,7 +1140,7 @@ function generateLoadingPage(message = "Loading...") {
     styles
   });
 }
-function escapeHtml2(text) {
+function escapeHtml3(text) {
   return String(text).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
 }
 var init_templates = __esm({
@@ -1191,7 +1226,7 @@ async function loadGoWasmFromFile(wasmFilePath, options = {}) {
     const GoRuntime = await loadGoRuntime(options.goWasmPath);
     const go = new GoRuntime();
     const wasmBuffer = await fs3.readFile(wasmFilePath);
-    const wasmModule = await WebAssembly.compile(wasmBuffer);
+    const wasmModule = await WebAssembly.compile(new Uint8Array(wasmBuffer));
     const baseImports = go.importObject;
     const finalImportObject = {
       ...baseImports,
@@ -1329,13 +1364,13 @@ function createDevServer(options = {}) {
   });
 }
 function createProductionServer(config) {
-  const server2 = new Server({
+  const server = new Server({
     ...config,
     // Fix the PORT parsing
     port: config.port || (process.env.PORT ? parseInt(process.env.PORT) : 8080)
   });
-  server2.addShutdownHandler();
-  return server2;
+  server.addShutdownHandler();
+  return server;
 }
 function getRequestIp(req) {
   return req.ip || req.headers["x-forwarded-for"]?.split(",")[0].trim() || req.socket.remoteAddress || "";
@@ -1355,7 +1390,7 @@ var Server, renderComponent, server_default;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
-    init_dist();
+    init_server_renderer();
     init_database();
     init_auth();
     init_api_router();
@@ -1372,10 +1407,12 @@ var init_server = __esm({
     init_middleware();
     Server = class {
       constructor(config = {}) {
-        this.server = null;
-        this.db = null;
-        this.auth = null;
-        this.initialized = false;
+        __publicField(this, "app");
+        __publicField(this, "server", null);
+        __publicField(this, "config");
+        __publicField(this, "db", null);
+        __publicField(this, "auth", null);
+        __publicField(this, "initialized", false);
         this.config = {
           port: 3e3,
           apiDir: "./api",
@@ -1654,8 +1691,8 @@ var init_server = __esm({
           if (!fs4.existsSync(clientJsPath)) {
             const clientJsContent = `
           // Auto-generated hydration script
-          import { hydrate } from 'frontend-hamroun';
-          
+          import { hydrate } from 'baraqex';
+
           // Find SSR content and hydrate it
           document.addEventListener('DOMContentLoaded', () => {
             const ssrRoots = document.querySelectorAll('[data-ssr-root]');
@@ -1695,9 +1732,9 @@ var init_server = __esm({
         process.on("SIGINT", gracefulShutdown);
       }
     };
-    renderComponent = (Component, props = {}) => {
+    renderComponent = (Component2, props = {}) => {
       try {
-        const html = renderToString(Component(props));
+        const html = renderToString(Component2(props));
         return {
           html: typeof html === "string" ? html : String(html),
           success: true
@@ -1763,70 +1800,1982 @@ function renderToString2(component) {
     return "<div>Error rendering component</div>";
   }
 }
-var init_server_renderer = __esm({
+var init_server_renderer2 = __esm({
   "src/server-renderer.ts"() {
     "use strict";
   }
 });
 
-// src/index.ts
-init_dist();
-
-// 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/core/batch.ts
+var isBatching = false;
+var syncQueue = [];
+var asyncQueue = [];
+async function batchUpdates(fn) {
+  if (isBatching) {
+    if (fn.constructor.name === "AsyncFunction") {
+      asyncQueue.push(fn);
+    } else {
+      syncQueue.push(fn);
+    }
+    return;
   }
+  isBatching = true;
   try {
-    if (!window.Go) {
-      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
-    }
-    if (options.debug) {
-      console.log("[WASM] Loading WASM from:", wasmUrl);
-    }
-    const response = await fetch(wasmUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch WASM file: ${response.status}`);
-    }
-    const wasmBytes = await response.arrayBuffer();
-    const go = new window.Go();
-    const wasmModule = await WebAssembly.instantiate(wasmBytes, go.importObject);
-    go.run(wasmModule.instance);
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    if (options.debug) {
-      console.log("[WASM] Go program started, checking for registered functions...");
-    }
-    const functions = {};
-    for (const key in window) {
-      if (typeof window[key] === "function" && key.startsWith("go")) {
-        functions[key] = window[key];
-        if (options.debug) {
-          console.log(`[WASM] Found function: ${key}`);
-        }
-      }
+    const result = fn();
+    if (result instanceof Promise) {
+      await result;
     }
-    const wasmInstance = {
-      instance: wasmModule.instance,
-      module: wasmModule,
-      exports: wasmModule.instance.exports,
-      functions
-    };
-    if (options.onLoad) {
-      options.onLoad(wasmInstance);
+    while (syncQueue.length > 0) {
+      const nextFn = syncQueue.shift();
+      nextFn();
     }
-    if (options.debug) {
-      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
+    while (asyncQueue.length > 0) {
+      const nextFn = asyncQueue.shift();
+      await nextFn();
     }
-    return wasmInstance;
-  } catch (error) {
-    console.error("[WASM] Error loading Go WASM module:", error);
-    throw error;
+  } finally {
+    isBatching = false;
   }
 }
-function callWasmFunction(funcName, ...args) {
-  if (typeof window === "undefined") {
-    throw new Error("callWasmFunction() is for browser use only.");
-  }
+function getIsBatching() {
+  return isBatching;
+}
+
+// src/core/index.ts
+init_context();
+init_hooks();
+
+// src/core/jsx-runtime.ts
+init_hooks();
+var isBrowser = typeof document !== "undefined";
+function jsx(type, props, key) {
+  const processedProps = { ...props };
+  if (key !== void 0) {
+    processedProps.key = key;
+  }
+  if (arguments.length > 3) {
+    processedProps.children = Array.prototype.slice.call(arguments, 3);
+  }
+  return { type, props: processedProps, key: processedProps.key };
+}
+var jsxs = jsx;
+function jsxDEV(type, props, key, _isStaticChildren, _source, _self) {
+  return jsx(type, props, key);
+}
+var Fragment = ({ children }) => children;
+function assertBrowser(method) {
+  if (!isBrowser) {
+    throw new Error(
+      `[baraqex] ${method}() can only be called in a browser environment. Use renderToString() for server-side rendering.`
+    );
+  }
+}
+function createTextNode(text) {
+  return document.createTextNode(text);
+}
+function applyProps(element, props) {
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children")
+      continue;
+    if (key === "className") {
+      element.setAttribute("class", String(value));
+    } else if (key === "htmlFor") {
+      element.setAttribute("for", String(value));
+    } else if (key.startsWith("on") && typeof value === "function") {
+      const eventName = key.slice(2).toLowerCase();
+      element.addEventListener(eventName, value);
+    } else if (key === "style" && typeof value === "object") {
+      Object.assign(element.style, value);
+    } else if (key === "dangerouslySetInnerHTML" && value && value.__html) {
+      element.innerHTML = value.__html;
+    } else if (key === "ref") {
+      if (typeof value === "function") {
+        value(element);
+      } else if (value && typeof value === "object" && "current" in value) {
+        value.current = element;
+      }
+    } else if (value !== false && value != null) {
+      if (value === true) {
+        element.setAttribute(key, "");
+      } else {
+        element.setAttribute(key, String(value));
+      }
+    }
+  }
+}
+async function createElement(vnode) {
+  assertBrowser("createElement");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      const node = await createElement(child);
+      fragment.appendChild(node);
+    }
+    return fragment;
+  }
+  if (typeof vnode === "object" && "type" in vnode && vnode.props !== void 0) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      if (type === Fragment) {
+        const children2 = props?.children;
+        if (children2 == null)
+          return createTextNode("");
+        return createElement(children2);
+      }
+      const root = getCurrentRoot() ?? void 0;
+      const renderId = prepareRender(root);
+      try {
+        const result = type(props || {});
+        return await createElement(result);
+      } finally {
+        finishRender();
+      }
+    }
+    const element = document.createElement(type);
+    applyProps(element, props || {});
+    const children = props?.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children : [children];
+      for (const child of childArray) {
+        const childNode = await createElement(child);
+        element.appendChild(childNode);
+      }
+    }
+    return element;
+  }
+  return createTextNode(String(vnode));
+}
+function createElementSync(vnode) {
+  assertBrowser("createElementSync");
+  if (vnode == null || typeof vnode === "boolean") {
+    return createTextNode("");
+  }
+  if (typeof vnode === "number" || typeof vnode === "string") {
+    return createTextNode(String(vnode));
+  }
+  if (Array.isArray(vnode)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of vnode) {
+      fragment.appendChild(createElementSync(child));
+    }
+    return fragment;
+  }
+  if (typeof vnode === "object" && "type" in vnode) {
+    const { type, props } = vnode;
+    if (typeof type === "function") {
+      if (type === Fragment) {
+        return createElementSync(props?.children);
+      }
+      const result = type(props || {});
+      return createElementSync(result);
+    }
+    const element = document.createElement(type);
+    applyProps(element, props || {});
+    const children = props?.children;
+    if (children != null) {
+      const childArray = Array.isArray(children) ? children : [children];
+      for (const child of childArray) {
+        element.appendChild(createElementSync(child));
+      }
+    }
+    return element;
+  }
+  return createTextNode(String(vnode));
+}
+
+// src/core/renderer.ts
+init_hooks();
+var isBrowser2 = typeof document !== "undefined";
+var rootMap = /* @__PURE__ */ new WeakMap();
+async function render(element, container) {
+  if (!isBrowser2) {
+    throw new Error(
+      "[baraqex] render() can only be called in a browser. Use renderToString() for server-side rendering."
+    );
+  }
+  if (!container) {
+    throw new Error("[baraqex] render() requires a container element");
+  }
+  let root = rootMap.get(container);
+  if (!root) {
+    root = createRootState();
+    rootMap.set(container, root);
+  }
+  await batchUpdates(async () => {
+    prepareRender(root);
+    try {
+      setRenderCallback(render, element, container);
+      const domNode = await createElement(element);
+      container.textContent = "";
+      container.appendChild(domNode);
+    } finally {
+      finishRender();
+    }
+  });
+}
+async function hydrate(element, container) {
+  await render(element, container);
+}
+function createRoot(container) {
+  const root = createRootState();
+  rootMap.set(container, root);
+  return {
+    render: (element) => render(element, container),
+    unmount: () => {
+      cleanupRoot(root);
+      rootMap.delete(container);
+      container.textContent = "";
+    }
+  };
+}
+function hasRoot(container) {
+  return rootMap.has(container);
+}
+
+// src/core/index.ts
+init_server_renderer();
+
+// src/core/vdom.ts
+var isBrowser3 = typeof document !== "undefined";
+function arePropsEqual(oldProps, newProps) {
+  const oldKeys = Object.keys(oldProps || {}).filter((k) => k !== "children");
+  const newKeys = Object.keys(newProps || {}).filter((k) => k !== "children");
+  if (oldKeys.length !== newKeys.length)
+    return false;
+  return oldKeys.every((key) => Object.is(oldProps[key], newProps[key]));
+}
+function diff(oldNode, newNode) {
+  if (oldNode == null || newNode == null) {
+    return oldNode !== newNode;
+  }
+  if (typeof oldNode !== typeof newNode)
+    return true;
+  if (typeof newNode === "string" || typeof newNode === "number") {
+    return oldNode !== newNode;
+  }
+  if (Array.isArray(oldNode) && Array.isArray(newNode)) {
+    if (oldNode.length !== newNode.length)
+      return true;
+    return oldNode.some((child, i) => diff(child, newNode[i]));
+  }
+  if (typeof oldNode === "object" && typeof newNode === "object") {
+    if (newNode.type !== oldNode.type)
+      return true;
+    if (newNode.key !== oldNode.key)
+      return true;
+    return !arePropsEqual(oldNode.props, newNode.props);
+  }
+  return oldNode !== newNode;
+}
+function shouldComponentUpdate(oldProps, newProps) {
+  return !arePropsEqual(oldProps, newProps);
+}
+function calculatePatches(oldNode, newNode) {
+  if (oldNode == null && newNode != null) {
+    return { type: "CREATE", node: newNode };
+  }
+  if (oldNode != null && newNode == null) {
+    return { type: "REMOVE" };
+  }
+  if (oldNode == null && newNode == null) {
+    return null;
+  }
+  if (typeof oldNode !== typeof newNode) {
+    return { type: "REPLACE", node: newNode };
+  }
+  if (typeof newNode === "string" || typeof newNode === "number") {
+    if (oldNode !== newNode) {
+      return { type: "REPLACE", node: newNode };
+    }
+    return null;
+  }
+  if (typeof oldNode === "object" && typeof newNode === "object" && "type" in newNode) {
+    if (oldNode.type !== newNode.type) {
+      return { type: "REPLACE", node: newNode };
+    }
+    const propPatches = {};
+    let hasChanges = false;
+    const newProps = newNode.props || {};
+    const oldProps = oldNode.props || {};
+    for (const key of Object.keys(newProps)) {
+      if (key === "children")
+        continue;
+      if (!Object.is(newProps[key], oldProps[key])) {
+        propPatches[key] = newProps[key];
+        hasChanges = true;
+      }
+    }
+    for (const key of Object.keys(oldProps)) {
+      if (key === "children")
+        continue;
+      if (!(key in newProps)) {
+        propPatches[key] = void 0;
+        hasChanges = true;
+      }
+    }
+    const oldChildren = normalizeChildren(oldProps.children);
+    const newChildren = normalizeChildren(newProps.children);
+    const childPatches = diffChildren(oldChildren, newChildren);
+    if (childPatches.length > 0) {
+      hasChanges = true;
+    }
+    if (hasChanges) {
+      return {
+        type: "UPDATE",
+        props: propPatches,
+        children: childPatches.length > 0 ? childPatches : void 0
+      };
+    }
+    return null;
+  }
+  return null;
+}
+function normalizeChildren(children) {
+  if (children == null)
+    return [];
+  return Array.isArray(children) ? children : [children];
+}
+function diffChildren(oldChildren, newChildren) {
+  const patches = [];
+  const oldKeyMap = /* @__PURE__ */ new Map();
+  oldChildren.forEach((child, i) => {
+    if (child && typeof child === "object" && child.key != null) {
+      oldKeyMap.set(child.key, i);
+    }
+  });
+  const newKeyMap = /* @__PURE__ */ new Map();
+  newChildren.forEach((child, i) => {
+    if (child && typeof child === "object" && child.key != null) {
+      newKeyMap.set(child.key, i);
+    }
+  });
+  const maxLen = Math.max(oldChildren.length, newChildren.length);
+  for (let i = 0; i < maxLen; i++) {
+    const oldChild = i < oldChildren.length ? oldChildren[i] : null;
+    const newChild = i < newChildren.length ? newChildren[i] : null;
+    const patch = calculatePatches(oldChild, newChild);
+    if (patch) {
+      patches.push(patch);
+    }
+  }
+  return patches;
+}
+function applyPatches(element, patch) {
+  if (!isBrowser3)
+    return element;
+  switch (patch.type) {
+    case "REMOVE":
+      element.parentNode?.removeChild(element);
+      return null;
+    case "REPLACE": {
+      if (!patch.node)
+        return element;
+      const newNode = patch.node;
+      if (typeof newNode === "string" || typeof newNode === "number") {
+        const textNode = document.createTextNode(String(newNode));
+        element.parentNode?.replaceChild(textNode, element);
+        return null;
+      }
+      element.textContent = "";
+      return element;
+    }
+    case "UPDATE": {
+      if (patch.props) {
+        for (const [key, value] of Object.entries(patch.props)) {
+          if (value === void 0) {
+            const attrName = key === "className" ? "class" : key;
+            element.removeAttribute(attrName);
+          } else if (key === "className") {
+            element.setAttribute("class", String(value));
+          } else if (key === "style" && typeof value === "object") {
+            const htmlEl = element;
+            for (const [prop, val] of Object.entries(value)) {
+              htmlEl.style[prop] = val;
+            }
+          } else if (key.startsWith("on") && typeof value === "function") {
+            const eventName = key.slice(2).toLowerCase();
+            const attrName = `data-baraqex-listener-${eventName}`;
+            const oldHandler = element.__baraqexHandlers?.[eventName];
+            if (oldHandler) {
+              element.removeEventListener(eventName, oldHandler);
+            }
+            element.addEventListener(eventName, value);
+            if (!element.__baraqexHandlers) {
+              element.__baraqexHandlers = {};
+            }
+            element.__baraqexHandlers[eventName] = value;
+          } else if (key === "ref") {
+            if (typeof value === "function") {
+              value(element);
+            } else if (value && typeof value === "object" && "current" in value) {
+              value.current = element;
+            }
+          } else {
+            if (value === true) {
+              element.setAttribute(key, "");
+            } else {
+              element.setAttribute(key, String(value));
+            }
+          }
+        }
+      }
+      return element;
+    }
+    default:
+      return element;
+  }
+}
+
+// src/core/component.ts
+var Component = class {
+  constructor(props) {
+    __publicField(this, "props");
+    __publicField(this, "state");
+    __publicField(this, "element", null);
+    __publicField(this, "_mounted", false);
+    __publicField(this, "_pendingState", null);
+    this.props = props;
+    this.state = {};
+  }
+  /**
+   * Called after the component is mounted to the DOM
+   */
+  componentDidMount() {
+  }
+  /**
+   * Called before the component is unmounted from the DOM
+   */
+  componentWillUnmount() {
+  }
+  /**
+   * Called when the component receives new props
+   */
+  componentDidUpdate(_prevProps, _prevState) {
+  }
+  /**
+   * Determine if the component should re-render
+   */
+  shouldComponentUpdate(_nextProps, _nextState) {
+    return true;
+  }
+  /**
+   * Update component state and trigger re-render
+   */
+  setState(newState) {
+    const prevState = { ...this.state };
+    const stateUpdate = typeof newState === "function" ? newState(this.state, this.props) : newState;
+    this.state = { ...this.state, ...stateUpdate };
+    if (this._mounted) {
+      if (this.shouldComponentUpdate(this.props, this.state)) {
+        this._update();
+        this.componentDidUpdate(this.props, prevState);
+      }
+    }
+  }
+  /**
+   * Force a re-render without checking shouldComponentUpdate
+   */
+  forceUpdate() {
+    this._update();
+  }
+  /**
+   * Internal update method
+   */
+  async _update() {
+    const vdom = this.render();
+    if (!vdom || !this.element?.parentNode)
+      return;
+    const newElement = await createElement(vdom);
+    if (newElement instanceof HTMLElement) {
+      this.element.parentNode.replaceChild(newElement, this.element);
+      this.element = newElement;
+    }
+  }
+  /**
+   * Mount the component to a container
+   */
+  async mount(container) {
+    const vdom = this.render();
+    if (!vdom)
+      return;
+    const element = await createElement(vdom);
+    if (element instanceof HTMLElement) {
+      this.element = element;
+      container.appendChild(element);
+      this._mounted = true;
+      this.componentDidMount();
+    }
+  }
+  /**
+   * Unmount the component
+   */
+  unmount() {
+    if (this.element?.parentNode) {
+      this.componentWillUnmount();
+      this.element.parentNode.removeChild(this.element);
+      this._mounted = false;
+      this.element = null;
+    }
+  }
+};
+function createClassComponent(ComponentClass) {
+  return (props) => {
+    const instance = new ComponentClass(props);
+    return instance.render();
+  };
+}
+var PureComponent = class extends Component {
+  shouldComponentUpdate(nextProps, nextState) {
+    const propsKeys = Object.keys(this.props);
+    const nextPropsKeys = Object.keys(nextProps);
+    if (propsKeys.length !== nextPropsKeys.length)
+      return true;
+    for (const key of propsKeys) {
+      if (!Object.is(this.props[key], nextProps[key]))
+        return true;
+    }
+    const stateKeys = Object.keys(this.state);
+    const nextStateKeys = Object.keys(nextState);
+    if (stateKeys.length !== nextStateKeys.length)
+      return true;
+    for (const key of stateKeys) {
+      if (!Object.is(this.state[key], nextState[key]))
+        return true;
+    }
+    return false;
+  }
+};
+
+// src/core/event-bus.ts
+function createEventBus() {
+  const events = /* @__PURE__ */ new Map();
+  const onceHandlers = /* @__PURE__ */ new WeakMap();
+  const on = (event, handler) => {
+    if (!events.has(event)) {
+      events.set(event, /* @__PURE__ */ new Set());
+    }
+    events.get(event).add(handler);
+    return () => off(event, handler);
+  };
+  const once = (event, handler) => {
+    const onceWrapper = (...args) => {
+      handler(...args);
+      off(event, onceWrapper);
+    };
+    onceHandlers.set(handler, onceWrapper);
+    return on(event, onceWrapper);
+  };
+  const off = (event, handler) => {
+    if (!handler) {
+      events.delete(event);
+      return;
+    }
+    const handlers = events.get(event);
+    if (!handlers)
+      return;
+    handlers.delete(handler);
+    const onceWrapper = onceHandlers.get(handler);
+    if (onceWrapper) {
+      handlers.delete(onceWrapper);
+      onceHandlers.delete(handler);
+    }
+    if (handlers.size === 0) {
+      events.delete(event);
+    }
+  };
+  const emit = (event, ...args) => {
+    const handlers = events.get(event);
+    if (!handlers)
+      return;
+    const handlersCopy = Array.from(handlers);
+    for (const handler of handlersCopy) {
+      try {
+        handler(...args);
+      } catch (error) {
+        console.error(`Error in event handler for "${event}":`, error);
+      }
+    }
+  };
+  const clear = (event) => {
+    if (event) {
+      events.delete(event);
+    } else {
+      events.clear();
+    }
+  };
+  return { on, once, off, emit, clear };
+}
+var eventBus = createEventBus();
+function useEvent(event, handler, options = {}) {
+  return options.once ? eventBus.once(event, handler) : eventBus.on(event, handler);
+}
+
+// src/core/router.ts
+init_context();
+init_hooks();
+var RouterContext = createContext({
+  pathname: "/",
+  search: "",
+  hash: "",
+  params: {},
+  query: {},
+  navigate: () => {
+  },
+  back: () => {
+  },
+  forward: () => {
+  },
+  match: () => false
+});
+function parseQuery(search) {
+  const query = {};
+  const params = new URLSearchParams(search);
+  params.forEach((value, key) => {
+    query[key] = value;
+  });
+  return query;
+}
+function matchPath(pathname, pattern, exact = false) {
+  const params = {};
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = pathname.split("/").filter(Boolean);
+  if (exact && patternParts.length !== pathParts.length) {
+    return { match: false, params };
+  }
+  if (patternParts.length > pathParts.length) {
+    return { match: false, params };
+  }
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      const paramName = patternPart.slice(1);
+      params[paramName] = decodeURIComponent(pathPart);
+    } else if (patternPart === "*") {
+      params["*"] = pathParts.slice(i).join("/");
+      return { match: true, params };
+    } else if (patternPart !== pathPart) {
+      return { match: false, params };
+    }
+  }
+  return { match: true, params };
+}
+function RouterProvider({
+  children
+}) {
+  const [location, setLocation] = useState((() => {
+    if (typeof window === "undefined") {
+      return { pathname: "/", search: "", hash: "", params: {}, query: {} };
+    }
+    return {
+      pathname: window.location.pathname,
+      search: window.location.search,
+      hash: window.location.hash,
+      params: {},
+      query: parseQuery(window.location.search)
+    };
+  })());
+  useEffect(() => {
+    if (typeof window === "undefined")
+      return;
+    const handlePopState = () => {
+      setLocation({
+        pathname: window.location.pathname,
+        search: window.location.search,
+        hash: window.location.hash,
+        params: {},
+        query: parseQuery(window.location.search)
+      });
+    };
+    window.addEventListener("popstate", handlePopState);
+    return () => window.removeEventListener("popstate", handlePopState);
+  }, []);
+  const navigate = (to, options = {}) => {
+    if (typeof window === "undefined")
+      return;
+    const url = new URL(to, window.location.origin);
+    if (options.replace) {
+      window.history.replaceState(options.state || null, "", url.href);
+    } else {
+      window.history.pushState(options.state || null, "", url.href);
+    }
+    setLocation({
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      params: {},
+      query: parseQuery(url.search)
+    });
+  };
+  const back = () => {
+    if (typeof window !== "undefined") {
+      window.history.back();
+    }
+  };
+  const forward = () => {
+    if (typeof window !== "undefined") {
+      window.history.forward();
+    }
+  };
+  const match = (pattern) => {
+    return matchPath(location.pathname, pattern).match;
+  };
+  const contextValue = {
+    ...location,
+    navigate,
+    back,
+    forward,
+    match
+  };
+  return jsx(RouterContext.Provider, { value: contextValue, children });
+}
+function Router({ routes }) {
+  const { pathname, params: existingParams } = useContext(RouterContext);
+  for (const route of routes) {
+    const { match, params } = matchPath(pathname, route.path, route.exact);
+    if (match) {
+      const Component2 = route.component;
+      return jsx(Component2, { ...params, ...existingParams });
+    }
+  }
+  return null;
+}
+function Route({
+  path: path5,
+  component: Component2,
+  exact = false
+}) {
+  const { pathname } = useContext(RouterContext);
+  const { match, params } = matchPath(pathname, path5, exact);
+  if (match) {
+    return jsx(Component2, params);
+  }
+  return null;
+}
+function Switch({ children }) {
+  const { pathname } = useContext(RouterContext);
+  const routes = Array.isArray(children) ? children : [children];
+  for (const child of routes) {
+    if (child?.props?.path) {
+      const exact = child.props.exact ?? false;
+      const { match } = matchPath(pathname, child.props.path, exact);
+      if (match) {
+        return child;
+      }
+    }
+  }
+  return null;
+}
+function Link({
+  to,
+  children,
+  replace = false,
+  className = "",
+  activeClassName = "",
+  ...rest
+}) {
+  const { pathname, navigate } = useContext(RouterContext);
+  const isActive = pathname === to || pathname.startsWith(to + "/");
+  const handleClick = (e) => {
+    e.preventDefault();
+    navigate(to, { replace });
+  };
+  const combinedClassName = isActive && activeClassName ? `${className} ${activeClassName}`.trim() : className;
+  return jsx("a", {
+    href: to,
+    onClick: handleClick,
+    className: combinedClassName || void 0,
+    ...rest,
+    children
+  });
+}
+function Redirect({
+  to,
+  replace = true
+}) {
+  const { navigate } = useContext(RouterContext);
+  useEffect(() => {
+    navigate(to, { replace });
+  }, [to, replace]);
+  return null;
+}
+function NavLink({
+  to,
+  children,
+  activeClassName = "active",
+  className = "",
+  exact = false,
+  ...rest
+}) {
+  const { pathname, navigate } = useContext(RouterContext);
+  const { match } = matchPath(pathname, to, exact);
+  const isActive = match;
+  const combinedClassName = isActive ? `${className} ${activeClassName}`.trim() : className;
+  const handleClick = (e) => {
+    e.preventDefault();
+    navigate(to);
+  };
+  return jsx("a", {
+    href: to,
+    onClick: handleClick,
+    className: combinedClassName || void 0,
+    "aria-current": isActive ? "page" : void 0,
+    ...rest,
+    children
+  });
+}
+function useRouter() {
+  return useContext(RouterContext);
+}
+function useLocation() {
+  const { pathname, search, hash, params, query } = useContext(RouterContext);
+  return { pathname, search, hash, params, query };
+}
+function useParams() {
+  const { params } = useContext(RouterContext);
+  return params;
+}
+function useNavigate() {
+  const { navigate } = useContext(RouterContext);
+  return navigate;
+}
+function useSearchParams() {
+  const { search, navigate, pathname } = useContext(RouterContext);
+  const searchParams = new URLSearchParams(search);
+  const setSearchParams = (newParams) => {
+    navigate(`${pathname}?${newParams.toString()}`);
+  };
+  return [searchParams, setSearchParams];
+}
+function useMatch(pattern) {
+  const { pathname } = useContext(RouterContext);
+  const { match, params } = matchPath(pathname, pattern);
+  return match ? params : null;
+}
+
+// src/core/forms.ts
+init_hooks();
+function validateFieldValue(value, rules, allValues) {
+  if (rules.required) {
+    const isEmpty2 = value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0;
+    if (isEmpty2) {
+      return typeof rules.required === "string" ? rules.required : "This field is required";
+    }
+  }
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (rules.minLength !== void 0) {
+    const minLength = typeof rules.minLength === "object" ? rules.minLength.value : rules.minLength;
+    const message = typeof rules.minLength === "object" ? rules.minLength.message : `Minimum length is ${minLength}`;
+    if (String(value).length < minLength) {
+      return message;
+    }
+  }
+  if (rules.maxLength !== void 0) {
+    const maxLength = typeof rules.maxLength === "object" ? rules.maxLength.value : rules.maxLength;
+    const message = typeof rules.maxLength === "object" ? rules.maxLength.message : `Maximum length is ${maxLength}`;
+    if (String(value).length > maxLength) {
+      return message;
+    }
+  }
+  if (rules.min !== void 0) {
+    const min = typeof rules.min === "object" ? rules.min.value : rules.min;
+    const message = typeof rules.min === "object" ? rules.min.message : `Minimum value is ${min}`;
+    if (Number(value) < min) {
+      return message;
+    }
+  }
+  if (rules.max !== void 0) {
+    const max = typeof rules.max === "object" ? rules.max.value : rules.max;
+    const message = typeof rules.max === "object" ? rules.max.message : `Maximum value is ${max}`;
+    if (Number(value) > max) {
+      return message;
+    }
+  }
+  if (rules.pattern !== void 0) {
+    const pattern = rules.pattern instanceof RegExp ? rules.pattern : rules.pattern.value;
+    const message = rules.pattern instanceof RegExp ? "Invalid format" : rules.pattern.message;
+    if (!pattern.test(String(value))) {
+      return message;
+    }
+  }
+  if (rules.validate) {
+    const result = rules.validate(value, allValues);
+    if (result === false) {
+      return "Invalid value";
+    }
+    if (typeof result === "string") {
+      return result;
+    }
+  }
+  return void 0;
+}
+function useForm(options) {
+  const {
+    initialValues,
+    validate,
+    validationRules,
+    onSubmit,
+    validateOnChange = true,
+    validateOnBlur = true
+  } = options;
+  const [values, setValuesState] = useState(initialValues);
+  const [errors, setErrorsState] = useState({});
+  const [touched, setTouched] = useState({});
+  const [dirty, setDirty] = useState({});
+  const [isSubmitting, setIsSubmitting] = useState(false);
+  const [submitCount, setSubmitCount] = useState(0);
+  const initialValuesRef = useRef(initialValues);
+  const isValid = Object.keys(errors).length === 0;
+  const isDirty = Object.values(dirty).some(Boolean);
+  const validateField = useCallback((field) => {
+    const value = values[field];
+    if (validationRules && validationRules[field]) {
+      return validateFieldValue(value, validationRules[field], values);
+    }
+    if (validate) {
+      const allErrors = validate(values);
+      return allErrors[field];
+    }
+    return void 0;
+  }, [values, validate, validationRules]);
+  const validateForm = useCallback(() => {
+    const newErrors = {};
+    if (validationRules) {
+      for (const field in validationRules) {
+        const error = validateFieldValue(values[field], validationRules[field], values);
+        if (error) {
+          newErrors[field] = error;
+        }
+      }
+    }
+    if (validate) {
+      const customErrors = validate(values);
+      Object.assign(newErrors, customErrors);
+    }
+    return newErrors;
+  }, [values, validate, validationRules]);
+  useEffect(() => {
+    if (validateOnChange) {
+      const newErrors = validateForm();
+      setErrorsState(newErrors);
+    }
+  }, [values, validateOnChange, validateForm]);
+  const handleChange = useCallback((e) => {
+    const { name, value, type, checked } = e.target;
+    const fieldValue = type === "checkbox" ? checked : value;
+    setValuesState((prev) => ({ ...prev, [name]: fieldValue }));
+    setDirty((prev) => ({ ...prev, [name]: true }));
+  }, []);
+  const handleBlur = useCallback((e) => {
+    const { name } = e.target;
+    setTouched((prev) => ({ ...prev, [name]: true }));
+    if (validateOnBlur) {
+      const error = validateField(name);
+      setErrorsState((prev) => {
+        if (error) {
+          return { ...prev, [name]: error };
+        }
+        const { [name]: _, ...rest } = prev;
+        return rest;
+      });
+    }
+  }, [validateOnBlur, validateField]);
+  const handleSubmit = useCallback(async (e) => {
+    if (e?.preventDefault) {
+      e.preventDefault();
+    }
+    setSubmitCount((prev) => prev + 1);
+    const allTouched = {};
+    for (const key in values) {
+      allTouched[key] = true;
+    }
+    setTouched(allTouched);
+    const formErrors = validateForm();
+    setErrorsState(formErrors);
+    if (Object.keys(formErrors).length > 0) {
+      return;
+    }
+    if (onSubmit) {
+      setIsSubmitting(true);
+      try {
+        await onSubmit(values, formConfig);
+      } finally {
+        setIsSubmitting(false);
+      }
+    }
+  }, [values, validateForm, onSubmit]);
+  const setFieldValue = useCallback((field, value) => {
+    setValuesState((prev) => ({ ...prev, [field]: value }));
+    setDirty((prev) => ({ ...prev, [field]: true }));
+  }, []);
+  const setFieldError = useCallback((field, error) => {
+    setErrorsState((prev) => ({ ...prev, [field]: error }));
+  }, []);
+  const setFieldTouched = useCallback((field, isTouched = true) => {
+    setTouched((prev) => ({ ...prev, [field]: isTouched }));
+  }, []);
+  const setValues = useCallback((newValues) => {
+    setValuesState((prev) => ({ ...prev, ...newValues }));
+  }, []);
+  const setErrors = useCallback((newErrors) => {
+    setErrorsState(newErrors);
+  }, []);
+  const resetForm = useCallback((nextValues) => {
+    setValuesState(nextValues ? { ...initialValuesRef.current, ...nextValues } : initialValuesRef.current);
+    setErrorsState({});
+    setTouched({});
+    setDirty({});
+    setSubmitCount(0);
+  }, []);
+  const getFieldProps = useCallback((field) => ({
+    name: field,
+    value: values[field] ?? "",
+    onChange: handleChange,
+    onBlur: handleBlur
+  }), [values, handleChange, handleBlur]);
+  const formConfig = {
+    values,
+    errors,
+    touched,
+    dirty,
+    isValid,
+    isDirty,
+    isSubmitting,
+    submitCount,
+    handleChange,
+    handleBlur,
+    handleSubmit,
+    setFieldValue,
+    setFieldError,
+    setFieldTouched,
+    setValues,
+    setErrors,
+    resetForm,
+    validateField,
+    validateForm,
+    getFieldProps,
+    register: getFieldProps
+  };
+  return formConfig;
+}
+function useField(name, form) {
+  return {
+    field: form.getFieldProps(name),
+    meta: {
+      touched: form.touched[name] || false,
+      error: form.errors[name],
+      dirty: form.dirty[name] || false
+    },
+    helpers: {
+      setValue: (value) => form.setFieldValue(name, value),
+      setError: (error) => form.setFieldError(name, error),
+      setTouched: (touched) => form.setFieldTouched(name, touched)
+    }
+  };
+}
+var patterns = {
+  email: /^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$/i,
+  phone: /^\+?[1-9]\d{1,14}$/,
+  url: /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/,
+  alphanumeric: /^[a-zA-Z0-9]+$/,
+  numeric: /^\d+$/,
+  password: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/
+};
+
+// src/core/store.ts
+init_context();
+init_hooks();
+function createStore(reducer, initialState, middlewares = []) {
+  let state = initialState;
+  let listeners = /* @__PURE__ */ new Set();
+  let currentReducer = reducer;
+  const getState = () => state;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  let dispatch = (action) => {
+    state = currentReducer(state, action);
+    listeners.forEach((listener) => listener());
+  };
+  if (middlewares.length > 0) {
+    const store = { getState, dispatch, subscribe, replaceReducer: () => {
+    } };
+    const chain = middlewares.map((middleware) => middleware(store));
+    dispatch = chain.reduceRight(
+      (next, middleware) => middleware(next),
+      dispatch
+    );
+  }
+  const replaceReducer = (nextReducer) => {
+    currentReducer = nextReducer;
+  };
+  dispatch({ type: "@@INIT" });
+  return {
+    getState,
+    dispatch,
+    subscribe,
+    replaceReducer
+  };
+}
+function combineReducers(reducers) {
+  return (state, action) => {
+    const nextState = {};
+    let hasChanged = false;
+    for (const key in reducers) {
+      const reducer = reducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
+    }
+    return hasChanged ? nextState : state;
+  };
+}
+var StoreContext = createContext({
+  store: {
+    getState: () => ({}),
+    dispatch: () => {
+    },
+    subscribe: () => () => {
+    },
+    replaceReducer: () => {
+    }
+  },
+  state: {}
+});
+function StoreProvider({
+  store,
+  children
+}) {
+  const [state, setState] = useState(store.getState());
+  useEffect(() => {
+    const unsubscribe = store.subscribe(() => {
+      setState(store.getState());
+    });
+    return unsubscribe;
+  }, [store]);
+  return jsx(StoreContext.Provider, {
+    value: { store, state },
+    children
+  });
+}
+function useSelector(selector) {
+  const { state } = useContext(StoreContext);
+  return selector(state);
+}
+function useDispatch() {
+  const { store } = useContext(StoreContext);
+  return store.dispatch;
+}
+function useStore() {
+  const { store } = useContext(StoreContext);
+  return store;
+}
+var logger = (store) => (next) => (action) => {
+  console.group(`Action: ${action.type}`);
+  console.log("Payload:", action.payload);
+  console.log("Previous State:", store.getState());
+  const result = next(action);
+  console.log("Next State:", store.getState());
+  console.groupEnd();
+  return result;
+};
+var thunk = (store) => (next) => (action) => {
+  if (typeof action === "function") {
+    return action(store.dispatch, store.getState);
+  }
+  return next(action);
+};
+var devTools = (store) => (next) => (action) => {
+  if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
+    const devToolsExtension = window.__REDUX_DEVTOOLS_EXTENSION__;
+    devToolsExtension.send(action, store.getState());
+  }
+  return next(action);
+};
+function createAction(type) {
+  const actionCreator = (payload) => ({ type, payload });
+  actionCreator.type = type;
+  actionCreator.match = (action) => action.type === type;
+  return actionCreator;
+}
+function createSlice(config) {
+  const { name, initialState, reducers } = config;
+  const actions = {};
+  for (const key in reducers) {
+    const type = `${name}/${key}`;
+    actions[key] = (payload) => ({ type, payload });
+  }
+  const reducer = (state = initialState, action) => {
+    for (const key in reducers) {
+      const type = `${name}/${key}`;
+      if (action.type === type) {
+        return reducers[key](state, action);
+      }
+    }
+    return state;
+  };
+  return {
+    name,
+    reducer,
+    actions
+  };
+}
+
+// src/core/lifecycle-events.ts
+var LifecycleEvents = /* @__PURE__ */ ((LifecycleEvents2) => {
+  LifecycleEvents2["APP_INIT"] = "app:init";
+  LifecycleEvents2["APP_MOUNTED"] = "app:mounted";
+  LifecycleEvents2["APP_UPDATED"] = "app:updated";
+  LifecycleEvents2["APP_ERROR"] = "app:error";
+  LifecycleEvents2["APP_DESTROYED"] = "app:destroyed";
+  LifecycleEvents2["COMPONENT_CREATED"] = "component:created";
+  LifecycleEvents2["COMPONENT_MOUNTED"] = "component:mounted";
+  LifecycleEvents2["COMPONENT_UPDATED"] = "component:updated";
+  LifecycleEvents2["COMPONENT_ERROR"] = "component:error";
+  LifecycleEvents2["COMPONENT_UNMOUNTED"] = "component:unmounted";
+  LifecycleEvents2["ROUTER_BEFORE_CHANGE"] = "router:before-change";
+  LifecycleEvents2["ROUTER_AFTER_CHANGE"] = "router:after-change";
+  LifecycleEvents2["ROUTER_ERROR"] = "router:error";
+  LifecycleEvents2["STORE_INITIALIZED"] = "store:initialized";
+  LifecycleEvents2["STORE_BEFORE_ACTION"] = "store:before-action";
+  LifecycleEvents2["STORE_AFTER_ACTION"] = "store:after-action";
+  LifecycleEvents2["STORE_ERROR"] = "store:error";
+  return LifecycleEvents2;
+})(LifecycleEvents || {});
+function emitAppInit(data) {
+  eventBus.emit("app:init" /* APP_INIT */, data);
+}
+function emitAppMounted(rootElement) {
+  eventBus.emit("app:mounted" /* APP_MOUNTED */, rootElement);
+}
+function emitAppUpdated() {
+  eventBus.emit("app:updated" /* APP_UPDATED */);
+}
+function emitAppError(error) {
+  eventBus.emit("app:error" /* APP_ERROR */, error);
+}
+function emitAppDestroyed() {
+  eventBus.emit("app:destroyed" /* APP_DESTROYED */);
+}
+function emitComponentCreated(info) {
+  eventBus.emit("component:created" /* COMPONENT_CREATED */, info);
+}
+function emitComponentMounted(info, element) {
+  eventBus.emit("component:mounted" /* COMPONENT_MOUNTED */, info, element);
+}
+function emitComponentUpdated(info, prevProps, newProps) {
+  eventBus.emit("component:updated" /* COMPONENT_UPDATED */, info, prevProps, newProps);
+}
+function emitComponentError(info, error) {
+  eventBus.emit("component:error" /* COMPONENT_ERROR */, info, error);
+}
+function emitComponentUnmounted(info) {
+  eventBus.emit("component:unmounted" /* COMPONENT_UNMOUNTED */, info);
+}
+function emitRouterBeforeChange(info) {
+  return new Promise((resolve) => {
+    let prevented = false;
+    const prevent = () => {
+      prevented = true;
+    };
+    eventBus.emit("router:before-change" /* ROUTER_BEFORE_CHANGE */, info, prevent);
+    resolve(!prevented);
+  });
+}
+function emitRouterAfterChange(info) {
+  eventBus.emit("router:after-change" /* ROUTER_AFTER_CHANGE */, info);
+}
+function emitRouterError(error, info) {
+  eventBus.emit("router:error" /* ROUTER_ERROR */, error, info);
+}
+function emitStoreInitialized(state) {
+  eventBus.emit("store:initialized" /* STORE_INITIALIZED */, state);
+}
+function emitStoreBeforeAction(actionType, payload, state) {
+  eventBus.emit("store:before-action" /* STORE_BEFORE_ACTION */, actionType, payload, state);
+}
+function emitStoreAfterAction(info) {
+  eventBus.emit("store:after-action" /* STORE_AFTER_ACTION */, info);
+}
+function emitStoreError(error, actionType, payload) {
+  eventBus.emit("store:error" /* STORE_ERROR */, error, actionType, payload);
+}
+function onAppInit(handler) {
+  return eventBus.on("app:init" /* APP_INIT */, handler);
+}
+function onAppMounted(handler) {
+  return eventBus.on("app:mounted" /* APP_MOUNTED */, handler);
+}
+function onAppUpdated(handler) {
+  return eventBus.on("app:updated" /* APP_UPDATED */, handler);
+}
+function onAppError(handler) {
+  return eventBus.on("app:error" /* APP_ERROR */, handler);
+}
+function onAppDestroyed(handler) {
+  return eventBus.on("app:destroyed" /* APP_DESTROYED */, handler);
+}
+function onComponentCreated(handler) {
+  return eventBus.on("component:created" /* COMPONENT_CREATED */, handler);
+}
+function onComponentMounted(handler) {
+  return eventBus.on("component:mounted" /* COMPONENT_MOUNTED */, handler);
+}
+function onComponentUpdated(handler) {
+  return eventBus.on("component:updated" /* COMPONENT_UPDATED */, handler);
+}
+function onComponentError(handler) {
+  return eventBus.on("component:error" /* COMPONENT_ERROR */, handler);
+}
+function onComponentUnmounted(handler) {
+  return eventBus.on("component:unmounted" /* COMPONENT_UNMOUNTED */, handler);
+}
+function onRouterBeforeChange(handler) {
+  return eventBus.on("router:before-change" /* ROUTER_BEFORE_CHANGE */, handler);
+}
+function onRouterAfterChange(handler) {
+  return eventBus.on("router:after-change" /* ROUTER_AFTER_CHANGE */, handler);
+}
+function onRouterError(handler) {
+  return eventBus.on("router:error" /* ROUTER_ERROR */, handler);
+}
+function onStoreInitialized(handler) {
+  return eventBus.on("store:initialized" /* STORE_INITIALIZED */, handler);
+}
+function onStoreBeforeAction(handler) {
+  return eventBus.on("store:before-action" /* STORE_BEFORE_ACTION */, handler);
+}
+function onStoreAfterAction(handler) {
+  return eventBus.on("store:after-action" /* STORE_AFTER_ACTION */, handler);
+}
+function onStoreError(handler) {
+  return eventBus.on("store:error" /* STORE_ERROR */, handler);
+}
+
+// src/core/utils.ts
+function debounce(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  const { leading = false, trailing = true } = options;
+  const invokeFunc = (time) => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const shouldInvoke = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || timeSinceLastInvoke >= wait;
+  };
+  const trailingEdge = (time) => {
+    timeoutId = null;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = null;
+    lastThis = null;
+    return result;
+  };
+  const remainingWait = (time) => {
+    const timeSinceLastCall = lastCallTime === void 0 ? 0 : time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return timeWaiting;
+  };
+  const timerExpired = () => {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timeoutId = setTimeout(timerExpired, remainingWait(time));
+    return result;
+  };
+  const debounced = function(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timeoutId === null) {
+        lastInvokeTime = time;
+        timeoutId = setTimeout(timerExpired, wait);
+        if (leading) {
+          return invokeFunc(time);
+        }
+      }
+    }
+    if (timeoutId === null) {
+      timeoutId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = void 0;
+    timeoutId = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      return trailingEdge(Date.now());
+    }
+    return result;
+  };
+  return debounced;
+}
+function throttle(func, wait, options = {}) {
+  let timeoutId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  let result;
+  let lastCallTime = 0;
+  const { leading = true, trailing = true } = options;
+  const invokeFunc = () => {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = Date.now();
+    result = func.apply(thisArg, args);
+    return result;
+  };
+  const throttled = function(...args) {
+    const now = Date.now();
+    const remaining = wait - (now - lastCallTime);
+    lastArgs = args;
+    lastThis = this;
+    if (remaining <= 0 || remaining > wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (leading || lastCallTime !== 0) {
+        return invokeFunc();
+      }
+    }
+    if (!timeoutId && trailing) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        if (trailing && lastArgs) {
+          invokeFunc();
+        }
+      }, remaining);
+    }
+    return result;
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = null;
+    lastArgs = null;
+    lastThis = null;
+    lastCallTime = 0;
+  };
+  return throttled;
+}
+function deepClone(obj) {
+  if (obj === null || typeof obj !== "object") {
+    return obj;
+  }
+  if (obj instanceof Date) {
+    return new Date(obj.getTime());
+  }
+  if (obj instanceof RegExp) {
+    return new RegExp(obj.source, obj.flags);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepClone(item));
+  }
+  if (obj instanceof Map) {
+    const clonedMap = /* @__PURE__ */ new Map();
+    obj.forEach((value, key) => {
+      clonedMap.set(deepClone(key), deepClone(value));
+    });
+    return clonedMap;
+  }
+  if (obj instanceof Set) {
+    const clonedSet = /* @__PURE__ */ new Set();
+    obj.forEach((value) => {
+      clonedSet.add(deepClone(value));
+    });
+    return clonedSet;
+  }
+  const clonedObj = {};
+  for (const key in obj) {
+    if (Object.prototype.hasOwnProperty.call(obj, key)) {
+      clonedObj[key] = deepClone(obj[key]);
+    }
+  }
+  return clonedObj;
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length)
+    return target;
+  const source = sources.shift();
+  if (source === void 0)
+    return target;
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (sourceValue !== null && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue !== null && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        target[key] = deepMerge(targetValue, sourceValue);
+      } else {
+        target[key] = deepClone(sourceValue);
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function memoize(fn, options = {}) {
+  const { maxSize = 100, keyGenerator = (...args) => JSON.stringify(args) } = options;
+  const cache = /* @__PURE__ */ new Map();
+  const memoized = function(...args) {
+    const key = keyGenerator(...args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    if (cache.size >= maxSize) {
+      const firstKey = cache.keys().next().value;
+      if (firstKey !== void 0) {
+        cache.delete(firstKey);
+      }
+    }
+    cache.set(key, result);
+    return result;
+  };
+  memoized.cache = cache;
+  memoized.clear = () => cache.clear();
+  return memoized;
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function formatDate(date, format = "YYYY-MM-DD HH:mm:ss") {
+  const d = date instanceof Date ? date : new Date(date);
+  if (isNaN(d.getTime())) {
+    return "Invalid Date";
+  }
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  const tokens = {
+    "YYYY": String(d.getFullYear()),
+    "YY": String(d.getFullYear()).slice(-2),
+    "MM": pad(d.getMonth() + 1),
+    "M": String(d.getMonth() + 1),
+    "DD": pad(d.getDate()),
+    "D": String(d.getDate()),
+    "HH": pad(d.getHours()),
+    "H": String(d.getHours()),
+    "hh": pad(d.getHours() % 12 || 12),
+    "h": String(d.getHours() % 12 || 12),
+    "mm": pad(d.getMinutes()),
+    "m": String(d.getMinutes()),
+    "ss": pad(d.getSeconds()),
+    "s": String(d.getSeconds()),
+    "SSS": pad(d.getMilliseconds(), 3),
+    "A": d.getHours() < 12 ? "AM" : "PM",
+    "a": d.getHours() < 12 ? "am" : "pm"
+  };
+  let result = format;
+  for (const token in tokens) {
+    result = result.replace(new RegExp(token, "g"), tokens[token]);
+  }
+  return result;
+}
+function shallowEqual(a, b) {
+  if (a === b)
+    return true;
+  if (!a || !b)
+    return false;
+  if (typeof a !== "object" || typeof b !== "object")
+    return false;
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  for (const key of keysA) {
+    if (a[key] !== b[key])
+      return false;
+  }
+  return true;
+}
+function deepEqual(a, b) {
+  if (a === b)
+    return true;
+  if (a === null || b === null)
+    return false;
+  if (typeof a !== typeof b)
+    return false;
+  if (typeof a !== "object")
+    return false;
+  if (Array.isArray(a) !== Array.isArray(b))
+    return false;
+  if (Array.isArray(a)) {
+    if (a.length !== b.length)
+      return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length)
+    return false;
+  return keysA.every((key) => deepEqual(a[key], b[key]));
+}
+function escapeHtml2(str) {
+  const htmlEscapes = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#39;"
+  };
+  return str.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+}
+function unescapeHtml(str) {
+  const htmlUnescapes = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'"
+  };
+  return str.replace(/&(?:amp|lt|gt|quot|#39);/g, (entity) => htmlUnescapes[entity] || entity);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function camelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, char) => char ? char.toUpperCase() : "").replace(/^(.)/, (char) => char.toLowerCase());
+}
+function kebabCase(str) {
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options = {}) {
+  const { retries = 3, delay = 1e3, backoff = 2, onRetry } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        if (onRetry) {
+          onRetry(lastError, attempt + 1);
+        }
+        await sleep(delay * Math.pow(backoff, attempt));
+      }
+    }
+  }
+  throw lastError;
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function groupBy(array, key) {
+  return array.reduce((result, item) => {
+    const groupKey = typeof key === "function" ? key(item) : String(item[key]);
+    if (!result[groupKey]) {
+      result[groupKey] = [];
+    }
+    result[groupKey].push(item);
+    return result;
+  }, {});
+}
+function isEmpty(value) {
+  if (value === null || value === void 0)
+    return true;
+  if (typeof value === "string")
+    return value.trim() === "";
+  if (Array.isArray(value))
+    return value.length === 0;
+  if (value instanceof Map || value instanceof Set)
+    return value.size === 0;
+  if (typeof value === "object")
+    return Object.keys(value).length === 0;
+  return false;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function get(obj, path5, defaultValue) {
+  const keys = Array.isArray(path5) ? path5 : path5.split(".");
+  let result = obj;
+  for (const key of keys) {
+    if (result === null || result === void 0) {
+      return defaultValue;
+    }
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+}
+function set(obj, path5, value) {
+  const keys = Array.isArray(path5) ? path5 : path5.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return obj;
+}
+
+// src/core/errors.ts
+var BaraqexError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    __publicField(this, "code");
+    __publicField(this, "hint");
+    __publicField(this, "docs");
+    __publicField(this, "originalCause");
+    this.name = "BaraqexError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.docs = options.docs;
+    this.originalCause = options.cause;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  /**
+   * Format error for console output with helpful hints
+   */
+  format() {
+    let output = `
+\u274C ${this.name}: ${this.message}
+`;
+    output += `   Code: ${this.code}
+`;
+    if (this.hint) {
+      output += `   \u{1F4A1} Hint: ${this.hint}
+`;
+    }
+    if (this.docs) {
+      output += `   \u{1F4DA} Docs: ${this.docs}
+`;
+    }
+    return output;
+  }
+};
+var ConfigError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "CONFIG_ERROR",
+      hint: options?.hint || "Check your baraqex.config.js or server configuration",
+      docs: "https://baraqex.tech/docs/configuration",
+      cause: options?.cause
+    });
+    this.name = "ConfigError";
+  }
+};
+var DatabaseError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "DATABASE_ERROR",
+      hint: options?.hint || "Verify your database connection string and credentials",
+      docs: "https://baraqex.tech/docs/database",
+      cause: options?.cause
+    });
+    __publicField(this, "dbType");
+    this.name = "DatabaseError";
+    this.dbType = options?.dbType;
+  }
+};
+var AuthError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "AUTH_ERROR",
+      hint: options?.hint || "Check your JWT secret and token configuration",
+      docs: "https://baraqex.tech/docs/authentication",
+      cause: options?.cause
+    });
+    this.name = "AuthError";
+  }
+};
+var WasmError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "WASM_ERROR",
+      hint: options?.hint || "Ensure your .wasm file is accessible and properly compiled",
+      docs: "https://baraqex.tech/docs/webassembly",
+      cause: options?.cause
+    });
+    this.name = "WasmError";
+  }
+};
+var RouterError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "ROUTER_ERROR",
+      hint: options?.hint || "Check your API route file structure and exports",
+      docs: "https://baraqex.tech/docs/routing",
+      cause: options?.cause
+    });
+    this.name = "RouterError";
+  }
+};
+var ValidationError = class extends BaraqexError {
+  constructor(message, options) {
+    super(message, {
+      code: "VALIDATION_ERROR",
+      hint: options?.hint,
+      cause: options?.cause
+    });
+    __publicField(this, "field");
+    __publicField(this, "value");
+    this.name = "ValidationError";
+    this.field = options?.field;
+    this.value = options?.value;
+  }
+};
+function formatError(error) {
+  if (error instanceof BaraqexError) {
+    return error.format();
+  }
+  if (error instanceof Error) {
+    return `
+\u274C Error: ${error.message}
+`;
+  }
+  return `
+\u274C Unknown error: ${String(error)}
+`;
+}
+function withErrorHandling(fn, errorHandler3) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (errorHandler3) {
+        errorHandler3(error);
+      } else {
+        console.error(formatError(error));
+      }
+      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.");
+  }
+  try {
+    if (!window.Go) {
+      throw new Error("Go WASM runtime not available. Make sure wasm_exec.js is loaded.");
+    }
+    if (options.debug) {
+      console.log("[WASM] Loading WASM from:", wasmUrl);
+    }
+    const response = await fetch(wasmUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch WASM file: ${response.status}`);
+    }
+    const wasmBytes = await response.arrayBuffer();
+    const go = new window.Go();
+    const wasmModule = await WebAssembly.instantiate(wasmBytes, go.importObject);
+    go.run(wasmModule.instance);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (options.debug) {
+      console.log("[WASM] Go program started, checking for registered functions...");
+    }
+    const functions = {};
+    for (const key in window) {
+      if (typeof window[key] === "function" && key.startsWith("go")) {
+        functions[key] = window[key];
+        if (options.debug) {
+          console.log(`[WASM] Found function: ${key}`);
+        }
+      }
+    }
+    const wasmInstance = {
+      instance: wasmModule.instance,
+      module: wasmModule,
+      exports: wasmModule.instance.exports,
+      functions
+    };
+    if (options.onLoad) {
+      options.onLoad(wasmInstance);
+    }
+    if (options.debug) {
+      console.log(`[WASM] Module loaded successfully with ${Object.keys(functions).length} functions`);
+    }
+    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.");
+  }
   const func = window[funcName];
   if (typeof func !== "function") {
     throw new Error(`Function ${funcName} not found. Make sure the WASM module is loaded.`);
@@ -1862,34 +3811,6 @@ function useGoWasm(wasmUrl, options = {}) {
 }
 
 // src/index.ts
-var isNode = typeof process !== "undefined" && process.versions?.node;
-var isBrowser = typeof window !== "undefined";
-var BaraqexServer = null;
-var createServer2 = null;
-var createDevServer2 = null;
-var createProductionServer2 = null;
-var renderComponent2 = null;
-var Database2 = null;
-var AuthService2 = null;
-var ApiRouter2 = null;
-var requestLogger2 = null;
-var errorHandler2 = null;
-var notFoundHandler2 = null;
-var rateLimit2 = null;
-var initNodeWasm3 = null;
-var loadGoWasmFromFile2 = null;
-var hashString2 = null;
-var getPagination2 = null;
-var sendSuccess2 = null;
-var sendError2 = null;
-var validateFields2 = null;
-var validateFileUpload2 = null;
-var getEnvironmentInfo2 = null;
-var isDirectoryEmpty2 = null;
-var ensureDirectory2 = null;
-var writeJsonFile2 = null;
-var readJsonFile2 = null;
-var baraqexRenderToString = null;
 var safeJsonParse2 = (json, fallback) => {
   try {
     return JSON.parse(json);
@@ -1906,133 +3827,300 @@ var generateToken2 = (length = 32) => {
       array[i] = Math.floor(Math.random() * 256);
     }
   }
-  return Array.from(array, (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
 };
 var generateDocument2 = (content, options = {}) => `<!DOCTYPE html><html><head><title>${options.title || "App"}</title></head><body>${content}</body></html>`;
 var generateErrorPage2 = (code, message) => `<div>Error ${code}: ${message}</div>`;
 var generateLoadingPage2 = (message = "Loading...") => `<div>${message}</div>`;
-var renderToString3 = (component) => {
+var fallbackRenderToString = (component) => {
   try {
     if (typeof component === "function") {
       const result = component();
       return typeof result === "string" ? result : String(result || "");
     }
     return String(component || "");
-  } catch (error) {
+  } catch {
     return "<div>Error rendering component</div>";
   }
 };
-if (isNode && !isBrowser) {
-  (async () => {
-    try {
-      try {
-        await import("express");
-        const [serverModule, utilsModule, templatesModule, rendererModule] = await Promise.all([
-          Promise.resolve().then(() => (init_server(), server_exports)),
-          Promise.resolve().then(() => (init_utils(), utils_exports)),
-          Promise.resolve().then(() => (init_templates(), templates_exports)),
-          Promise.resolve().then(() => (init_server_renderer(), server_renderer_exports))
-        ]);
-        BaraqexServer = serverModule.Server;
-        createServer2 = serverModule.createServer;
-        createDevServer2 = serverModule.createDevServer;
-        createProductionServer2 = serverModule.createProductionServer;
-        renderComponent2 = serverModule.renderComponent;
-        Database2 = serverModule.Database;
-        AuthService2 = serverModule.AuthService;
-        ApiRouter2 = serverModule.ApiRouter;
-        requestLogger2 = serverModule.requestLogger;
-        errorHandler2 = serverModule.errorHandler;
-        notFoundHandler2 = serverModule.notFoundHandler;
-        rateLimit2 = serverModule.rateLimit;
-        initNodeWasm3 = serverModule.initNodeWasm;
-        loadGoWasmFromFile2 = serverModule.loadGoWasmFromFile;
-        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;
-        generateDocument2 = templatesModule.generateDocument;
-        generateErrorPage2 = templatesModule.generateErrorPage;
-        generateLoadingPage2 = templatesModule.generateLoadingPage;
-        baraqexRenderToString = rendererModule.renderToString;
-      } catch (expressError) {
-        console.warn("Express not available - server functionality disabled");
-        createServer2 = () => {
-          throw new Error("Server functionality not available. Make sure you have Express installed: npm install express @types/express");
-        };
-        createDevServer2 = () => {
-          throw new Error("Server functionality not available. Make sure you have Express installed: npm install express @types/express");
-        };
-        createProductionServer2 = () => {
-          throw new Error("Server functionality not available. Make sure you have Express installed: npm install express @types/express");
-        };
+function createLazyLoader(importFn, fallback) {
+  let cached = null;
+  let loading = null;
+  async function ensure() {
+    if (cached)
+      return cached;
+    if (!loading) {
+      loading = importFn().then((mod) => {
+        cached = mod;
+        return mod;
+      });
+    }
+    return loading;
+  }
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (cached?.[prop] !== void 0) {
+        return cached[prop];
       }
-    } catch (error) {
-      console.warn("Server modules not available:", error.message);
+      return async (...args) => {
+        try {
+          const mod = await ensure();
+          const fn = mod[prop];
+          if (typeof fn !== "function") {
+            throw new Error(
+              `[baraqex] '${prop}' is not exported from the server module.`
+            );
+          }
+          return fn(...args);
+        } catch (err) {
+          if (fallback && fallback[prop]) {
+            return fallback[prop](...args);
+          }
+          throw err;
+        }
+      };
     }
-  })();
+  });
 }
-console.log("Baraqex - powered by Frontend Hamroun Framework with additional utilities");
+var notAvailable = (name) => () => {
+  throw new Error(
+    `[baraqex] ${name} is only available in a Node.js environment with Express installed. Run: npm install express @types/express`
+  );
+};
+var serverNotFound = {
+  createServer: notAvailable("createServer"),
+  createDevServer: notAvailable("createDevServer"),
+  createProductionServer: notAvailable("createProductionServer"),
+  Server: notAvailable("Server"),
+  renderComponent: notAvailable("renderComponent"),
+  Database: notAvailable("Database"),
+  AuthService: notAvailable("AuthService"),
+  ApiRouter: notAvailable("ApiRouter"),
+  requestLogger: notAvailable("requestLogger"),
+  errorHandler: notAvailable("errorHandler"),
+  notFoundHandler: notAvailable("notFoundHandler"),
+  rateLimit: notAvailable("rateLimit"),
+  initNodeWasm: notAvailable("initNodeWasm"),
+  loadGoWasmFromFile: notAvailable("loadGoWasmFromFile")
+};
+var isNode = typeof process !== "undefined" && !!process.versions?.node;
+var isBrowser4 = typeof window !== "undefined";
+var serverModules = createLazyLoader(
+  () => Promise.all([
+    Promise.resolve().then(() => (init_server(), server_exports)),
+    Promise.resolve().then(() => (init_utils(), utils_exports)),
+    Promise.resolve().then(() => (init_templates(), templates_exports)),
+    Promise.resolve().then(() => (init_server_renderer2(), server_renderer_exports))
+  ]).then(([server, utils, templates, renderer]) => ({
+    ...server,
+    ...utils,
+    ...templates,
+    ...renderer
+  })),
+  isNode && !isBrowser4 ? serverNotFound : serverNotFound
+);
+var lazy = (name) => (...args) => serverModules[name](...args);
+var createServer2 = lazy("createServer");
+var createDevServer2 = lazy("createDevServer");
+var createProductionServer2 = lazy("createProductionServer");
+var BaraqexServer = serverModules.Server;
+var Database2 = serverModules.Database;
+var AuthService2 = serverModules.AuthService;
+var ApiRouter2 = serverModules.ApiRouter;
+var requestLogger2 = lazy("requestLogger");
+var errorHandler2 = lazy("errorHandler");
+var notFoundHandler2 = lazy("notFoundHandler");
+var rateLimit2 = lazy("rateLimit");
+var initNodeWasm3 = lazy("initNodeWasm");
+var loadGoWasmFromFile2 = lazy("loadGoWasmFromFile");
+var hashString2 = lazy("hashString");
+var getPagination2 = lazy("getPagination");
+var sendSuccess2 = lazy("sendSuccess");
+var sendError2 = lazy("sendError");
+var validateFields2 = lazy("validateFields");
+var validateFileUpload2 = lazy("validateFileUpload");
+var getEnvironmentInfo2 = lazy("getEnvironmentInfo");
+var isDirectoryEmpty2 = lazy("isDirectoryEmpty");
+var ensureDirectory2 = lazy("ensureDirectory");
+var writeJsonFile2 = lazy("writeJsonFile");
+var readJsonFile2 = lazy("readJsonFile");
+var renderComponent2 = lazy("renderComponent");
 export {
   ApiRouter2 as ApiRouter,
+  AuthError,
   AuthService2 as AuthService,
+  BaraqexError,
   BaraqexServer,
+  Component,
+  ConfigError,
   Database2 as Database,
+  DatabaseError,
   Fragment,
-  baraqexRenderToString,
+  LifecycleEvents,
+  Link,
+  NavLink,
+  PureComponent,
+  Redirect,
+  Route,
+  Router,
+  RouterContext,
+  RouterError,
+  RouterProvider,
+  StoreContext,
+  StoreProvider,
+  Switch,
+  ValidationError,
+  WasmError,
+  applyPatches,
   batchUpdates,
+  calculatePatches,
   callWasmFunction,
+  camelCase,
+  capitalize,
+  clamp,
+  cleanupHooks,
+  cleanupRoot,
+  combineReducers,
+  createAction,
+  createClassComponent,
   createContext,
   createDevServer2 as createDevServer,
+  createElement,
+  createElementSync,
+  createEventBus,
   createProductionServer2 as createProductionServer,
+  createRoot,
+  createRootState,
   createServer2 as createServer,
+  createSlice,
+  createStore,
+  debounce,
+  deepClone,
+  deepEqual,
+  deepMerge,
+  deferred,
+  devTools,
+  diff,
+  emitAppDestroyed,
+  emitAppError,
+  emitAppInit,
+  emitAppMounted,
+  emitAppUpdated,
+  emitComponentCreated,
+  emitComponentError,
+  emitComponentMounted,
+  emitComponentUnmounted,
+  emitComponentUpdated,
+  emitRouterAfterChange,
+  emitRouterBeforeChange,
+  emitRouterError,
+  emitStoreAfterAction,
+  emitStoreBeforeAction,
+  emitStoreError,
+  emitStoreInitialized,
   ensureDirectory2 as ensureDirectory,
   errorHandler2 as errorHandler,
+  escapeHtml2 as escapeHtml,
+  eventBus,
+  fallbackRenderToString,
+  finishRender,
+  formatDate,
   generateDocument2 as generateDocument,
   generateErrorPage2 as generateErrorPage,
   generateLoadingPage2 as generateLoadingPage,
   generateToken2 as generateToken,
+  get,
+  getContextValue,
+  getCurrentRoot,
   getEnvironmentInfo2 as getEnvironmentInfo,
+  getIsBatching,
   getPagination2 as getPagination,
   getWasmFunctions,
+  groupBy,
+  hasRoot,
   hashString2 as hashString,
   hydrate,
   initNodeWasm3 as initNodeWasm,
   isDirectoryEmpty2 as isDirectoryEmpty,
+  isEmpty,
   isWasmReady,
   jsx,
-  jsx as jsxs,
+  jsxDEV,
+  jsxs,
+  kebabCase,
   loadGoWasm,
   loadGoWasmFromFile2 as loadGoWasmFromFile,
+  logger,
+  memoize,
   notFoundHandler2 as notFoundHandler,
+  omit,
+  onAppDestroyed,
+  onAppError,
+  onAppInit,
+  onAppMounted,
+  onAppUpdated,
+  onComponentCreated,
+  onComponentError,
+  onComponentMounted,
+  onComponentUnmounted,
+  onComponentUpdated,
+  onRouterAfterChange,
+  onRouterBeforeChange,
+  onRouterError,
+  onStoreAfterAction,
+  onStoreBeforeAction,
+  onStoreError,
+  onStoreInitialized,
+  patterns,
+  pick,
+  prepareRender,
   rateLimit2 as rateLimit,
   readJsonFile2 as readJsonFile,
   render,
   renderComponent2 as renderComponent,
-  renderToString3 as renderToString,
+  renderToStream,
+  renderToString,
+  renderToStringWithData,
   requestLogger2 as requestLogger,
+  retry,
   safeJsonParse2 as safeJsonParse,
   sendError2 as sendError,
   sendSuccess2 as sendSuccess,
-  server,
+  set,
+  setCurrentRoot,
+  shallowEqual,
+  shouldComponentUpdate,
+  sleep,
+  throttle,
+  thunk,
+  unescapeHtml,
+  useCallback,
   useContext,
+  useDispatch,
   useEffect,
   useErrorBoundary,
+  useEvent,
+  useField,
+  useForm,
   useGoWasm,
+  useId,
+  useLayoutEffect,
+  useLocation,
+  useMatch,
   useMemo,
+  useNavigate,
+  useParams,
+  useReducer,
   useRef,
+  useRouter,
+  useSearchParams,
+  useSelector,
   useState,
+  useStore,
+  uuid,
   validateFields2 as validateFields,
   validateFileUpload2 as validateFileUpload,
+  withErrorHandling,
   writeJsonFile2 as writeJsonFile
 };
 //# sourceMappingURL=index.js.map