elit 1.1.0 → 2.0.0

package/dist/cli.js

@@ -0,0 +1,2307 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "elit",
+      version: "2.0.0",
+      description: "Optimized lightweight library for creating DOM elements with reactive state",
+      main: "dist/index.js",
+      module: "dist/index.mjs",
+      types: "dist/index.d.ts",
+      bin: {
+        elit: "./dist/cli.js"
+      },
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.mjs",
+          require: "./dist/index.js"
+        },
+        "./dom": {
+          types: "./dist/dom.d.ts",
+          import: "./dist/dom.mjs",
+          require: "./dist/dom.js"
+        },
+        "./el": {
+          types: "./dist/el.d.ts",
+          import: "./dist/el.mjs",
+          require: "./dist/el.js"
+        },
+        "./router": {
+          types: "./dist/router.d.ts",
+          import: "./dist/router.mjs",
+          require: "./dist/router.js"
+        },
+        "./state": {
+          types: "./dist/state.d.ts",
+          import: "./dist/state.mjs",
+          require: "./dist/state.js"
+        },
+        "./style": {
+          types: "./dist/style.d.ts",
+          import: "./dist/style.mjs",
+          require: "./dist/style.js"
+        },
+        "./server": {
+          types: "./dist/server.d.ts",
+          import: "./dist/server.mjs",
+          require: "./dist/server.js"
+        },
+        "./hmr": {
+          types: "./dist/hmr.d.ts",
+          import: "./dist/hmr.mjs",
+          require: "./dist/hmr.js"
+        },
+        "./build": {
+          types: "./dist/build.d.ts",
+          import: "./dist/build.mjs",
+          require: "./dist/build.js"
+        }
+      },
+      scripts: {
+        build: "tsup",
+        dev: "tsup --watch",
+        typecheck: "tsc --noEmit",
+        "docs:dev": "npm run --prefix docs dev",
+        "docs:build": "npm run --prefix docs build",
+        "docs:preview": "npm run --prefix docs preview",
+        "docs:deploy": "npm run docs:build && gh-pages -d docs/dist"
+      },
+      keywords: [
+        "dom",
+        "reactive",
+        "state-management",
+        "ui",
+        "framework",
+        "typescript",
+        "lightweight",
+        "ssr",
+        "router",
+        "css-in-js",
+        "virtual-scrolling",
+        "hmr",
+        "hot-module-replacement",
+        "dev-server",
+        "development",
+        "websocket",
+        "rest-api",
+        "shared-state",
+        "real-time",
+        "build",
+        "bundler",
+        "esbuild"
+      ],
+      author: "",
+      license: "MIT",
+      repository: {
+        type: "git",
+        url: "https://github.com/d-osc/elit.git"
+      },
+      bugs: {
+        url: "https://github.com/d-osc/elit/issues"
+      },
+      homepage: "https://github.com/d-osc/elit#readme",
+      dependencies: {
+        chokidar: "^4.0.3",
+        esbuild: "^0.24.2",
+        "mime-types": "^2.1.35",
+        open: "^11.0.0",
+        ws: "^8.18.0"
+      },
+      devDependencies: {
+        "@types/mime-types": "^2.1.4",
+        "@types/node": "^22.0.0",
+        "@types/ws": "^8.5.13",
+        terser: "^5.44.1",
+        tsup: "^8.0.0",
+        typescript: "^5.3.0"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE"
+      ]
+    };
+  }
+});
+
+// src/config.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var CONFIG_FILES = [
+  "elit.config.ts",
+  "elit.config.js",
+  "elit.config.mjs",
+  "elit.config.cjs",
+  "elit.config.json"
+];
+function loadEnv(mode = "development", cwd = process.cwd()) {
+  const env = { MODE: mode };
+  const envFiles = [
+    `.env.${mode}.local`,
+    `.env.${mode}`,
+    `.env.local`,
+    `.env`
+  ];
+  for (const file of envFiles) {
+    const filePath = (0, import_path.resolve)(cwd, file);
+    if ((0, import_fs.existsSync)(filePath)) {
+      const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) continue;
+        const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/);
+        if (match) {
+          const [, key, value] = match;
+          let cleanValue = value.trim();
+          if (cleanValue.startsWith('"') && cleanValue.endsWith('"') || cleanValue.startsWith("'") && cleanValue.endsWith("'")) {
+            cleanValue = cleanValue.slice(1, -1);
+          }
+          if (!(key in env)) {
+            env[key] = cleanValue;
+          }
+        }
+      }
+    }
+  }
+  return env;
+}
+async function loadConfig(cwd = process.cwd()) {
+  for (const configFile of CONFIG_FILES) {
+    const configPath = (0, import_path.resolve)(cwd, configFile);
+    if ((0, import_fs.existsSync)(configPath)) {
+      try {
+        return await loadConfigFile(configPath);
+      } catch (error) {
+        console.error(`Error loading config file: ${configFile}`);
+        console.error(error);
+        throw error;
+      }
+    }
+  }
+  return null;
+}
+async function loadConfigFile(configPath) {
+  const ext = configPath.split(".").pop();
+  if (ext === "json") {
+    const content = (0, import_fs.readFileSync)(configPath, "utf-8");
+    return JSON.parse(content);
+  } else {
+    if (ext === "ts") {
+      try {
+        const { pathToFileURL } = await import("url");
+        const configModule = await import(pathToFileURL(configPath).href);
+        return configModule.default || configModule;
+      } catch {
+        console.error("TypeScript config files require tsx or ts-node to be installed.");
+        console.error("Install with: npm install -D tsx");
+        console.error("Or use a .js or .json config file instead.");
+        throw new Error("Cannot load TypeScript config without tsx/ts-node");
+      }
+    } else {
+      const { pathToFileURL } = await import("url");
+      const configModule = await import(pathToFileURL(configPath).href);
+      return configModule.default || configModule;
+    }
+  }
+}
+function mergeConfig(config, cliArgs) {
+  if (!config) {
+    return cliArgs;
+  }
+  return {
+    ...config,
+    ...Object.fromEntries(
+      Object.entries(cliArgs).filter(([_, v]) => v !== void 0)
+    )
+  };
+}
+
+// src/server.ts
+var import_http = require("http");
+var import_https = require("https");
+var import_ws = require("ws");
+var import_chokidar = require("chokidar");
+var import_promises = require("fs/promises");
+var import_path2 = require("path");
+var import_mime_types = require("mime-types");
+var import_esbuild = require("esbuild");
+
+// src/dom.ts
+var DomNode = class {
+  constructor() {
+    this.elementCache = /* @__PURE__ */ new WeakMap();
+    this.reactiveNodes = /* @__PURE__ */ new Map();
+  }
+  createElement(tagName, props = {}, children = []) {
+    return { tagName, props, children };
+  }
+  renderToDOM(vNode, parent) {
+    if (vNode == null || vNode === false) return;
+    if (typeof vNode !== "object") {
+      parent.appendChild(document.createTextNode(String(vNode)));
+      return;
+    }
+    const { tagName, props, children } = vNode;
+    const isSVG = tagName === "svg" || tagName[0] === "s" && tagName[1] === "v" && tagName[2] === "g" || parent.namespaceURI === "http://www.w3.org/2000/svg";
+    const el = isSVG ? document.createElementNS("http://www.w3.org/2000/svg", tagName.replace("svg", "").toLowerCase() || tagName) : document.createElement(tagName);
+    for (const key in props) {
+      const value = props[key];
+      if (value == null || value === false) continue;
+      const c = key.charCodeAt(0);
+      if (c === 99 && (key.length < 6 || key[5] === "N")) {
+        const classValue = Array.isArray(value) ? value.join(" ") : value;
+        isSVG ? el.setAttribute("class", classValue) : el.className = classValue;
+      } else if (c === 115 && key.length === 5) {
+        if (typeof value === "string") {
+          el.style.cssText = value;
+        } else {
+          const s = el.style;
+          for (const k in value) s[k] = value[k];
+        }
+      } else if (c === 111 && key.charCodeAt(1) === 110) {
+        el[key.toLowerCase()] = value;
+      } else if (c === 100 && key.length > 20) {
+        el.innerHTML = value.__html;
+      } else if (c === 114 && key.length === 3) {
+        setTimeout(() => {
+          typeof value === "function" ? value(el) : value.current = el;
+        }, 0);
+      } else {
+        el.setAttribute(key, value === true ? "" : String(value));
+      }
+    }
+    const len = children.length;
+    if (!len) {
+      parent.appendChild(el);
+      return;
+    }
+    const renderChildren = (target) => {
+      for (let i = 0; i < len; i++) {
+        const child = children[i];
+        if (child == null || child === false) continue;
+        if (Array.isArray(child)) {
+          for (let j = 0, cLen = child.length; j < cLen; j++) {
+            const c = child[j];
+            c != null && c !== false && this.renderToDOM(c, target);
+          }
+        } else {
+          this.renderToDOM(child, target);
+        }
+      }
+    };
+    if (len > 30) {
+      const fragment = document.createDocumentFragment();
+      renderChildren(fragment);
+      el.appendChild(fragment);
+    } else {
+      renderChildren(el);
+    }
+    parent.appendChild(el);
+  }
+  render(rootElement, vNode) {
+    const el = typeof rootElement === "string" ? document.getElementById(rootElement.replace("#", "")) : rootElement;
+    if (!el) {
+      throw new Error(`Element not found: ${rootElement}`);
+    }
+    if (vNode.children && vNode.children.length > 500) {
+      const fragment = document.createDocumentFragment();
+      this.renderToDOM(vNode, fragment);
+      el.appendChild(fragment);
+    } else {
+      this.renderToDOM(vNode, el);
+    }
+    return el;
+  }
+  batchRender(rootElement, vNodes) {
+    const el = typeof rootElement === "string" ? document.getElementById(rootElement.replace("#", "")) : rootElement;
+    if (!el) {
+      throw new Error(`Element not found: ${rootElement}`);
+    }
+    const len = vNodes.length;
+    if (len > 3e3) {
+      const fragment = document.createDocumentFragment();
+      let processed = 0;
+      const chunkSize = 1500;
+      const processChunk = () => {
+        const end = Math.min(processed + chunkSize, len);
+        for (let i = processed; i < end; i++) {
+          this.renderToDOM(vNodes[i], fragment);
+        }
+        processed = end;
+        if (processed >= len) {
+          el.appendChild(fragment);
+        } else {
+          requestAnimationFrame(processChunk);
+        }
+      };
+      processChunk();
+    } else {
+      const fragment = document.createDocumentFragment();
+      for (let i = 0; i < len; i++) {
+        this.renderToDOM(vNodes[i], fragment);
+      }
+      el.appendChild(fragment);
+    }
+    return el;
+  }
+  renderChunked(rootElement, vNodes, chunkSize = 5e3, onProgress) {
+    const el = typeof rootElement === "string" ? document.getElementById(rootElement.replace("#", "")) : rootElement;
+    if (!el) {
+      throw new Error(`Element not found: ${rootElement}`);
+    }
+    const len = vNodes.length;
+    let index = 0;
+    const renderChunk = () => {
+      const end = Math.min(index + chunkSize, len);
+      const fragment = document.createDocumentFragment();
+      for (let i = index; i < end; i++) {
+        this.renderToDOM(vNodes[i], fragment);
+      }
+      el.appendChild(fragment);
+      index = end;
+      if (onProgress) onProgress(index, len);
+      if (index < len) {
+        requestAnimationFrame(renderChunk);
+      }
+    };
+    requestAnimationFrame(renderChunk);
+    return el;
+  }
+  renderToHead(...vNodes) {
+    const head = document.head;
+    if (head) {
+      for (const vNode of vNodes.flat()) {
+        vNode && this.renderToDOM(vNode, head);
+      }
+    }
+    return head;
+  }
+  addStyle(cssText) {
+    const el = document.createElement("style");
+    el.textContent = cssText;
+    return document.head.appendChild(el);
+  }
+  addMeta(attrs) {
+    const el = document.createElement("meta");
+    for (const k in attrs) el.setAttribute(k, attrs[k]);
+    return document.head.appendChild(el);
+  }
+  addLink(attrs) {
+    const el = document.createElement("link");
+    for (const k in attrs) el.setAttribute(k, attrs[k]);
+    return document.head.appendChild(el);
+  }
+  setTitle(text) {
+    return document.title = text;
+  }
+  // Reactive State Management
+  createState(initialValue, options = {}) {
+    let value = initialValue;
+    const listeners = /* @__PURE__ */ new Set();
+    let updateTimer = null;
+    const { throttle = 0, deep = false } = options;
+    const notify = () => listeners.forEach((fn) => fn(value));
+    const scheduleUpdate = () => {
+      if (throttle > 0) {
+        if (!updateTimer) {
+          updateTimer = setTimeout(() => {
+            updateTimer = null;
+            notify();
+          }, throttle);
+        }
+      } else {
+        notify();
+      }
+    };
+    return {
+      get value() {
+        return value;
+      },
+      set value(newValue) {
+        const changed = deep ? JSON.stringify(value) !== JSON.stringify(newValue) : value !== newValue;
+        if (changed) {
+          value = newValue;
+          scheduleUpdate();
+        }
+      },
+      subscribe(fn) {
+        listeners.add(fn);
+        return () => listeners.delete(fn);
+      },
+      destroy() {
+        listeners.clear();
+        updateTimer && clearTimeout(updateTimer);
+      }
+    };
+  }
+  computed(states, computeFn) {
+    const values = states.map((s) => s.value);
+    const result = this.createState(computeFn(...values));
+    states.forEach((state, index) => {
+      state.subscribe((newValue) => {
+        values[index] = newValue;
+        result.value = computeFn(...values);
+      });
+    });
+    return result;
+  }
+  effect(stateFn) {
+    stateFn();
+  }
+  // Virtual scrolling helper for large lists
+  createVirtualList(container, items, renderItem, itemHeight = 50, bufferSize = 5) {
+    const viewportHeight = container.clientHeight;
+    const totalHeight = items.length * itemHeight;
+    let scrollTop = 0;
+    const getVisibleRange = () => {
+      const start = Math.max(0, Math.floor(scrollTop / itemHeight) - bufferSize);
+      const end = Math.min(items.length, Math.ceil((scrollTop + viewportHeight) / itemHeight) + bufferSize);
+      return { start, end };
+    };
+    const render = () => {
+      const { start, end } = getVisibleRange();
+      const wrapper = document.createElement("div");
+      wrapper.style.cssText = `height:${totalHeight}px;position:relative`;
+      for (let i = start; i < end; i++) {
+        const itemEl = document.createElement("div");
+        itemEl.style.cssText = `position:absolute;top:${i * itemHeight}px;height:${itemHeight}px;width:100%`;
+        this.renderToDOM(renderItem(items[i], i), itemEl);
+        wrapper.appendChild(itemEl);
+      }
+      container.innerHTML = "";
+      container.appendChild(wrapper);
+    };
+    const scrollHandler = () => {
+      scrollTop = container.scrollTop;
+      requestAnimationFrame(render);
+    };
+    container.addEventListener("scroll", scrollHandler);
+    render();
+    return {
+      render,
+      destroy: () => {
+        container.removeEventListener("scroll", scrollHandler);
+        container.innerHTML = "";
+      }
+    };
+  }
+  // Lazy load components
+  lazy(loadFn) {
+    let component = null;
+    let loading = false;
+    return async (...args) => {
+      if (!component && !loading) {
+        loading = true;
+        component = await loadFn();
+        loading = false;
+      }
+      return component ? component(...args) : { tagName: "div", props: { class: "loading" }, children: ["Loading..."] };
+    };
+  }
+  // Memory management - cleanup unused elements
+  cleanupUnusedElements(root) {
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+    const toRemove = [];
+    while (walker.nextNode()) {
+      const node = walker.currentNode;
+      if (node.id && node.id.startsWith("r") && !this.elementCache.has(node)) {
+        toRemove.push(node);
+      }
+    }
+    toRemove.forEach((el) => el.remove());
+    return toRemove.length;
+  }
+  // Server-Side Rendering - convert VNode to HTML string
+  renderToString(vNode, options = {}) {
+    const { pretty = false, indent = 0 } = options;
+    const indentStr = pretty ? "  ".repeat(indent) : "";
+    const newLine = pretty ? "\n" : "";
+    let resolvedVNode = this.resolveStateValue(vNode);
+    resolvedVNode = this.unwrapReactive(resolvedVNode);
+    if (Array.isArray(resolvedVNode)) {
+      return resolvedVNode.map((child) => this.renderToString(child, options)).join("");
+    }
+    if (typeof resolvedVNode !== "object" || resolvedVNode === null) {
+      if (resolvedVNode === null || resolvedVNode === void 0 || resolvedVNode === false) {
+        return "";
+      }
+      return this.escapeHtml(String(resolvedVNode));
+    }
+    const { tagName, props, children } = resolvedVNode;
+    const isSelfClosing = this.isSelfClosingTag(tagName);
+    let html = `${indentStr}<${tagName}`;
+    const attrs = this.propsToAttributes(props);
+    if (attrs) {
+      html += ` ${attrs}`;
+    }
+    if (isSelfClosing) {
+      html += ` />${newLine}`;
+      return html;
+    }
+    html += ">";
+    if (props.dangerouslySetInnerHTML) {
+      html += props.dangerouslySetInnerHTML.__html;
+      html += `</${tagName}>${newLine}`;
+      return html;
+    }
+    if (children && children.length > 0) {
+      const resolvedChildren = children.map((c) => {
+        const resolved = this.resolveStateValue(c);
+        return this.unwrapReactive(resolved);
+      });
+      const hasComplexChildren = resolvedChildren.some(
+        (c) => typeof c === "object" && c !== null && !Array.isArray(c) && "tagName" in c
+      );
+      if (pretty && hasComplexChildren) {
+        html += newLine;
+        for (const child of resolvedChildren) {
+          if (child == null || child === false) continue;
+          if (Array.isArray(child)) {
+            for (const c of child) {
+              if (c != null && c !== false) {
+                html += this.renderToString(c, { pretty, indent: indent + 1 });
+              }
+            }
+          } else {
+            html += this.renderToString(child, { pretty, indent: indent + 1 });
+          }
+        }
+        html += indentStr;
+      } else {
+        for (const child of resolvedChildren) {
+          if (child == null || child === false) continue;
+          if (Array.isArray(child)) {
+            for (const c of child) {
+              if (c != null && c !== false) {
+                html += this.renderToString(c, { pretty: false, indent: 0 });
+              }
+            }
+          } else {
+            html += this.renderToString(child, { pretty: false, indent: 0 });
+          }
+        }
+      }
+    }
+    html += `</${tagName}>${newLine}`;
+    return html;
+  }
+  resolveStateValue(value) {
+    if (value && typeof value === "object" && "value" in value && "subscribe" in value) {
+      return value.value;
+    }
+    return value;
+  }
+  isReactiveWrapper(vNode) {
+    if (!vNode || typeof vNode !== "object" || !vNode.tagName) {
+      return false;
+    }
+    return vNode.tagName === "span" && vNode.props?.id && typeof vNode.props.id === "string" && vNode.props.id.match(/^r[a-z0-9]{9}$/);
+  }
+  unwrapReactive(vNode) {
+    if (!this.isReactiveWrapper(vNode)) {
+      return vNode;
+    }
+    const children = vNode.children;
+    if (!children || children.length === 0) {
+      return "";
+    }
+    if (children.length === 1) {
+      const child = children[0];
+      if (child && typeof child === "object" && child.tagName === "span") {
+        const props = child.props;
+        const hasNoProps = !props || Object.keys(props).length === 0;
+        const hasSingleStringChild = child.children && child.children.length === 1 && typeof child.children[0] === "string";
+        if (hasNoProps && hasSingleStringChild) {
+          return child.children[0];
+        }
+      }
+      return this.unwrapReactive(child);
+    }
+    return children.map((c) => this.unwrapReactive(c));
+  }
+  escapeHtml(text) {
+    const htmlEscapes = {
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#x27;"
+    };
+    return text.replace(/[&<>"']/g, (char) => htmlEscapes[char]);
+  }
+  isSelfClosingTag(tagName) {
+    const selfClosingTags = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    return selfClosingTags.has(tagName.toLowerCase());
+  }
+  propsToAttributes(props) {
+    const attrs = [];
+    for (const key in props) {
+      if (key === "children" || key === "dangerouslySetInnerHTML" || key === "ref") {
+        continue;
+      }
+      let value = props[key];
+      value = this.resolveStateValue(value);
+      if (value == null || value === false) continue;
+      if (key.startsWith("on") && typeof value === "function") {
+        continue;
+      }
+      if (key === "className" || key === "class") {
+        const className = Array.isArray(value) ? value.join(" ") : value;
+        if (className) {
+          attrs.push(`class="${this.escapeHtml(String(className))}"`);
+        }
+        continue;
+      }
+      if (key === "style") {
+        const styleStr = this.styleToString(value);
+        if (styleStr) {
+          attrs.push(`style="${this.escapeHtml(styleStr)}"`);
+        }
+        continue;
+      }
+      if (value === true) {
+        attrs.push(key);
+        continue;
+      }
+      attrs.push(`${key}="${this.escapeHtml(String(value))}"`);
+    }
+    return attrs.join(" ");
+  }
+  styleToString(style) {
+    if (typeof style === "string") {
+      return style;
+    }
+    if (typeof style === "object" && style !== null) {
+      const styles = [];
+      for (const key in style) {
+        const cssKey = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+        styles.push(`${cssKey}:${style[key]}`);
+      }
+      return styles.join(";");
+    }
+    return "";
+  }
+  isState(value) {
+    return value && typeof value === "object" && "value" in value && "subscribe" in value && typeof value.subscribe === "function";
+  }
+  createReactiveChild(state, renderFn) {
+    const currentValue = renderFn(state.value);
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      const entry = { node: null, renderFn };
+      this.reactiveNodes.set(state, entry);
+      state.subscribe(() => {
+        if (entry.node && entry.node.parentNode) {
+          const newValue = renderFn(state.value);
+          entry.node.textContent = String(newValue ?? "");
+        }
+      });
+    }
+    return currentValue;
+  }
+  jsonToVNode(json) {
+    if (this.isState(json)) {
+      return this.createReactiveChild(json, (v) => v);
+    }
+    if (json == null || typeof json === "boolean") {
+      return json;
+    }
+    if (typeof json === "string" || typeof json === "number") {
+      return json;
+    }
+    const { tag, attributes = {}, children } = json;
+    const props = {};
+    for (const key in attributes) {
+      const value = attributes[key];
+      if (key === "class") {
+        props.className = this.isState(value) ? value.value : value;
+      } else {
+        props[key] = this.isState(value) ? value.value : value;
+      }
+    }
+    const childrenArray = [];
+    if (children != null) {
+      if (Array.isArray(children)) {
+        for (const child of children) {
+          if (this.isState(child)) {
+            childrenArray.push(this.createReactiveChild(child, (v) => v));
+          } else {
+            const converted = this.jsonToVNode(child);
+            if (converted != null && converted !== false) {
+              childrenArray.push(converted);
+            }
+          }
+        }
+      } else if (this.isState(children)) {
+        childrenArray.push(this.createReactiveChild(children, (v) => v));
+      } else if (typeof children === "object" && "tag" in children) {
+        const converted = this.jsonToVNode(children);
+        if (converted != null && converted !== false) {
+          childrenArray.push(converted);
+        }
+      } else {
+        childrenArray.push(children);
+      }
+    }
+    return { tagName: tag, props, children: childrenArray };
+  }
+  vNodeJsonToVNode(json) {
+    if (this.isState(json)) {
+      return this.createReactiveChild(json, (v) => v);
+    }
+    if (json == null || typeof json === "boolean") {
+      return json;
+    }
+    if (typeof json === "string" || typeof json === "number") {
+      return json;
+    }
+    const { tagName, props = {}, children = [] } = json;
+    const resolvedProps = {};
+    for (const key in props) {
+      const value = props[key];
+      resolvedProps[key] = this.isState(value) ? value.value : value;
+    }
+    const childrenArray = [];
+    for (const child of children) {
+      if (this.isState(child)) {
+        childrenArray.push(this.createReactiveChild(child, (v) => v));
+      } else {
+        const converted = this.vNodeJsonToVNode(child);
+        if (converted != null && converted !== false) {
+          childrenArray.push(converted);
+        }
+      }
+    }
+    return { tagName, props: resolvedProps, children: childrenArray };
+  }
+  renderJson(rootElement, json) {
+    const vNode = this.jsonToVNode(json);
+    if (!vNode || typeof vNode !== "object" || !("tagName" in vNode)) {
+      throw new Error("Invalid JSON structure");
+    }
+    return this.render(rootElement, vNode);
+  }
+  renderVNode(rootElement, json) {
+    const vNode = this.vNodeJsonToVNode(json);
+    if (!vNode || typeof vNode !== "object" || !("tagName" in vNode)) {
+      throw new Error("Invalid VNode JSON structure");
+    }
+    return this.render(rootElement, vNode);
+  }
+  renderJsonToString(json, options = {}) {
+    const vNode = this.jsonToVNode(json);
+    return this.renderToString(vNode, options);
+  }
+  renderVNodeToString(json, options = {}) {
+    const vNode = this.vNodeJsonToVNode(json);
+    return this.renderToString(vNode, options);
+  }
+  // Server-side rendering - Render complete HTML document VNode to document
+  renderServer(vNode) {
+    if (typeof vNode !== "object" || vNode === null || !("tagName" in vNode)) throw new Error("renderServer requires a VNode with html tag");
+    if (vNode.tagName !== "html") throw new Error("renderServer requires a VNode with html tag as root");
+    const htmlVNode = vNode;
+    let headVNode = null, bodyVNode = null;
+    for (const child of htmlVNode.children || []) {
+      if (typeof child === "object" && child !== null && "tagName" in child) {
+        if (child.tagName === "head") headVNode = child;
+        if (child.tagName === "body") bodyVNode = child;
+      }
+    }
+    if (htmlVNode.props) for (const k in htmlVNode.props) {
+      const v = htmlVNode.props[k];
+      if (v !== void 0 && v !== null && v !== false) document.documentElement.setAttribute(k, String(v));
+    }
+    if (headVNode) {
+      document.head.innerHTML = "";
+      for (const child of headVNode.children || []) this.renderToDOM(child, document.head);
+    }
+    if (bodyVNode) {
+      document.body.innerHTML = "";
+      if (bodyVNode.props) for (const k in bodyVNode.props) {
+        const v = bodyVNode.props[k];
+        if (v !== void 0 && v !== null && v !== false) document.body.setAttribute(k, String(v));
+      }
+      for (const child of bodyVNode.children || []) this.renderToDOM(child, document.body);
+    }
+  }
+  // Generate complete HTML document as string (for SSR)
+  renderToHTMLDocument(vNode, options = {}) {
+    const { title = "", meta = [], links = [], scripts = [], styles = [], lang = "en", head = "", bodyAttrs = {}, pretty = false } = options;
+    const nl = pretty ? "\n" : "";
+    const indent = pretty ? "  " : "";
+    const indent2 = pretty ? "    " : "";
+    let html = `<!DOCTYPE html>${nl}<html lang="${lang}">${nl}${indent}<head>${nl}${indent2}<meta charset="UTF-8">${nl}${indent2}<meta name="viewport" content="width=device-width, initial-scale=1.0">${nl}`;
+    if (title) html += `${indent2}<title>${this.escapeHtml(title)}</title>${nl}`;
+    for (const m of meta) {
+      html += `${indent2}<meta`;
+      for (const k in m) html += ` ${k}="${this.escapeHtml(m[k])}"`;
+      html += `>${nl}`;
+    }
+    for (const l of links) {
+      html += `${indent2}<link`;
+      for (const k in l) html += ` ${k}="${this.escapeHtml(l[k])}"`;
+      html += `>${nl}`;
+    }
+    for (const s of styles) {
+      if (s.href) {
+        html += `${indent2}<link rel="stylesheet" href="${this.escapeHtml(s.href)}">${nl}`;
+      } else if (s.content) {
+        html += `${indent2}<style>${s.content}</style>${nl}`;
+      }
+    }
+    if (head) html += head + nl;
+    html += `${indent}</head>${nl}${indent}<body`;
+    for (const k in bodyAttrs) html += ` ${k}="${this.escapeHtml(bodyAttrs[k])}"`;
+    html += `>${nl}`;
+    html += this.renderToString(vNode, { pretty, indent: 2 });
+    for (const script of scripts) {
+      html += `${indent2}<script`;
+      if (script.type) html += ` type="${this.escapeHtml(script.type)}"`;
+      if (script.async) html += ` async`;
+      if (script.defer) html += ` defer`;
+      if (script.src) {
+        html += ` src="${this.escapeHtml(script.src)}"></script>${nl}`;
+      } else if (script.content) {
+        html += `>${script.content}</script>${nl}`;
+      } else {
+        html += `></script>${nl}`;
+      }
+    }
+    html += `${indent}</body>${nl}</html>`;
+    return html;
+  }
+  // Expose elementCache for reactive updates
+  getElementCache() {
+    return this.elementCache;
+  }
+};
+var dom = new DomNode();
+
+// src/server.ts
+function rewritePath(path, pathRewrite) {
+  if (!pathRewrite) return path;
+  for (const [from, to] of Object.entries(pathRewrite)) {
+    const regex = new RegExp(from);
+    if (regex.test(path)) {
+      return path.replace(regex, to);
+    }
+  }
+  return path;
+}
+function createProxyHandler(proxyConfigs) {
+  return async (req, res) => {
+    const url = req.url || "/";
+    const path = url.split("?")[0];
+    const proxy = proxyConfigs.find((p) => path.startsWith(p.context));
+    if (!proxy) return false;
+    const { target, changeOrigin, pathRewrite, headers } = proxy;
+    try {
+      const targetUrl = new URL(target);
+      const isHttps = targetUrl.protocol === "https:";
+      const requestLib = isHttps ? import_https.request : import_http.request;
+      let proxyPath = rewritePath(url, pathRewrite);
+      const proxyReqOptions = {
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || (isHttps ? 443 : 80),
+        path: proxyPath,
+        method: req.method,
+        headers: {
+          ...req.headers,
+          ...headers || {}
+        }
+      };
+      if (changeOrigin) {
+        proxyReqOptions.headers.host = targetUrl.host;
+      }
+      delete proxyReqOptions.headers["host"];
+      const proxyReq = requestLib(proxyReqOptions, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+      });
+      proxyReq.on("error", (error) => {
+        console.error("[Proxy] Error proxying %s to %s:", url, target, error.message);
+        if (!res.headersSent) {
+          res.writeHead(502, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Bad Gateway", message: "Proxy error" }));
+        }
+      });
+      req.pipe(proxyReq);
+      return true;
+    } catch (error) {
+      console.error("[Proxy] Invalid proxy configuration for %s:", path, error);
+      return false;
+    }
+  };
+}
+var SharedState = class {
+  constructor(key, options) {
+    this.key = key;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.changeHandlers = /* @__PURE__ */ new Set();
+    this.options = options;
+    this._value = options.initial;
+  }
+  get value() {
+    return this._value;
+  }
+  set value(newValue) {
+    if (this.options.validate && !this.options.validate(newValue)) {
+      throw new Error(`Invalid state value for "${this.key}"`);
+    }
+    const oldValue = this._value;
+    this._value = newValue;
+    this.changeHandlers.forEach((handler) => {
+      handler(newValue, oldValue);
+    });
+    this.broadcast();
+  }
+  update(updater) {
+    this.value = updater(this._value);
+  }
+  subscribe(ws) {
+    this.listeners.add(ws);
+    this.sendTo(ws);
+  }
+  unsubscribe(ws) {
+    this.listeners.delete(ws);
+  }
+  onChange(handler) {
+    this.changeHandlers.add(handler);
+    return () => this.changeHandlers.delete(handler);
+  }
+  broadcast() {
+    const message = JSON.stringify({ type: "state:update", key: this.key, value: this._value, timestamp: Date.now() });
+    this.listeners.forEach((ws) => ws.readyState === import_ws.WebSocket.OPEN && ws.send(message));
+  }
+  sendTo(ws) {
+    if (ws.readyState === import_ws.WebSocket.OPEN) {
+      ws.send(JSON.stringify({ type: "state:init", key: this.key, value: this._value, timestamp: Date.now() }));
+    }
+  }
+  get subscriberCount() {
+    return this.listeners.size;
+  }
+  clear() {
+    this.listeners.clear();
+    this.changeHandlers.clear();
+  }
+};
+var StateManager = class {
+  constructor() {
+    this.states = /* @__PURE__ */ new Map();
+  }
+  create(key, options) {
+    if (this.states.has(key)) return this.states.get(key);
+    const state = new SharedState(key, options);
+    this.states.set(key, state);
+    return state;
+  }
+  get(key) {
+    return this.states.get(key);
+  }
+  has(key) {
+    return this.states.has(key);
+  }
+  delete(key) {
+    const state = this.states.get(key);
+    if (state) {
+      state.clear();
+      return this.states.delete(key);
+    }
+    return false;
+  }
+  subscribe(key, ws) {
+    this.states.get(key)?.subscribe(ws);
+  }
+  unsubscribe(key, ws) {
+    this.states.get(key)?.unsubscribe(ws);
+  }
+  unsubscribeAll(ws) {
+    this.states.forEach((state) => state.unsubscribe(ws));
+  }
+  handleStateChange(key, value) {
+    const state = this.states.get(key);
+    if (state) state.value = value;
+  }
+  keys() {
+    return Array.from(this.states.keys());
+  }
+  clear() {
+    this.states.forEach((state) => state.clear());
+    this.states.clear();
+  }
+};
+var defaultOptions = {
+  port: 3e3,
+  host: "localhost",
+  https: false,
+  open: true,
+  watch: ["**/*.ts", "**/*.js", "**/*.html", "**/*.css"],
+  ignore: ["node_modules/**", "dist/**", ".git/**", "**/*.d.ts"],
+  logging: true,
+  middleware: [],
+  worker: []
+};
+function createDevServer(options) {
+  const config = { ...defaultOptions, ...options };
+  const wsClients = /* @__PURE__ */ new Set();
+  const stateManager = new StateManager();
+  const clientsToNormalize = config.clients?.length ? config.clients : config.root ? [{ root: config.root, basePath: config.basePath || "", ssr: config.ssr, proxy: config.proxy }] : null;
+  if (!clientsToNormalize) throw new Error('DevServerOptions must include either "clients" array or "root" directory');
+  const normalizedClients = clientsToNormalize.map((client) => {
+    let basePath = client.basePath || "";
+    if (basePath) {
+      while (basePath.startsWith("/")) basePath = basePath.slice(1);
+      while (basePath.endsWith("/")) basePath = basePath.slice(0, -1);
+      basePath = basePath ? "/" + basePath : "";
+    }
+    return {
+      root: client.root,
+      basePath,
+      ssr: client.ssr,
+      proxyHandler: client.proxy ? createProxyHandler(client.proxy) : void 0
+    };
+  });
+  const globalProxyHandler = config.proxy ? createProxyHandler(config.proxy) : null;
+  const server = (0, import_http.createServer)(async (req, res) => {
+    const originalUrl = req.url || "/";
+    const matchedClient = normalizedClients.find((c) => c.basePath && originalUrl.startsWith(c.basePath)) || normalizedClients.find((c) => !c.basePath);
+    if (!matchedClient) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("404 Not Found");
+      return;
+    }
+    if (matchedClient.proxyHandler) {
+      try {
+        const proxied = await matchedClient.proxyHandler(req, res);
+        if (proxied) {
+          if (config.logging) console.log(`[Proxy] ${req.method} ${originalUrl} -> proxied (client-specific)`);
+          return;
+        }
+      } catch (error) {
+        console.error("[Proxy] Error (client-specific):", error);
+      }
+    }
+    if (globalProxyHandler) {
+      try {
+        const proxied = await globalProxyHandler(req, res);
+        if (proxied) {
+          if (config.logging) console.log(`[Proxy] ${req.method} ${originalUrl} -> proxied (global)`);
+          return;
+        }
+      } catch (error) {
+        console.error("[Proxy] Error (global):", error);
+      }
+    }
+    const url = matchedClient.basePath ? originalUrl.slice(matchedClient.basePath.length) || "/" : originalUrl;
+    if (config.api && url.startsWith("/api")) {
+      const handled = await config.api.handle(req, res);
+      if (handled) return;
+    }
+    let filePath = url === "/" ? "/index.html" : url;
+    filePath = filePath.split("?")[0];
+    if (config.logging && filePath === "/src/pages") {
+      console.log(`[DEBUG] Request for /src/pages received`);
+    }
+    if (filePath.includes("\0")) {
+      if (config.logging) console.log(`[403] Rejected path with null byte: ${filePath}`);
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("403 Forbidden");
+      return;
+    }
+    const isDistRequest = filePath.startsWith("/dist/");
+    let normalizedPath;
+    const tempPath = (0, import_path2.normalize)(filePath).replace(/\\/g, "/").replace(/^\/+/, "");
+    if (tempPath.includes("..")) {
+      if (config.logging) console.log(`[403] Path traversal attempt: ${filePath}`);
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("403 Forbidden");
+      return;
+    }
+    normalizedPath = tempPath;
+    const rootDir = await (0, import_promises.realpath)((0, import_path2.resolve)(matchedClient.root));
+    const baseDir = isDistRequest ? await (0, import_promises.realpath)((0, import_path2.resolve)(matchedClient.root, "..")) : rootDir;
+    let fullPath;
+    try {
+      fullPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath)));
+      if (!fullPath.startsWith(baseDir.endsWith(import_path2.sep) ? baseDir : baseDir + import_path2.sep)) {
+        if (config.logging) console.log(`[403] File access outside of root: ${fullPath}`);
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("403 Forbidden");
+        return;
+      }
+      if (config.logging && filePath === "/src/pages") {
+        console.log(`[DEBUG] Initial resolve succeeded: ${fullPath}`);
+      }
+    } catch (firstError) {
+      let resolvedPath;
+      if (config.logging && !normalizedPath.includes(".")) {
+        console.log(`[DEBUG] File not found: ${normalizedPath}, trying extensions...`);
+      }
+      if (normalizedPath.endsWith(".js")) {
+        const tsPath = normalizedPath.replace(/\.js$/, ".ts");
+        try {
+          const tsFullPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, tsPath)));
+          if (!tsFullPath.startsWith(baseDir.endsWith(import_path2.sep) ? baseDir : baseDir + import_path2.sep)) {
+            if (config.logging) console.log(`[403] Fallback TS path outside of root: ${tsFullPath}`);
+            res.writeHead(403, { "Content-Type": "text/plain" });
+            res.end("403 Forbidden");
+            return;
+          }
+          resolvedPath = tsFullPath;
+        } catch {
+        }
+      }
+      if (!resolvedPath && !normalizedPath.includes(".")) {
+        try {
+          resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath + ".ts")));
+          if (config.logging) console.log(`[DEBUG] Found: ${normalizedPath}.ts`);
+        } catch {
+          try {
+            resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath + ".js")));
+            if (config.logging) console.log(`[DEBUG] Found: ${normalizedPath}.js`);
+          } catch {
+            try {
+              resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath, "index.ts")));
+              if (config.logging) console.log(`[DEBUG] Found: ${normalizedPath}/index.ts`);
+            } catch {
+              try {
+                resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath, "index.js")));
+                if (config.logging) console.log(`[DEBUG] Found: ${normalizedPath}/index.js`);
+              } catch {
+                if (config.logging) console.log(`[DEBUG] Not found: all attempts failed for ${normalizedPath}`);
+              }
+            }
+          }
+        }
+      }
+      if (!resolvedPath) {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+        return;
+      }
+      fullPath = resolvedPath;
+    }
+    try {
+      const stats = await (0, import_promises.stat)(fullPath);
+      if (stats.isDirectory()) {
+        if (config.logging) console.log(`[DEBUG] Path is directory: ${fullPath}, trying index files...`);
+        let indexPath;
+        try {
+          indexPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(fullPath, "index.ts")));
+          if (config.logging) console.log(`[DEBUG] Found index.ts in directory`);
+        } catch {
+          try {
+            indexPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(fullPath, "index.js")));
+            if (config.logging) console.log(`[DEBUG] Found index.js in directory`);
+          } catch {
+            if (config.logging) console.log(`[DEBUG] No index file found in directory`);
+            res.writeHead(404, { "Content-Type": "text/plain" });
+            res.end("404 Not Found");
+            return;
+          }
+        }
+        fullPath = indexPath;
+      }
+    } catch (statError) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("404 Not Found");
+      return;
+    }
+    const parentDir = await (0, import_promises.realpath)((0, import_path2.resolve)(matchedClient.root, ".."));
+    const isInRoot = fullPath.startsWith(rootDir + import_path2.sep) || fullPath === rootDir;
+    const isInParent = isDistRequest && (fullPath.startsWith(parentDir + import_path2.sep) || fullPath === parentDir);
+    if (!isInRoot && !isInParent) {
+      if (config.logging) console.log(`[403] Path outside allowed directories: ${filePath}`);
+      res.writeHead(403, { "Content-Type": "text/plain" });
+      res.end("403 Forbidden");
+      return;
+    }
+    try {
+      const stats = await (0, import_promises.stat)(fullPath);
+      if (stats.isDirectory()) {
+        try {
+          const indexPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(fullPath, "index.html")));
+          if (!indexPath.startsWith(rootDir + import_path2.sep) && indexPath !== rootDir) {
+            res.writeHead(403, { "Content-Type": "text/plain" });
+            res.end("403 Forbidden");
+            return;
+          }
+          await (0, import_promises.stat)(indexPath);
+          return serveFile(indexPath, res, matchedClient);
+        } catch {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("404 Not Found");
+          return;
+        }
+      }
+      await serveFile(fullPath, res, matchedClient);
+    } catch (error) {
+      if (config.logging) console.log(`[404] ${filePath}`);
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("404 Not Found");
+    }
+  });
+  async function serveFile(filePath, res, client) {
+    try {
+      const rootDir = await (0, import_promises.realpath)((0, import_path2.resolve)(client.root));
+      const parentDir = await (0, import_promises.realpath)((0, import_path2.resolve)(client.root, ".."));
+      let resolvedPath;
+      try {
+        resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)(filePath));
+      } catch {
+        if (filePath.endsWith("index.html") && client.ssr) {
+          return serveSSR(res, client);
+        }
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("404 Not Found");
+        return;
+      }
+      const isInRoot = resolvedPath.startsWith(rootDir + import_path2.sep) || resolvedPath === rootDir;
+      const isInParentDist = resolvedPath.startsWith(parentDir + import_path2.sep + "dist" + import_path2.sep);
+      if (!isInRoot && !isInParentDist) {
+        if (config.logging) console.log(`[403] Attempted to serve file outside allowed directories: ${filePath}`);
+        res.writeHead(403, { "Content-Type": "text/plain" });
+        res.end("403 Forbidden");
+        return;
+      }
+      let content = await (0, import_promises.readFile)(resolvedPath);
+      const ext = (0, import_path2.extname)(resolvedPath);
+      let mimeType = (0, import_mime_types.lookup)(resolvedPath) || "application/octet-stream";
+      if (ext === ".ts" || ext === ".tsx") {
+        try {
+          const result = await (0, import_esbuild.build)({
+            stdin: {
+              contents: content.toString(),
+              loader: ext === ".tsx" ? "tsx" : "ts",
+              resolveDir: (0, import_path2.resolve)(resolvedPath, ".."),
+              sourcefile: resolvedPath
+            },
+            format: "esm",
+            target: "es2020",
+            write: false,
+            bundle: false,
+            sourcemap: "inline"
+          });
+          content = Buffer.from(result.outputFiles[0].text);
+          mimeType = "application/javascript";
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end(`TypeScript compilation error:
+${error}`);
+          if (config.logging) console.error("[500] TypeScript compilation error:", error);
+          return;
+        }
+      }
+      if (ext === ".html") {
+        const elitPath = client.basePath ? `${client.basePath}/dist/client.mjs` : "/dist/client.mjs";
+        const importMap = `<script type="importmap">
+{
+  "imports": {
+    "elit": "${elitPath}"
+  }
+}
+</script>`;
+        const hmrScript = `<script>(function(){const ws=new WebSocket('ws://${config.host}:${config.port}${client.basePath}');ws.onopen=()=>console.log('[Elit HMR] Connected');ws.onmessage=(e)=>{const d=JSON.parse(e.data);if(d.type==='update'){console.log('[Elit HMR] File updated:',d.path);window.location.reload()}else if(d.type==='reload'){console.log('[Elit HMR] Reloading...');window.location.reload()}else if(d.type==='error')console.error('[Elit HMR] Error:',d.error)};ws.onclose=()=>{console.log('[Elit HMR] Disconnected - Retrying...');setTimeout(()=>window.location.reload(),1000)};ws.onerror=(e)=>console.error('[Elit HMR] WebSocket error:',e)})();</script>`;
+        let html = content.toString();
+        if (client.basePath && client.basePath !== "/") {
+          const baseTag = `<base href="${client.basePath}/">`;
+          if (!html.includes("<base")) {
+            if (html.includes('<meta name="viewport"')) {
+              html = html.replace(
+                /<meta name="viewport"[^>]*>/,
+                (match) => `${match}
+  ${baseTag}`
+              );
+            } else if (html.includes("<head>")) {
+              html = html.replace("<head>", `<head>
+  ${baseTag}`);
+            }
+          }
+        }
+        html = html.includes("</head>") ? html.replace("</head>", `${importMap}</head>`) : html;
+        html = html.includes("</body>") ? html.replace("</body>", `${hmrScript}</body>`) : html + hmrScript;
+        content = Buffer.from(html);
+      }
+      const cacheControl = ext === ".html" || ext === ".ts" || ext === ".tsx" ? "no-cache, no-store, must-revalidate" : "public, max-age=31536000, immutable";
+      const headers = {
+        "Content-Type": mimeType,
+        "Cache-Control": cacheControl
+      };
+      const compressible = /^(text\/|application\/(javascript|json|xml))/.test(mimeType);
+      if (compressible && content.length > 1024) {
+        const { gzipSync } = require("zlib");
+        const compressed = gzipSync(content);
+        headers["Content-Encoding"] = "gzip";
+        headers["Content-Length"] = compressed.length;
+        res.writeHead(200, headers);
+        res.end(compressed);
+      } else {
+        res.writeHead(200, headers);
+        res.end(content);
+      }
+      if (config.logging) console.log(`[200] ${(0, import_path2.relative)(client.root, filePath)}`);
+    } catch (error) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("500 Internal Server Error");
+      if (config.logging) console.error("[500] Error reading file:", error);
+    }
+  }
+  function serveSSR(res, client) {
+    try {
+      if (!client.ssr) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+        res.end("SSR function not configured");
+        return;
+      }
+      const result = client.ssr();
+      let html;
+      if (typeof result === "string") {
+        html = result;
+      } else if (typeof result === "object" && result !== null && "tagName" in result) {
+        const vnode = result;
+        if (vnode.tagName === "html") {
+          html = dom.renderToString(vnode);
+        } else {
+          html = `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"></head><body>${dom.renderToString(vnode)}</body></html>`;
+        }
+      } else {
+        html = String(result);
+      }
+      const hmrScript = `<script>(function(){const ws=new WebSocket('ws://${config.host}:${config.port}${client.basePath}');ws.onopen=()=>console.log('[Elit HMR] Connected');ws.onmessage=(e)=>{const d=JSON.parse(e.data);if(d.type==='update'){console.log('[Elit HMR] File updated:',d.path);window.location.reload()}else if(d.type==='reload'){console.log('[Elit HMR] Reloading...');window.location.reload()}else if(d.type==='error')console.error('[Elit HMR] Error:',d.error)};ws.onclose=()=>{console.log('[Elit HMR] Disconnected - Retrying...');setTimeout(()=>window.location.reload(),1000)};ws.onerror=(e)=>console.error('[Elit HMR] WebSocket error:',e)})();</script>`;
+      html = html.includes("</body>") ? html.replace("</body>", `${hmrScript}</body>`) : html + hmrScript;
+      res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-cache, no-store, must-revalidate" });
+      res.end(html);
+      if (config.logging) console.log(`[200] SSR rendered`);
+    } catch (error) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("500 SSR Error");
+      if (config.logging) console.error("[500] SSR Error:", error);
+    }
+  }
+  const wss = new import_ws.WebSocketServer({ server });
+  wss.on("connection", (ws) => {
+    wsClients.add(ws);
+    const message = { type: "connected", timestamp: Date.now() };
+    ws.send(JSON.stringify(message));
+    if (config.logging) {
+      console.log("[HMR] Client connected");
+    }
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "state:subscribe") {
+          stateManager.subscribe(msg.key, ws);
+          if (config.logging) {
+            console.log(`[State] Client subscribed to "${msg.key}"`);
+          }
+        } else if (msg.type === "state:unsubscribe") {
+          stateManager.unsubscribe(msg.key, ws);
+          if (config.logging) {
+            console.log(`[State] Client unsubscribed from "${msg.key}"`);
+          }
+        } else if (msg.type === "state:change") {
+          stateManager.handleStateChange(msg.key, msg.value);
+          if (config.logging) {
+            console.log(`[State] Client updated "${msg.key}"`);
+          }
+        }
+      } catch (error) {
+        if (config.logging) {
+          console.error("[WebSocket] Message parse error:", error);
+        }
+      }
+    });
+    ws.on("close", () => {
+      wsClients.delete(ws);
+      stateManager.unsubscribeAll(ws);
+      if (config.logging) {
+        console.log("[HMR] Client disconnected");
+      }
+    });
+  });
+  const watchPaths = normalizedClients.flatMap(
+    (client) => config.watch.map((pattern) => (0, import_path2.join)(client.root, pattern))
+  );
+  const watcher = (0, import_chokidar.watch)(watchPaths, {
+    ignored: config.ignore,
+    ignoreInitial: true,
+    persistent: true
+  });
+  watcher.on("change", (path) => {
+    if (config.logging) console.log(`[HMR] File changed: ${path}`);
+    const message = JSON.stringify({ type: "update", path, timestamp: Date.now() });
+    wsClients.forEach((client) => client.readyState === import_ws.WebSocket.OPEN && client.send(message));
+  });
+  watcher.on("add", (path) => config.logging && console.log(`[HMR] File added: ${path}`));
+  watcher.on("unlink", (path) => config.logging && console.log(`[HMR] File removed: ${path}`));
+  server.setMaxListeners(20);
+  server.listen(config.port, config.host, () => {
+    if (config.logging) {
+      console.log("\n\u{1F680} Elit Dev Server");
+      console.log(`
+  \u279C Local:   http://${config.host}:${config.port}`);
+      if (normalizedClients.length > 1) {
+        console.log(`  \u279C Clients:`);
+        normalizedClients.forEach((client) => {
+          const clientUrl = `http://${config.host}:${config.port}${client.basePath}`;
+          console.log(`     - ${clientUrl} \u2192 ${client.root}`);
+        });
+      } else {
+        const client = normalizedClients[0];
+        console.log(`  \u279C Root:    ${client.root}`);
+        if (client.basePath) {
+          console.log(`  \u279C Base:    ${client.basePath}`);
+        }
+      }
+      console.log(`
+[HMR] Watching for file changes...
+`);
+    }
+    if (config.open && normalizedClients.length > 0) {
+      const firstClient = normalizedClients[0];
+      const url = `http://${config.host}:${config.port}${firstClient.basePath}`;
+      const open = async () => {
+        const { default: openBrowser } = await import("open");
+        await openBrowser(url);
+      };
+      open().catch(() => {
+      });
+    }
+  });
+  let isClosing = false;
+  const close = async () => {
+    if (isClosing) return;
+    isClosing = true;
+    if (config.logging) console.log("\n[Server] Shutting down...");
+    await watcher.close();
+    wss.close();
+    wsClients.forEach((client) => client.close());
+    wsClients.clear();
+    return new Promise((resolve4) => {
+      server.close(() => {
+        if (config.logging) console.log("[Server] Closed");
+        resolve4();
+      });
+    });
+  };
+  const primaryClient = normalizedClients[0];
+  const primaryUrl = `http://${config.host}:${config.port}${primaryClient.basePath}`;
+  return {
+    server,
+    wss,
+    url: primaryUrl,
+    state: stateManager,
+    close
+  };
+}
+
+// src/build.ts
+var import_esbuild2 = require("esbuild");
+var import_fs2 = require("fs");
+var import_path3 = require("path");
+var defaultOptions2 = {
+  outDir: "dist",
+  minify: true,
+  sourcemap: false,
+  target: "es2020",
+  format: "esm",
+  treeshake: true,
+  logging: true,
+  external: []
+};
+async function build2(options) {
+  const config = { ...defaultOptions2, ...options };
+  const startTime = Date.now();
+  if (!config.entry) {
+    throw new Error("Entry file is required");
+  }
+  const entryPath = (0, import_path3.resolve)(config.entry);
+  const outDir = (0, import_path3.resolve)(config.outDir);
+  let outFile = config.outFile;
+  if (!outFile) {
+    const baseName = (0, import_path3.basename)(config.entry, (0, import_path3.extname)(config.entry));
+    const ext = config.format === "cjs" ? ".cjs" : ".js";
+    outFile = baseName + ext;
+  }
+  const outputPath = (0, import_path3.join)(outDir, outFile);
+  try {
+    (0, import_fs2.mkdirSync)(outDir, { recursive: true });
+  } catch (error) {
+  }
+  if (config.logging) {
+    console.log("\n\u{1F528} Building...");
+    console.log(`  Entry:  ${config.entry}`);
+    console.log(`  Output: ${outputPath}`);
+    console.log(`  Format: ${config.format}`);
+    console.log(`  Target: ${config.target}`);
+  }
+  const browserOnlyPlugin = {
+    name: "browser-only",
+    setup(build3) {
+      build3.onResolve({ filter: /^(node:.*|fs|path|http|https|url|os|child_process|net|tls|crypto|stream|util|events|buffer|zlib|readline|process|assert|constants|dns|domain|punycode|querystring|repl|string_decoder|sys|timers|tty|v8|vm)$/ }, () => {
+        return { path: "node-builtin", external: true, sideEffects: false };
+      });
+      build3.onResolve({ filter: /^(chokidar|esbuild|mime-types|open|ws|fs\/promises)$/ }, () => {
+        return { path: "server-dep", external: true, sideEffects: false };
+      });
+      build3.onLoad({ filter: /[\\/](server|config|cli)\.ts$/ }, () => {
+        return {
+          contents: "export {}",
+          loader: "js"
+        };
+      });
+    }
+  };
+  try {
+    const platform = config.platform || (config.format === "cjs" ? "node" : "browser");
+    const plugins = platform === "browser" ? [browserOnlyPlugin] : [];
+    const define = {};
+    if (config.env) {
+      Object.entries(config.env).forEach(([key, value]) => {
+        if (key.startsWith("VITE_")) {
+          define[`import.meta.env.${key}`] = JSON.stringify(value);
+        }
+      });
+      if (config.env.MODE) {
+        define["import.meta.env.MODE"] = JSON.stringify(config.env.MODE);
+      }
+      define["import.meta.env.DEV"] = JSON.stringify(config.env.MODE !== "production");
+      define["import.meta.env.PROD"] = JSON.stringify(config.env.MODE === "production");
+    }
+    const result = await (0, import_esbuild2.build)({
+      entryPoints: [entryPath],
+      bundle: true,
+      outfile: outputPath,
+      format: config.format,
+      target: config.target,
+      minify: config.minify,
+      sourcemap: config.sourcemap,
+      external: config.external,
+      treeShaking: config.treeshake,
+      globalName: config.globalName,
+      platform,
+      plugins,
+      define,
+      logLevel: config.logging ? "info" : "silent",
+      metafile: true,
+      // Additional optimizations
+      ...config.minify && {
+        minifyWhitespace: true,
+        minifyIdentifiers: true,
+        minifySyntax: true,
+        legalComments: "none",
+        mangleProps: /^_/,
+        // Mangle properties starting with _
+        keepNames: false
+      }
+    });
+    const buildTime = Date.now() - startTime;
+    const stats = (0, import_fs2.statSync)(outputPath);
+    const size = stats.size;
+    if (config.logging) {
+      console.log(`
+\u2705 Build successful!`);
+      console.log(`  Time: ${buildTime}ms`);
+      console.log(`  Size: ${formatBytes(size)}`);
+      if (result.metafile) {
+        const inputs = Object.keys(result.metafile.inputs).length;
+        console.log(`  Files: ${inputs} input(s)`);
+        const outputKeys = Object.keys(result.metafile.outputs);
+        if (outputKeys.length > 0) {
+          const mainOutput = result.metafile.outputs[outputKeys[0]];
+          if (mainOutput && mainOutput.inputs) {
+            const sortedInputs = Object.entries(mainOutput.inputs).sort(([, a], [, b]) => b.bytesInOutput - a.bytesInOutput).slice(0, 5);
+            if (sortedInputs.length > 0) {
+              console.log("\n  \u{1F4CA} Top 5 largest modules:");
+              sortedInputs.forEach(([file, info]) => {
+                const fileName = file.split(/[/\\]/).pop() || file;
+                console.log(`     ${fileName.padEnd(30)} ${formatBytes(info.bytesInOutput)}`);
+              });
+            }
+          }
+        }
+      }
+    }
+    const buildResult = {
+      outputPath,
+      buildTime,
+      size
+    };
+    if (config.copy && config.copy.length > 0) {
+      if (config.logging) {
+        console.log("\n\u{1F4E6} Copying files...");
+      }
+      for (const copyItem of config.copy) {
+        const fromPath = (0, import_path3.resolve)(copyItem.from);
+        const toPath = (0, import_path3.resolve)(outDir, copyItem.to);
+        const targetDir = (0, import_path3.dirname)(toPath);
+        if (!(0, import_fs2.existsSync)(targetDir)) {
+          (0, import_fs2.mkdirSync)(targetDir, { recursive: true });
+        }
+        if ((0, import_fs2.existsSync)(fromPath)) {
+          if (copyItem.transform) {
+            const content = (0, import_fs2.readFileSync)(fromPath, "utf-8");
+            const transformed = copyItem.transform(content, config);
+            (0, import_fs2.writeFileSync)(toPath, transformed);
+          } else {
+            (0, import_fs2.copyFileSync)(fromPath, toPath);
+          }
+          if (config.logging) {
+            console.log(`  \u2713 ${copyItem.from} \u2192 ${copyItem.to}`);
+          }
+        } else if (config.logging) {
+          console.warn(`  \u26A0 File not found: ${copyItem.from}`);
+        }
+      }
+    }
+    if (config.onBuildEnd) {
+      await config.onBuildEnd(buildResult);
+    }
+    if (config.logging) {
+      console.log("");
+    }
+    return buildResult;
+  } catch (error) {
+    if (config.logging) {
+      console.error("\n\u274C Build failed:");
+      console.error(error);
+    }
+    throw error;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+
+// src/cli.ts
+var COMMANDS = ["dev", "build", "preview", "help", "version"];
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || "help";
+  if (!COMMANDS.includes(command)) {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+  }
+  switch (command) {
+    case "dev":
+      await runDev(args.slice(1));
+      break;
+    case "build":
+      await runBuild(args.slice(1));
+      break;
+    case "preview":
+      await runPreview(args.slice(1));
+      break;
+    case "version":
+      printVersion();
+      break;
+    case "help":
+    default:
+      printHelp();
+      break;
+  }
+}
+async function runDev(args) {
+  const cliOptions = parseDevArgs(args);
+  const config = await loadConfig();
+  const options = config?.dev ? mergeConfig(config.dev, cliOptions) : cliOptions;
+  if (!options.root && (!options.clients || options.clients.length === 0)) {
+    options.root = process.cwd();
+  }
+  const devServer = createDevServer(options);
+  const shutdown = async () => {
+    console.log("\n[Server] Shutting down...");
+    await devServer.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function runBuild(args) {
+  const cliOptions = parseBuildArgs(args);
+  const config = await loadConfig();
+  const mode = process.env.MODE || "production";
+  const env = loadEnv(mode);
+  if (config?.build) {
+    const builds = Array.isArray(config.build) ? config.build : [config.build];
+    if (Object.keys(cliOptions).length > 0) {
+      const options = mergeConfig(builds[0] || {}, cliOptions);
+      if (!options.env) {
+        options.env = env;
+      }
+      if (!options.entry) {
+        console.error("Error: Entry file is required");
+        console.error("Specify in config file or use --entry <file>");
+        process.exit(1);
+      }
+      try {
+        await build2(options);
+      } catch (error) {
+        process.exit(1);
+      }
+    } else {
+      console.log(`Building ${builds.length} ${builds.length === 1 ? "entry" : "entries"}...
+`);
+      for (let i = 0; i < builds.length; i++) {
+        const buildConfig = builds[i];
+        if (!buildConfig.env) {
+          buildConfig.env = env;
+        }
+        if (!buildConfig.entry) {
+          console.error(`Error: Entry file is required for build #${i + 1}`);
+          process.exit(1);
+        }
+        console.log(`[${i + 1}/${builds.length}] Building ${buildConfig.entry}...`);
+        try {
+          await build2(buildConfig);
+        } catch (error) {
+          console.error(`Build #${i + 1} failed`);
+          process.exit(1);
+        }
+        if (i < builds.length - 1) {
+          console.log("");
+        }
+      }
+      console.log(`
+\u2713 All ${builds.length} builds completed successfully`);
+    }
+  } else {
+    const options = cliOptions;
+    if (!options.env) {
+      options.env = env;
+    }
+    if (!options.entry) {
+      console.error("Error: Entry file is required");
+      console.error("Specify in config file or use --entry <file>");
+      process.exit(1);
+    }
+    try {
+      await build2(options);
+    } catch (error) {
+      process.exit(1);
+    }
+  }
+}
+async function runPreview(args) {
+  const cliOptions = parsePreviewArgs(args);
+  const config = await loadConfig();
+  const previewConfig = config?.preview || {};
+  const mergedOptions = {
+    ...previewConfig,
+    ...Object.fromEntries(
+      Object.entries(cliOptions).filter(([_, v]) => v !== void 0)
+    )
+  };
+  const options = {
+    port: mergedOptions.port || 4173,
+    host: mergedOptions.host || "localhost",
+    open: mergedOptions.open ?? true,
+    logging: mergedOptions.logging ?? true
+  };
+  if (mergedOptions.clients && mergedOptions.clients.length > 0) {
+    options.clients = mergedOptions.clients;
+    console.log("Starting preview server with multiple clients...");
+    console.log(`  Clients: ${mergedOptions.clients.length}`);
+    mergedOptions.clients.forEach((client, i) => {
+      console.log(`    ${i + 1}. ${client.basePath} -> ${client.root}`);
+    });
+  } else {
+    const buildConfig = config?.build;
+    const defaultOutDir = Array.isArray(buildConfig) ? buildConfig[0]?.outDir : buildConfig?.outDir;
+    options.root = mergedOptions.root || defaultOutDir || "dist";
+    options.basePath = mergedOptions.basePath;
+    console.log("Starting preview server...");
+    console.log(`  Root:  ${options.root}`);
+  }
+  if (mergedOptions.proxy && mergedOptions.proxy.length > 0) {
+    options.proxy = mergedOptions.proxy;
+  }
+  if (mergedOptions.worker && mergedOptions.worker.length > 0) {
+    options.worker = mergedOptions.worker;
+  }
+  if (mergedOptions.api) {
+    options.api = mergedOptions.api;
+  }
+  if (mergedOptions.https) {
+    options.https = mergedOptions.https;
+  }
+  if (mergedOptions.middleware) {
+    options.middleware = mergedOptions.middleware;
+  }
+  if (mergedOptions.ssr) {
+    options.ssr = mergedOptions.ssr;
+  }
+  const devServer = createDevServer(options);
+  const shutdown = async () => {
+    console.log("\n[Server] Shutting down...");
+    await devServer.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+function parseDevArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "-p":
+      case "--port":
+        options.port = parseInt(next, 10);
+        i++;
+        break;
+      case "-h":
+      case "--host":
+        options.host = next;
+        i++;
+        break;
+      case "-r":
+      case "--root":
+        options.root = next;
+        i++;
+        break;
+      case "--no-open":
+        options.open = false;
+        break;
+      case "--silent":
+        options.logging = false;
+        break;
+    }
+  }
+  return options;
+}
+function parseBuildArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "-e":
+      case "--entry":
+        options.entry = next;
+        i++;
+        break;
+      case "-o":
+      case "--out-dir":
+        options.outDir = next;
+        i++;
+        break;
+      case "--no-minify":
+        options.minify = false;
+        break;
+      case "--sourcemap":
+        options.sourcemap = true;
+        break;
+      case "-f":
+      case "--format":
+        options.format = next;
+        i++;
+        break;
+      case "--silent":
+        options.logging = false;
+        break;
+    }
+  }
+  return options;
+}
+function parsePreviewArgs(args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const next = args[i + 1];
+    switch (arg) {
+      case "-p":
+      case "--port":
+        options.port = parseInt(next, 10);
+        i++;
+        break;
+      case "-h":
+      case "--host":
+        options.host = next;
+        i++;
+        break;
+      case "-r":
+      case "--root":
+        options.root = next;
+        i++;
+        break;
+      case "-b":
+      case "--base-path":
+        options.basePath = next;
+        i++;
+        break;
+      case "--no-open":
+        options.open = false;
+        break;
+      case "--silent":
+        options.logging = false;
+        break;
+    }
+  }
+  return options;
+}
+function printHelp() {
+  console.log(`
+Elit - Modern Web Development Toolkit
+
+Usage:
+  elit <command> [options]
+
+Commands:
+  dev       Start development server
+  build     Build for production
+  preview   Preview production build
+  version   Show version number
+  help      Show this help message
+
+Dev Options:
+  -p, --port <number>    Port to run server on (default: 3000)
+  -h, --host <string>    Host to bind to (default: localhost)
+  -r, --root <path>      Root directory to serve
+  --no-open              Don't open browser automatically
+  --silent               Disable logging
+
+Build Options:
+  -e, --entry <file>     Entry file to build (required)
+  -o, --out-dir <dir>    Output directory (default: dist)
+  -f, --format <format>  Output format: esm, cjs, iife (default: esm)
+  --no-minify            Disable minification
+  --sourcemap            Generate sourcemap
+  --silent               Disable logging
+
+Note: Build configuration supports both single and multiple builds:
+      - Single build: build: { entry: 'src/app.ts', outDir: 'dist' }
+      - Multiple builds: build: [{ entry: 'src/app1.ts' }, { entry: 'src/app2.ts' }]
+      When using array, all builds run sequentially.
+
+Preview Options:
+  -p, --port <number>      Port to run server on (default: 4173)
+  -h, --host <string>      Host to bind to (default: localhost)
+  -r, --root <dir>         Root directory to serve (default: dist or build.outDir)
+  -b, --base-path <path>   Base path for the application
+  --no-open                Don't open browser automatically
+  --silent                 Disable logging
+
+Note: Preview mode has full feature parity with dev mode:
+      - Single root and multi-client configurations (use clients[] in config)
+      - REST API endpoints (use api option in config)
+      - Proxy forwarding and Web Workers
+      - HTTPS support, custom middleware, and SSR
+
+Config File:
+  Create elit.config.ts, elit.config.js, or elit.config.json in project root
+
+Proxy Configuration:
+  Configure proxy in the config file to forward requests to backend servers.
+  Supports both global proxy (applies to all clients) and client-specific proxy.
+
+  Options:
+    - context: Path prefix to match (required, e.g., '/api', '/graphql')
+    - target: Backend server URL (required, e.g., 'http://localhost:8080')
+    - changeOrigin: Change the origin header to match target (default: false)
+    - pathRewrite: Rewrite request paths (e.g., { '^/api': '/v1/api' })
+    - headers: Add custom headers to proxied requests
+    - ws: Enable WebSocket proxying (default: false)
+
+  Proxy Priority:
+    1. Client-specific proxy (defined in clients[].proxy)
+    2. Global proxy (defined in dev.proxy)
+    The first matching proxy configuration will be used.
+
+Worker Configuration:
+  Configure Web Workers in the config file for background processing.
+  Supports both global workers (applies to all clients) and client-specific workers.
+
+  Options:
+    - path: Worker script path relative to root directory (required)
+    - name: Worker name/identifier (optional, defaults to filename)
+    - type: Worker type - 'module' (ESM) or 'classic' (default: 'module')
+
+  Worker Priority:
+    1. Client-specific workers (defined in clients[].worker)
+    2. Global workers (defined in dev.worker or preview.worker)
+    Both global and client-specific workers will be loaded.
+
+API and Middleware Configuration:
+  Configure REST API endpoints and custom middleware per client or globally.
+  Supports both global configuration and client-specific configuration.
+
+  Client-specific API and Middleware:
+    - Each client can have its own API router (clients[].api)
+    - Each client can have its own middleware chain (clients[].middleware)
+    - Client-specific configuration is isolated to that client's routes
+    - API paths are automatically prefixed with the client's basePath
+      Example: If basePath is '/app1' and route is '/api/health',
+               the full path will be '/app1/api/health'
+
+  Priority:
+    1. Client-specific middleware runs first (defined in clients[].middleware)
+    2. Global middleware runs second (defined in dev.middleware or preview.middleware)
+    3. Client-specific API routes are matched (defined in clients[].api)
+    4. Global API routes are matched (defined in dev.api or preview.api)
+
+Examples:
+  elit dev
+  elit dev --port 8080
+  elit build --entry src/app.ts
+  elit preview
+  elit preview --port 5000
+
+Config file example (elit.config.ts):
+  export default {
+    dev: {
+      port: 3000,
+      clients: [
+        {
+          root: './app1',
+          basePath: '/app1',
+          proxy: [
+            {
+              context: '/api',
+              target: 'http://localhost:8080',
+              changeOrigin: true
+            }
+          ],
+          worker: [
+            {
+              path: 'workers/data-processor.js',
+              name: 'dataProcessor',
+              type: 'module'
+            }
+          ],
+          // API routes are prefixed with basePath
+          // This route becomes: /app1/api/health
+          api: router()
+            .get('/api/health', (req, res) => {
+              res.json({ status: 'ok', app: 'app1' });
+            }),
+          middleware: [
+            (req, res, next) => {
+              console.log('App1 middleware:', req.url);
+              next();
+            }
+          ]
+        },
+        {
+          root: './app2',
+          basePath: '/app2',
+          proxy: [
+            {
+              context: '/graphql',
+              target: 'http://localhost:4000',
+              changeOrigin: true
+            }
+          ],
+          worker: [
+            {
+              path: 'workers/image-worker.js',
+              type: 'module'
+            }
+          ],
+          // API routes are prefixed with basePath
+          // This route becomes: /app2/api/status
+          api: router()
+            .get('/api/status', (req, res) => {
+              res.json({ status: 'running', app: 'app2' });
+            }),
+          middleware: [
+            (req, res, next) => {
+              console.log('App2 middleware:', req.url);
+              next();
+            }
+          ]
+        }
+      ],
+      // Global proxy (applies to all clients)
+      proxy: [
+        {
+          context: '/shared-api',
+          target: 'http://localhost:9000',
+          changeOrigin: true
+        }
+      ],
+      // Global workers (applies to all clients)
+      worker: [
+        {
+          path: 'workers/shared-worker.js',
+          name: 'sharedWorker',
+          type: 'module'
+        }
+      ]
+    },
+    // Single build configuration
+    build: {
+      entry: 'src/app.ts',
+      outDir: 'dist',
+      format: 'esm'
+    },
+    // Alternative: Multiple builds
+    // build: [
+    //   {
+    //     entry: 'src/app1.ts',
+    //     outDir: 'dist/app1',
+    //     outFile: 'app1.js',
+    //     format: 'esm',
+    //     minify: true
+    //   },
+    //   {
+    //     entry: 'src/app2.ts',
+    //     outDir: 'dist/app2',
+    //     outFile: 'app2.js',
+    //     format: 'esm',
+    //     minify: true
+    //   },
+    //   {
+    //     entry: 'src/worker.ts',
+    //     outDir: 'dist/workers',
+    //     outFile: 'worker.js',
+    //     format: 'esm',
+    //     platform: 'browser'
+    //   }
+    // ],
+    preview: {
+      port: 4173,
+      // Single client preview
+      root: 'dist',
+      basePath: '/app',
+      https: false,
+      // API router (import from elit/server)
+      api: router()
+        .get('/api/data', (req, res) => {
+          res.json({ message: 'Hello from preview API' });
+        }),
+      // Custom middleware
+      middleware: [
+        (req, res, next) => {
+          console.log('Preview request:', req.url);
+          next();
+        }
+      ],
+      // SSR render function
+      ssr: () => '<h1>Server-rendered content</h1>',
+      proxy: [
+        {
+          context: '/api',
+          target: 'http://localhost:8080'
+        }
+      ],
+      worker: [
+        {
+          path: 'workers/cache-worker.js',
+          type: 'module'
+        }
+      ]
+      // Multi-client preview (alternative)
+      // clients: [
+      //   {
+      //     root: './dist/app1',
+      //     basePath: '/app1',
+      //     proxy: [
+      //       {
+      //         context: '/api',
+      //         target: 'http://localhost:8080'
+      //       }
+      //     ],
+      //     worker: [
+      //       {
+      //         path: 'workers/app1-worker.js',
+      //         type: 'module'
+      //       }
+      //     ],
+      //     api: router()
+      //       .get('/api/health', (req, res) => {
+      //         res.json({ status: 'ok', app: 'app1' });
+      //       }),
+      //     middleware: [
+      //       (req, res, next) => {
+      //         console.log('App1 request:', req.url);
+      //         next();
+      //       }
+      //     ]
+      //   },
+      //   {
+      //     root: './dist/app2',
+      //     basePath: '/app2',
+      //     worker: [
+      //       {
+      //         path: 'workers/app2-worker.js',
+      //         type: 'module'
+      //       }
+      //     ],
+      //     api: router()
+      //       .get('/api/status', (req, res) => {
+      //         res.json({ status: 'running', app: 'app2' });
+      //       }),
+      //     middleware: [
+      //       (req, res, next) => {
+      //         console.log('App2 request:', req.url);
+      //         next();
+      //       }
+      //     ]
+      //   }
+      // ]
+    }
+  }
+  `);
+}
+function printVersion() {
+  const pkg = require_package();
+  console.log(`elit v${pkg.version}`);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});