elit 2.0.1 → 3.0.1

package/dist/cli.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -7,9 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -26,13 +32,1387 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime.ts
+var runtime, isNode, isBun, isDeno;
+var init_runtime = __esm({
+  "src/runtime.ts"() {
+    "use strict";
+    runtime = (() => {
+      if (typeof Deno !== "undefined") return "deno";
+      if (typeof Bun !== "undefined") return "bun";
+      return "node";
+    })();
+    isNode = runtime === "node";
+    isBun = runtime === "bun";
+    isDeno = runtime === "deno";
+  }
+});
+
+// src/fs.ts
+var fs_exports = {};
+__export(fs_exports, {
+  appendFile: () => appendFile,
+  appendFileSync: () => appendFileSync,
+  copyFile: () => copyFile,
+  copyFileSync: () => copyFileSync,
+  default: () => fs_default,
+  exists: () => exists,
+  existsSync: () => existsSync,
+  getRuntime: () => getRuntime,
+  mkdir: () => mkdir,
+  mkdirSync: () => mkdirSync,
+  promises: () => promises,
+  readFile: () => readFile,
+  readFileSync: () => readFileSync,
+  readdir: () => readdir,
+  readdirSync: () => readdirSync,
+  realpath: () => realpath,
+  realpathSync: () => realpathSync,
+  rename: () => rename,
+  renameSync: () => renameSync,
+  rmdir: () => rmdir,
+  rmdirSync: () => rmdirSync,
+  stat: () => stat,
+  statSync: () => statSync,
+  unlink: () => unlink,
+  unlinkSync: () => unlinkSync,
+  writeFile: () => writeFile,
+  writeFileSync: () => writeFileSync
+});
+function parseOptions(options, defaultValue) {
+  return typeof options === "string" ? { encoding: options } : options || defaultValue;
+}
+function decodeContent(content, encoding) {
+  if (encoding) {
+    return new TextDecoder(encoding).decode(content);
+  }
+  return Buffer.from(content instanceof ArrayBuffer ? new Uint8Array(content) : content);
+}
+function dataToUint8Array(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  if (data instanceof Buffer) {
+    return new Uint8Array(data);
+  }
+  return data;
+}
+function processDenoEntries(iterator, withFileTypes) {
+  const entries = [];
+  for (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function processDenoEntriesAsync(iterator, withFileTypes) {
+  const entries = [];
+  for await (const entry of iterator) {
+    if (withFileTypes) {
+      entries.push(createDirentFromDenoEntry(entry));
+    } else {
+      entries.push(entry.name);
+    }
+  }
+  return entries;
+}
+async function readFile(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readFile(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = await file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = await Deno.readFile(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readFileSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readFileSync(path, opts);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const content = file.arrayBuffer();
+    return decodeContent(content, opts.encoding);
+  } else if (isDeno) {
+    const content = Deno.readFileSync(path);
+    return decodeContent(content, opts.encoding);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function writeFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.writeFile(path, data, opts);
+  } else if (isBun) {
+    await Bun.write(path, data);
+  } else if (isDeno) {
+    await Deno.writeFile(path, dataToUint8Array(data));
+  }
+}
+function writeFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.writeFileSync(path, data, opts);
+  } else if (isBun) {
+    Bun.write(path, data);
+  } else if (isDeno) {
+    Deno.writeFileSync(path, dataToUint8Array(data));
+  }
+}
+async function appendFile(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.appendFile(path, data, opts);
+  } else {
+    if (await exists(path)) {
+      const existing = await readFile(path);
+      const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+      await writeFile(path, combined, opts);
+    } else {
+      await writeFile(path, data, opts);
+    }
+  }
+}
+function appendFileSync(path, data, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    fs.appendFileSync(path, data, opts);
+  } else {
+    if (existsSync(path)) {
+      const existing = readFileSync(path);
+      const combined = Buffer.isBuffer(existing) ? Buffer.concat([existing, Buffer.isBuffer(data) ? data : Buffer.from(data)]) : existing + (Buffer.isBuffer(data) ? data.toString() : data);
+      writeFileSync(path, combined, opts);
+    } else {
+      writeFileSync(path, data, opts);
+    }
+  }
+}
+async function exists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function existsSync(path) {
+  try {
+    statSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function stat(path) {
+  if (isNode) {
+    return fsPromises.stat(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    const exists2 = await file.exists();
+    if (!exists2) {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = await Deno.stat(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+function statSync(path) {
+  if (isNode) {
+    return fs.statSync(path);
+  } else if (isBun) {
+    const file = Bun.file(path);
+    const size = file.size;
+    try {
+      file.arrayBuffer();
+    } catch {
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
+    }
+    return createStatsObject(path, size, false);
+  } else if (isDeno) {
+    const info = Deno.statSync(path);
+    return createStatsFromDenoFileInfo(info);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function mkdir(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    await fsPromises.mkdir(path, opts);
+  } else if (isBun) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    await Deno.mkdir(path, { recursive: opts.recursive });
+  }
+}
+function mkdirSync(path, options) {
+  const opts = typeof options === "number" ? { mode: options } : options || {};
+  if (isNode) {
+    fs.mkdirSync(path, opts);
+  } else if (isBun) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  } else if (isDeno) {
+    Deno.mkdirSync(path, { recursive: opts.recursive });
+  }
+}
+async function readdir(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fsPromises.readdir(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+function readdirSync(path, options) {
+  const opts = parseOptions(options, {});
+  if (isNode) {
+    return fs.readdirSync(path, opts);
+  } else if (isBunOrDeno) {
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
+  }
+  throw new Error("Unsupported runtime");
+}
+async function unlink(path) {
+  if (isNode) {
+    return fsPromises.unlink(path);
+  } else if (isBun) {
+    await Deno.remove(path);
+  } else if (isDeno) {
+    await Deno.remove(path);
+  }
+}
+function unlinkSync(path) {
+  if (isNode) {
+    fs.unlinkSync(path);
+  } else if (isBun) {
+    Deno.removeSync(path);
+  } else if (isDeno) {
+    Deno.removeSync(path);
+  }
+}
+async function rmdir(path, options) {
+  if (isNode) {
+    return fsPromises.rmdir(path, options);
+  } else if (isBun) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    await Deno.remove(path, { recursive: options?.recursive });
+  }
+}
+function rmdirSync(path, options) {
+  if (isNode) {
+    fs.rmdirSync(path, options);
+  } else if (isBun) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  } else if (isDeno) {
+    Deno.removeSync(path, { recursive: options?.recursive });
+  }
+}
+async function rename(oldPath, newPath) {
+  if (isNode) {
+    return fsPromises.rename(oldPath, newPath);
+  } else if (isBun) {
+    await Deno.rename(oldPath, newPath);
+  } else if (isDeno) {
+    await Deno.rename(oldPath, newPath);
+  }
+}
+function renameSync(oldPath, newPath) {
+  if (isNode) {
+    fs.renameSync(oldPath, newPath);
+  } else if (isBun) {
+    Deno.renameSync(oldPath, newPath);
+  } else if (isDeno) {
+    Deno.renameSync(oldPath, newPath);
+  }
+}
+async function copyFile(src, dest, flags) {
+  if (isNode) {
+    return fsPromises.copyFile(src, dest, flags);
+  } else if (isBun) {
+    await Deno.copyFile(src, dest);
+  } else if (isDeno) {
+    await Deno.copyFile(src, dest);
+  }
+}
+function copyFileSync(src, dest, flags) {
+  if (isNode) {
+    fs.copyFileSync(src, dest, flags);
+  } else if (isBun) {
+    Deno.copyFileSync(src, dest);
+  } else if (isDeno) {
+    Deno.copyFileSync(src, dest);
+  }
+}
+async function realpath(path, options) {
+  if (isNode) {
+    return fsPromises.realpath(path, options);
+  } else if (isBun) {
+    const fs2 = require("fs/promises");
+    return fs2.realpath(path, options);
+  } else if (isDeno) {
+    return await Deno.realPath(path);
+  }
+  return path;
+}
+function realpathSync(path, options) {
+  if (isNode) {
+    return fs.realpathSync(path, options);
+  } else if (isBun) {
+    const fs2 = require("fs");
+    return fs2.realpathSync(path, options);
+  } else if (isDeno) {
+    return Deno.realPathSync(path);
+  }
+  return path;
+}
+function createStatsObject(_path, size, isDir) {
+  const now = Date.now();
+  return {
+    isFile: () => !isDir,
+    isDirectory: () => isDir,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: 0,
+    ino: 0,
+    mode: isDir ? 16877 : 33188,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size,
+    blksize: 4096,
+    blocks: Math.ceil(size / 512),
+    atimeMs: now,
+    mtimeMs: now,
+    ctimeMs: now,
+    birthtimeMs: now,
+    atime: new Date(now),
+    mtime: new Date(now),
+    ctime: new Date(now),
+    birthtime: new Date(now)
+  };
+}
+function createStatsFromDenoFileInfo(info) {
+  return {
+    isFile: () => info.isFile,
+    isDirectory: () => info.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => info.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false,
+    dev: info.dev || 0,
+    ino: info.ino || 0,
+    mode: info.mode || 0,
+    nlink: info.nlink || 1,
+    uid: info.uid || 0,
+    gid: info.gid || 0,
+    rdev: 0,
+    size: info.size,
+    blksize: info.blksize || 4096,
+    blocks: info.blocks || Math.ceil(info.size / 512),
+    atimeMs: info.atime?.getTime() || Date.now(),
+    mtimeMs: info.mtime?.getTime() || Date.now(),
+    ctimeMs: info.birthtime?.getTime() || Date.now(),
+    birthtimeMs: info.birthtime?.getTime() || Date.now(),
+    atime: info.atime || /* @__PURE__ */ new Date(),
+    mtime: info.mtime || /* @__PURE__ */ new Date(),
+    ctime: info.birthtime || /* @__PURE__ */ new Date(),
+    birthtime: info.birthtime || /* @__PURE__ */ new Date()
+  };
+}
+function createDirentFromDenoEntry(entry) {
+  return {
+    name: entry.name,
+    isFile: () => entry.isFile,
+    isDirectory: () => entry.isDirectory,
+    isBlockDevice: () => false,
+    isCharacterDevice: () => false,
+    isSymbolicLink: () => entry.isSymlink || false,
+    isFIFO: () => false,
+    isSocket: () => false
+  };
+}
+function getRuntime() {
+  return runtime;
+}
+var isBunOrDeno, fs, fsPromises, promises, fs_default;
+var init_fs = __esm({
+  "src/fs.ts"() {
+    "use strict";
+    init_runtime();
+    isBunOrDeno = isBun || isDeno;
+    if (isNode) {
+      fs = require("fs");
+      fsPromises = require("fs/promises");
+    }
+    promises = {
+      readFile,
+      writeFile,
+      appendFile,
+      stat,
+      mkdir,
+      readdir,
+      unlink,
+      rmdir,
+      rename,
+      copyFile,
+      realpath
+    };
+    fs_default = {
+      readFile,
+      readFileSync,
+      writeFile,
+      writeFileSync,
+      appendFile,
+      appendFileSync,
+      exists,
+      existsSync,
+      stat,
+      statSync,
+      mkdir,
+      mkdirSync,
+      readdir,
+      readdirSync,
+      unlink,
+      unlinkSync,
+      rmdir,
+      rmdirSync,
+      rename,
+      renameSync,
+      copyFile,
+      copyFileSync,
+      realpath,
+      realpathSync,
+      promises,
+      getRuntime
+    };
+  }
+});
+
+// src/path.ts
+var path_exports = {};
+__export(path_exports, {
+  basename: () => basename,
+  default: () => path_default,
+  delimiter: () => delimiter,
+  dirname: () => dirname,
+  extname: () => extname,
+  format: () => format,
+  getRuntime: () => getRuntime2,
+  isAbsolute: () => isAbsolute,
+  join: () => join,
+  normalize: () => normalize,
+  parse: () => parse,
+  posix: () => posix,
+  relative: () => relative,
+  resolve: () => resolve,
+  sep: () => sep,
+  toNamespacedPath: () => toNamespacedPath,
+  win32: () => win32
+});
+function getSeparator(isWin) {
+  return isWin ? "\\" : "/";
+}
+function getCwd() {
+  if (isNode || isBun) {
+    return process.cwd();
+  } else if (isDeno) {
+    return Deno.cwd();
+  }
+  return "/";
+}
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+}
+function createPathOps(isWin) {
+  return {
+    sep: getSeparator(isWin),
+    delimiter: isWin ? ";" : ":",
+    normalize: (path) => normalizePath(path, isWin),
+    join: (...paths) => joinPaths(paths, isWin),
+    resolve: (...paths) => resolvePaths(paths, isWin),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
+    relative: (from, to) => relativePath(from, to, isWin),
+    dirname: (path) => getDirname(path, isWin),
+    basename: (path, ext) => getBasename(path, ext, isWin),
+    extname: (path) => getExtname(path),
+    parse: (path) => parsePath(path, isWin),
+    format: (pathObject) => formatPath(pathObject, isWin)
+  };
+}
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
+}
+function isAbsoluteWin(path) {
+  const len = path.length;
+  if (len === 0) return false;
+  const code = path.charCodeAt(0);
+  if (code === 47 || code === 92) {
+    return true;
+  }
+  if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
+      if (code2 === 47 || code2 === 92) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function normalizePath(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const isAbsolute2 = isWin ? isAbsoluteWin(path) : isAbsolutePosix(path);
+  const trailingSeparator = path[path.length - 1] === separator || isWin && path[path.length - 1] === "/";
+  let normalized = path.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const parts = normalized.split(separator);
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (part === "" || part === ".") {
+      if (i === 0 && isAbsolute2) result.push("");
+      continue;
+    }
+    if (part === "..") {
+      if (result.length > 0 && result[result.length - 1] !== "..") {
+        if (!(result.length === 1 && result[0] === "")) {
+          result.pop();
+        }
+      } else if (!isAbsolute2) {
+        result.push("..");
+      }
+    } else {
+      result.push(part);
+    }
+  }
+  let final = result.join(separator);
+  if (final.length === 0) {
+    return isAbsolute2 ? separator : ".";
+  }
+  if (trailingSeparator && final[final.length - 1] !== separator) {
+    final += separator;
+  }
+  return final;
+}
+function joinPaths(paths, isWin) {
+  if (paths.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  let joined = "";
+  for (let i = 0; i < paths.length; i++) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      if (joined.length === 0) {
+        joined = path;
+      } else {
+        joined += separator + path;
+      }
+    }
+  }
+  if (joined.length === 0) return ".";
+  return normalizePath(joined, isWin);
+}
+function resolvePaths(paths, isWin) {
+  const separator = getSeparator(isWin);
+  let resolved = "";
+  let isAbsolute2 = false;
+  for (let i = paths.length - 1; i >= 0 && !isAbsolute2; i--) {
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
+      isAbsolute2 = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
+    }
+  }
+  if (!isAbsolute2) {
+    const cwd = getCwd();
+    resolved = cwd + (resolved.length > 0 ? separator + resolved : "");
+  }
+  return normalizePath(resolved, isWin);
+}
+function relativePath(from, to, isWin) {
+  from = resolvePaths([from], isWin);
+  to = resolvePaths([to], isWin);
+  if (from === to) return "";
+  const separator = getSeparator(isWin);
+  const fromParts = from.split(separator).filter((p) => p.length > 0);
+  const toParts = to.split(separator).filter((p) => p.length > 0);
+  let commonLength = 0;
+  const minLength = Math.min(fromParts.length, toParts.length);
+  for (let i = 0; i < minLength; i++) {
+    if (fromParts[i] === toParts[i]) {
+      commonLength++;
+    } else {
+      break;
+    }
+  }
+  const upCount = fromParts.length - commonLength;
+  const result = [];
+  for (let i = 0; i < upCount; i++) {
+    result.push("..");
+  }
+  for (let i = commonLength; i < toParts.length; i++) {
+    result.push(toParts[i]);
+  }
+  return result.join(separator) || ".";
+}
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
+  const separator = getSeparator(isWin);
+  const normalized = normalizePath(path, isWin);
+  const lastSepIndex = normalized.lastIndexOf(separator);
+  if (lastSepIndex === -1) return ".";
+  if (lastSepIndex === 0) return separator;
+  return normalized.slice(0, lastSepIndex);
+}
+function getBasename(path, ext, isWin) {
+  if (path.length === 0) return "";
+  const lastSepIndex = isWin ? findLastSeparator(path) : path.lastIndexOf("/");
+  let base = lastSepIndex === -1 ? path : path.slice(lastSepIndex + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, base.length - ext.length);
+  }
+  return base;
+}
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
+    return "";
+  }
+  return path.slice(lastDotIndex);
+}
+function parsePath(path, isWin) {
+  let root = "";
+  if (isWin) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
+        root += "\\";
+      }
+    } else if (path[0] === "\\" || path[0] === "/") {
+      root = "\\";
+    }
+  } else {
+    if (path[0] === "/") {
+      root = "/";
+    }
+  }
+  const dir = getDirname(path, isWin);
+  const base = getBasename(path, void 0, isWin);
+  const ext = getExtname(path);
+  const name = ext ? base.slice(0, base.length - ext.length) : base;
+  return { root, dir, base, ext, name };
+}
+function formatPath(pathObject, isWin) {
+  const separator = getSeparator(isWin);
+  const dir = pathObject.dir || pathObject.root || "";
+  const base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir) return base;
+  if (dir === pathObject.root) return dir + base;
+  return dir + separator + base;
+}
+function normalize(path) {
+  return normalizePath(path, isWindows);
+}
+function join(...paths) {
+  return joinPaths(paths, isWindows);
+}
+function resolve(...paths) {
+  return resolvePaths(paths, isWindows);
+}
+function isAbsolute(path) {
+  return isWindows ? win32.isAbsolute(path) : posix.isAbsolute(path);
+}
+function relative(from, to) {
+  return relativePath(from, to, isWindows);
+}
+function dirname(path) {
+  return getDirname(path, isWindows);
+}
+function basename(path, ext) {
+  return getBasename(path, ext, isWindows);
+}
+function extname(path) {
+  return getExtname(path);
+}
+function parse(path) {
+  return parsePath(path, isWindows);
+}
+function format(pathObject) {
+  return formatPath(pathObject, isWindows);
+}
+function toNamespacedPath(path) {
+  if (!isWindows || path.length === 0) return path;
+  const resolved = resolve(path);
+  if (resolved.length >= 3) {
+    if (resolved[0] === "\\") {
+      if (resolved[1] === "\\" && resolved[2] !== "?") {
+        return "\\\\?\\UNC\\" + resolved.slice(2);
+      }
+    } else if (resolved[1] === ":" && resolved[2] === "\\") {
+      return "\\\\?\\" + resolved;
+    }
+  }
+  return path;
+}
+function getRuntime2() {
+  return runtime;
+}
+var isWindows, sep, delimiter, posix, win32, path_default;
+var init_path = __esm({
+  "src/path.ts"() {
+    "use strict";
+    init_runtime();
+    isWindows = (() => {
+      if (isNode) {
+        return process.platform === "win32";
+      } else if (isDeno) {
+        return Deno.build.os === "windows";
+      }
+      return typeof process !== "undefined" && process.platform === "win32";
+    })();
+    sep = isWindows ? "\\" : "/";
+    delimiter = isWindows ? ";" : ":";
+    posix = createPathOps(false);
+    win32 = createPathOps(true);
+    path_default = {
+      sep,
+      delimiter,
+      normalize,
+      join,
+      resolve,
+      isAbsolute,
+      relative,
+      dirname,
+      basename,
+      extname,
+      parse,
+      format,
+      toNamespacedPath,
+      posix,
+      win32,
+      getRuntime: getRuntime2
+    };
+  }
+});
+
+// src/http.ts
+var http_exports = {};
+__export(http_exports, {
+  Agent: () => Agent,
+  ClientRequest: () => ClientRequest,
+  IncomingMessage: () => IncomingMessage,
+  METHODS: () => METHODS,
+  STATUS_CODES: () => STATUS_CODES,
+  Server: () => Server,
+  ServerResponse: () => ServerResponse,
+  createServer: () => createServer,
+  default: () => http_default,
+  get: () => get,
+  getRuntime: () => getRuntime3,
+  request: () => request
+});
+function queueCallback(callback) {
+  if (callback) queueMicrotask(callback);
+}
+function headersToInit(headers) {
+  const result = {};
+  for (const key in headers) {
+    const value = headers[key];
+    result[key] = Array.isArray(value) ? value.join(", ") : String(value);
+  }
+  return result;
+}
+function createAddress(port, address, family = "IPv4") {
+  return { port, family, address };
+}
+function createErrorResponse() {
+  return new Response("Internal Server Error", { status: 500 });
+}
+function emitListeningWithCallback(server, callback) {
+  server._listening = true;
+  server.emit("listening");
+  queueCallback(callback);
+}
+function closeAndEmit(server, callback) {
+  server._listening = false;
+  server.emit("close");
+  if (callback) queueMicrotask(() => callback());
+}
+function createServer(optionsOrListener, requestListener) {
+  return new Server(typeof optionsOrListener === "function" ? optionsOrListener : requestListener);
+}
+function request(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest(urlString, options);
+  if (isNode) {
+    const urlObj = new URL(urlString);
+    const client = urlObj.protocol === "https:" ? https : http;
+    const nodeReq = client.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    nodeReq.on("error", (error) => req.emit("error", error));
+    nodeReq.end();
+  } else {
+    queueMicrotask(async () => {
+      try {
+        const response = await fetch(urlString, {
+          method: options?.method || "GET",
+          headers: options?.headers,
+          signal: options?.signal
+        });
+        const fetchRequest = new Request(urlString);
+        const incomingMessage = new IncomingMessage(fetchRequest);
+        incomingMessage.statusCode = response.status;
+        incomingMessage.statusMessage = response.statusText;
+        if (callback) callback(incomingMessage);
+        req.emit("response", incomingMessage);
+      } catch (error) {
+        req.emit("error", error);
+      }
+    });
+  }
+  return req;
+}
+function get(url, options, callback) {
+  return request(url, { ...options, method: "GET" }, callback);
+}
+function getRuntime3() {
+  return runtime;
+}
+var import_node_events, http, https, METHODS, STATUS_CODES, IncomingMessage, ServerResponse, Server, ClientRequest, Agent, http_default;
+var init_http = __esm({
+  "src/http.ts"() {
+    "use strict";
+    import_node_events = require("events");
+    init_runtime();
+    if (isNode && typeof process !== "undefined") {
+      try {
+        http = require("http");
+        https = require("https");
+      } catch (e) {
+        http = require("http");
+        https = require("https");
+      }
+    }
+    METHODS = [
+      "GET",
+      "POST",
+      "PUT",
+      "DELETE",
+      "PATCH",
+      "HEAD",
+      "OPTIONS",
+      "CONNECT",
+      "TRACE"
+    ];
+    STATUS_CODES = {
+      100: "Continue",
+      101: "Switching Protocols",
+      102: "Processing",
+      200: "OK",
+      201: "Created",
+      202: "Accepted",
+      203: "Non-Authoritative Information",
+      204: "No Content",
+      205: "Reset Content",
+      206: "Partial Content",
+      300: "Multiple Choices",
+      301: "Moved Permanently",
+      302: "Found",
+      303: "See Other",
+      304: "Not Modified",
+      307: "Temporary Redirect",
+      308: "Permanent Redirect",
+      400: "Bad Request",
+      401: "Unauthorized",
+      402: "Payment Required",
+      403: "Forbidden",
+      404: "Not Found",
+      405: "Method Not Allowed",
+      406: "Not Acceptable",
+      407: "Proxy Authentication Required",
+      408: "Request Timeout",
+      409: "Conflict",
+      410: "Gone",
+      411: "Length Required",
+      412: "Precondition Failed",
+      413: "Payload Too Large",
+      414: "URI Too Long",
+      415: "Unsupported Media Type",
+      416: "Range Not Satisfiable",
+      417: "Expectation Failed",
+      418: "I'm a teapot",
+      422: "Unprocessable Entity",
+      425: "Too Early",
+      426: "Upgrade Required",
+      428: "Precondition Required",
+      429: "Too Many Requests",
+      431: "Request Header Fields Too Large",
+      451: "Unavailable For Legal Reasons",
+      500: "Internal Server Error",
+      501: "Not Implemented",
+      502: "Bad Gateway",
+      503: "Service Unavailable",
+      504: "Gateway Timeout",
+      505: "HTTP Version Not Supported",
+      506: "Variant Also Negotiates",
+      507: "Insufficient Storage",
+      508: "Loop Detected",
+      510: "Not Extended",
+      511: "Network Authentication Required"
+    };
+    IncomingMessage = class extends import_node_events.EventEmitter {
+      constructor(req) {
+        super();
+        this.httpVersion = "1.1";
+        this.rawHeaders = [];
+        this._req = req;
+        if (isNode) {
+          this.method = req.method;
+          this.url = req.url;
+          this.headers = req.headers;
+          this.statusCode = req.statusCode;
+          this.statusMessage = req.statusMessage;
+          this.httpVersion = req.httpVersion;
+          this.rawHeaders = req.rawHeaders;
+          this.socket = req.socket;
+        } else {
+          this.method = req.method;
+          const urlObj = new URL(req.url);
+          this.url = urlObj.pathname + urlObj.search;
+          this.headers = req.headers;
+          this.rawHeaders = [];
+        }
+      }
+      async text() {
+        if (isNode) {
+          return new Promise((resolve2, reject) => {
+            const chunks = [];
+            this._req.on("data", (chunk) => chunks.push(chunk));
+            this._req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+            this._req.on("error", reject);
+          });
+        }
+        return this._req.text();
+      }
+      async json() {
+        if (isNode) {
+          const text = await this.text();
+          return JSON.parse(text);
+        }
+        return this._req.json();
+      }
+    };
+    ServerResponse = class extends import_node_events.EventEmitter {
+      constructor(_req, nodeRes) {
+        super();
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        this.headersSent = false;
+        this._body = "";
+        this._finished = false;
+        this._nodeRes = nodeRes;
+        this._headers = /* @__PURE__ */ Object.create(null);
+      }
+      setHeader(name, value) {
+        if (this.headersSent) {
+          throw new Error("Cannot set headers after they are sent");
+        }
+        if (isNode && this._nodeRes) {
+          this._nodeRes.setHeader(name, value);
+        }
+        this._headers[name.toLowerCase()] = value;
+        return this;
+      }
+      getHeader(name) {
+        if (isNode && this._nodeRes) {
+          return this._nodeRes.getHeader(name);
+        }
+        return this._headers[name.toLowerCase()];
+      }
+      getHeaders() {
+        if (isNode && this._nodeRes) {
+          return this._nodeRes.getHeaders();
+        }
+        return { ...this._headers };
+      }
+      getHeaderNames() {
+        if (isNode && this._nodeRes) {
+          return this._nodeRes.getHeaderNames();
+        }
+        return Object.keys(this._headers);
+      }
+      hasHeader(name) {
+        if (isNode && this._nodeRes) {
+          return this._nodeRes.hasHeader(name);
+        }
+        return name.toLowerCase() in this._headers;
+      }
+      removeHeader(name) {
+        if (this.headersSent) {
+          throw new Error("Cannot remove headers after they are sent");
+        }
+        if (isNode && this._nodeRes) {
+          this._nodeRes.removeHeader(name);
+        }
+        delete this._headers[name.toLowerCase()];
+      }
+      writeHead(statusCode, statusMessage, headers) {
+        if (this.headersSent) {
+          throw new Error("Cannot write headers after they are sent");
+        }
+        this.statusCode = statusCode;
+        if (typeof statusMessage === "string") {
+          this.statusMessage = statusMessage;
+          if (headers) {
+            for (const key in headers) {
+              this.setHeader(key, headers[key]);
+            }
+          }
+        } else if (statusMessage) {
+          for (const key in statusMessage) {
+            this.setHeader(key, statusMessage[key]);
+          }
+        }
+        if (isNode && this._nodeRes) {
+          if (typeof statusMessage === "string") {
+            this._nodeRes.writeHead(statusCode, statusMessage, headers);
+          } else {
+            this._nodeRes.writeHead(statusCode, statusMessage);
+          }
+        }
+        this.headersSent = true;
+        return this;
+      }
+      write(chunk, encoding, callback) {
+        if (typeof encoding === "function") {
+          callback = encoding;
+          encoding = "utf8";
+        }
+        if (!this.headersSent) {
+          this.writeHead(this.statusCode);
+        }
+        if (isNode && this._nodeRes) {
+          return this._nodeRes.write(chunk, encoding, callback);
+        }
+        this._body += chunk;
+        queueCallback(callback);
+        return true;
+      }
+      end(chunk, encoding, callback) {
+        if (this._finished) {
+          return this;
+        }
+        if (typeof chunk === "function") {
+          callback = chunk;
+          chunk = void 0;
+        } else if (typeof encoding === "function") {
+          callback = encoding;
+          encoding = "utf8";
+        }
+        if (chunk !== void 0) {
+          this.write(chunk, encoding);
+        }
+        if (!this.headersSent) {
+          this.writeHead(this.statusCode);
+        }
+        this._finished = true;
+        if (isNode && this._nodeRes) {
+          this._nodeRes.end(callback);
+          this.emit("finish");
+        } else {
+          const response = new Response(this._body, {
+            status: this.statusCode,
+            statusText: this.statusMessage,
+            headers: headersToInit(this._headers)
+          });
+          if (this._resolve) {
+            this._resolve(response);
+          }
+          queueCallback(callback);
+        }
+        return this;
+      }
+      _setResolver(resolve2) {
+        this._resolve = resolve2;
+      }
+    };
+    Server = class extends import_node_events.EventEmitter {
+      constructor(requestListener) {
+        super();
+        this._listening = false;
+        this.requestListener = requestListener;
+      }
+      listen(...args) {
+        let port = 3e3;
+        let hostname = "0.0.0.0";
+        let callback;
+        const firstArg = args[0];
+        if (typeof firstArg === "number") {
+          port = firstArg;
+          const secondArg = args[1];
+          if (typeof secondArg === "string") {
+            hostname = secondArg;
+            callback = args[2] || args[3];
+          } else if (typeof secondArg === "function") {
+            callback = secondArg;
+          }
+        } else if (firstArg && typeof firstArg === "object") {
+          port = firstArg.port || 3e3;
+          hostname = firstArg.hostname || "0.0.0.0";
+          callback = args[1];
+        }
+        const self = this;
+        if (isNode) {
+          this.nativeServer = http.createServer((req, res) => {
+            const incomingMessage = new IncomingMessage(req);
+            const serverResponse = new ServerResponse(incomingMessage, res);
+            if (self.requestListener) {
+              self.requestListener(incomingMessage, serverResponse);
+            } else {
+              self.emit("request", incomingMessage, serverResponse);
+            }
+          });
+          this.nativeServer.on("upgrade", (req, socket, head) => {
+            self.emit("upgrade", req, socket, head);
+          });
+          this.nativeServer.listen(port, hostname, () => {
+            this._listening = true;
+            this.emit("listening");
+            if (callback) callback();
+          });
+          this.nativeServer.on("error", (err) => this.emit("error", err));
+          this.nativeServer.on("close", () => {
+            this._listening = false;
+            this.emit("close");
+          });
+        } else if (isBun) {
+          this.nativeServer = Bun.serve({
+            port,
+            hostname,
+            fetch: (req) => {
+              const urlObj = new URL(req.url);
+              const pathname = urlObj.pathname + urlObj.search;
+              let statusCode = 200;
+              let statusMessage = "OK";
+              let body = "";
+              const headers = /* @__PURE__ */ Object.create(null);
+              let responseReady = false;
+              const incomingMessage = {
+                method: req.method,
+                url: pathname,
+                headers: req.headers,
+                httpVersion: "1.1",
+                rawHeaders: [],
+                _req: req,
+                text: () => req.text(),
+                json: () => req.json()
+              };
+              const serverResponse = {
+                statusCode: 200,
+                statusMessage: "OK",
+                headersSent: false,
+                _headers: headers,
+                setHeader(name, value) {
+                  headers[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+                  return this;
+                },
+                getHeader(name) {
+                  return headers[name.toLowerCase()];
+                },
+                getHeaders() {
+                  return { ...headers };
+                },
+                writeHead(status, arg2, arg3) {
+                  statusCode = status;
+                  this.statusCode = status;
+                  this.headersSent = true;
+                  if (typeof arg2 === "string") {
+                    statusMessage = arg2;
+                    this.statusMessage = arg2;
+                    if (arg3) {
+                      for (const key in arg3) {
+                        headers[key.toLowerCase()] = arg3[key];
+                      }
+                    }
+                  } else if (arg2) {
+                    for (const key in arg2) {
+                      headers[key.toLowerCase()] = arg2[key];
+                    }
+                  }
+                  return this;
+                },
+                write(chunk) {
+                  if (!this.headersSent) {
+                    this.writeHead(statusCode);
+                  }
+                  body += chunk;
+                  return true;
+                },
+                end(chunk) {
+                  if (chunk !== void 0) {
+                    this.write(chunk);
+                  }
+                  if (!this.headersSent) {
+                    this.writeHead(statusCode);
+                  }
+                  responseReady = true;
+                  return this;
+                }
+              };
+              if (self.requestListener) {
+                self.requestListener(incomingMessage, serverResponse);
+              }
+              if (responseReady) {
+                return new Response(body, {
+                  status: statusCode,
+                  statusText: statusMessage,
+                  headers
+                });
+              }
+              return new Promise((resolve2) => {
+                serverResponse.end = (chunk) => {
+                  if (chunk !== void 0) {
+                    body += chunk;
+                  }
+                  resolve2(new Response(body, {
+                    status: statusCode,
+                    statusText: statusMessage,
+                    headers
+                  }));
+                };
+              });
+            },
+            error: createErrorResponse
+          });
+          emitListeningWithCallback(this, callback);
+        } else if (isDeno) {
+          this.nativeServer = Deno.serve({
+            port,
+            hostname,
+            handler: (req) => {
+              return new Promise((resolve2) => {
+                const incomingMessage = new IncomingMessage(req);
+                const serverResponse = new ServerResponse();
+                serverResponse._setResolver(resolve2);
+                if (self.requestListener) {
+                  self.requestListener(incomingMessage, serverResponse);
+                } else {
+                  self.emit("request", incomingMessage, serverResponse);
+                }
+              });
+            },
+            onError: (error) => {
+              this.emit("error", error);
+              return createErrorResponse();
+            }
+          });
+          emitListeningWithCallback(this, callback);
+        }
+        return this;
+      }
+      close(callback) {
+        if (!this.nativeServer) {
+          if (callback) queueMicrotask(() => callback());
+          return this;
+        }
+        if (isNode) {
+          this.nativeServer.close(callback);
+        } else if (isBun) {
+          this.nativeServer.stop();
+          closeAndEmit(this, callback);
+        } else if (isDeno) {
+          this.nativeServer.shutdown();
+          closeAndEmit(this, callback);
+        }
+        return this;
+      }
+      address() {
+        if (!this.nativeServer) return null;
+        if (isNode) {
+          const addr = this.nativeServer.address();
+          if (!addr) return null;
+          if (typeof addr === "string") {
+            return createAddress(0, addr, "unix");
+          }
+          return addr;
+        } else if (isBun) {
+          return createAddress(this.nativeServer.port, this.nativeServer.hostname);
+        } else if (isDeno) {
+          const addr = this.nativeServer.addr;
+          return createAddress(addr.port, addr.hostname);
+        }
+        return null;
+      }
+      get listening() {
+        return this._listening;
+      }
+    };
+    ClientRequest = class extends import_node_events.EventEmitter {
+      constructor(_url, _options = {}) {
+        super();
+      }
+      write(_chunk) {
+        return true;
+      }
+      end(callback) {
+        queueCallback(callback);
+      }
+    };
+    Agent = class {
+      constructor(options) {
+        this.options = options;
+      }
+    };
+    http_default = {
+      createServer,
+      request,
+      get,
+      Server,
+      IncomingMessage,
+      ServerResponse,
+      Agent,
+      ClientRequest,
+      METHODS,
+      STATUS_CODES,
+      getRuntime: getRuntime3
+    };
+  }
+});
 
 // package.json
 var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "elit",
-      version: "2.0.0",
+      version: "3.0.1",
       description: "Optimized lightweight library for creating DOM elements with reactive state",
       main: "dist/index.js",
       module: "dist/index.mjs",
@@ -85,12 +1465,59 @@ var require_package = __commonJS({
           types: "./dist/build.d.ts",
           import: "./dist/build.mjs",
           require: "./dist/build.js"
+        },
+        "./http": {
+          types: "./dist/http.d.ts",
+          import: "./dist/http.mjs",
+          require: "./dist/http.js"
+        },
+        "./https": {
+          types: "./dist/https.d.ts",
+          import: "./dist/https.mjs",
+          require: "./dist/https.js"
+        },
+        "./ws": {
+          types: "./dist/ws.d.ts",
+          import: "./dist/ws.mjs",
+          require: "./dist/ws.js"
+        },
+        "./fs": {
+          types: "./dist/fs.d.ts",
+          import: "./dist/fs.mjs",
+          require: "./dist/fs.js"
+        },
+        "./mime-types": {
+          types: "./dist/mime-types.d.ts",
+          import: "./dist/mime-types.mjs",
+          require: "./dist/mime-types.js"
+        },
+        "./chokidar": {
+          types: "./dist/chokidar.d.ts",
+          import: "./dist/chokidar.mjs",
+          require: "./dist/chokidar.js"
+        },
+        "./path": {
+          types: "./dist/path.d.ts",
+          import: "./dist/path.mjs",
+          require: "./dist/path.js"
+        },
+        "./wss": {
+          types: "./dist/wss.d.ts",
+          import: "./dist/wss.mjs",
+          require: "./dist/wss.js"
+        },
+        "./runtime": {
+          types: "./dist/runtime.d.ts",
+          import: "./dist/runtime.mjs",
+          require: "./dist/runtime.js"
         }
       },
       scripts: {
         build: "tsup",
         dev: "tsup --watch",
         typecheck: "tsc --noEmit",
+        benchmark: "node benchmark/server-benchmark.js",
+        "benchmark:router": "node benchmark/router-benchmark.js",
         "docs:dev": "npm run --prefix docs dev",
         "docs:build": "npm run --prefix docs build",
         "docs:preview": "npm run --prefix docs preview",
@@ -129,18 +1556,18 @@ var require_package = __commonJS({
       bugs: {
         url: "https://github.com/d-osc/elit/issues"
       },
-      homepage: "https://github.com/d-osc/elit#readme",
+      homepage: "https://d-osc.github.io/elit/",
       dependencies: {
-        chokidar: "^4.0.3",
         esbuild: "^0.24.2",
-        "mime-types": "^2.1.35",
-        open: "^11.0.0",
-        ws: "^8.18.0"
+        open: "^11.0.0"
       },
       devDependencies: {
+        "@types/express": "^5.0.6",
         "@types/mime-types": "^2.1.4",
         "@types/node": "^22.0.0",
         "@types/ws": "^8.5.13",
+        express: "^5.2.1",
+        elysia: "^1.4.19",
         terser: "^5.44.1",
         tsup: "^8.0.0",
         typescript: "^5.3.0"
@@ -155,8 +1582,31 @@ var require_package = __commonJS({
 });
 
 // src/config.ts
-var import_fs = require("fs");
-var import_path = require("path");
+init_fs();
+init_path();
+function readFileAsString(filePath) {
+  const contentBuffer = readFileSync(filePath, "utf-8");
+  return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+}
+function removeQuotes(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+async function importConfigModule(configPath) {
+  const { pathToFileURL } = await import("url");
+  const configModule = await import(pathToFileURL(configPath).href);
+  return configModule.default || configModule;
+}
+async function safeCleanup(filePath) {
+  try {
+    const { unlinkSync: unlinkSync2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    unlinkSync2(filePath);
+  } catch {
+  }
+}
 var CONFIG_FILES = [
   "elit.config.ts",
   "elit.config.js",
@@ -173,9 +1623,9 @@ function loadEnv(mode = "development", cwd = process.cwd()) {
     `.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 filePath = resolve(cwd, file);
+    if (existsSync(filePath)) {
+      const content = readFileAsString(filePath);
       const lines = content.split("\n");
       for (const line of lines) {
         const trimmed = line.trim();
@@ -183,10 +1633,7 @@ function loadEnv(mode = "development", cwd = process.cwd()) {
         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);
-          }
+          const cleanValue = removeQuotes(value);
           if (!(key in env)) {
             env[key] = cleanValue;
           }
@@ -194,70 +1641,759 @@ function loadEnv(mode = "development", cwd = process.cwd()) {
       }
     }
   }
-  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 env;
+}
+async function loadConfig(cwd = process.cwd()) {
+  for (const configFile of CONFIG_FILES) {
+    const configPath = resolve(cwd, configFile);
+    if (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 = readFileAsString(configPath);
+    return JSON.parse(content);
+  } else if (ext === "ts") {
+    try {
+      const { build: build2 } = await import("esbuild");
+      const { tmpdir } = await import("os");
+      const { join: join2, dirname: dirname2 } = await Promise.resolve().then(() => (init_path(), path_exports));
+      const tempFile = join2(tmpdir(), `elit-config-${Date.now()}.mjs`);
+      const configDir = dirname2(configPath);
+      await build2({
+        entryPoints: [configPath],
+        bundle: true,
+        format: "esm",
+        platform: "node",
+        outfile: tempFile,
+        write: true,
+        target: "es2020",
+        // Bundle everything including elit/* so config can use elit modules
+        // Only mark Node.js built-ins as external
+        external: ["node:*"],
+        // Use the config directory as the working directory for resolution
+        absWorkingDir: configDir
+      });
+      const config = await importConfigModule(tempFile);
+      await safeCleanup(tempFile);
+      return config;
+    } catch (error) {
+      console.error("Failed to load TypeScript config file.");
+      console.error("You can use a .js, .mjs, or .json config file instead.");
+      throw error;
+    }
+  } else {
+    return await importConfigModule(configPath);
+  }
+}
+function mergeConfig(config, cliArgs) {
+  if (!config) {
+    return cliArgs;
+  }
+  return {
+    ...config,
+    ...Object.fromEntries(
+      Object.entries(cliArgs).filter(([_, v]) => v !== void 0)
+    )
+  };
+}
+
+// src/server.ts
+init_http();
+
+// src/https.ts
+var import_events = require("events");
+init_runtime();
+function queueCallback2(callback) {
+  if (callback) queueMicrotask(callback);
+}
+function loadHttpClasses() {
+  const httpModule = (init_http(), __toCommonJS(http_exports));
+  return {
+    IncomingMessage: httpModule.IncomingMessage,
+    ServerResponse: httpModule.ServerResponse
+  };
+}
+var https2;
+var ClientRequest2 = class extends import_events.EventEmitter {
+  constructor(_url, _options = {}) {
+    super();
+  }
+  write(_chunk) {
+    return true;
+  }
+  end(callback) {
+    queueCallback2(callback);
+  }
+};
+function request2(url, options, callback) {
+  const urlString = typeof url === "string" ? url : url.toString();
+  const req = new ClientRequest2(urlString, options);
+  if (isNode) {
+    const { IncomingMessage: IncomingMessage3 } = loadHttpClasses();
+    if (!https2) https2 = require("https");
+    const nodeReq = https2.request(urlString, {
+      method: options?.method || "GET",
+      headers: options?.headers,
+      timeout: options?.timeout,
+      signal: options?.signal
+    }, (res) => {
+      const incomingMessage = new IncomingMessage3(res);
+      if (callback) callback(incomingMessage);
+      req.emit("response", incomingMessage);
+    });
+    nodeReq.on("error", (error) => req.emit("error", error));
+    nodeReq.end();
+  } else {
+    const { IncomingMessage: IncomingMessage3 } = loadHttpClasses();
+    queueMicrotask(async () => {
+      try {
+        const response = await fetch(urlString, {
+          method: options?.method || "GET",
+          headers: options?.headers,
+          signal: options?.signal
+        });
+        const fetchRequest = new Request(urlString);
+        const incomingMessage = new IncomingMessage3(fetchRequest);
+        incomingMessage.statusCode = response.status;
+        incomingMessage.statusMessage = response.statusText;
+        if (callback) callback(incomingMessage);
+        req.emit("response", incomingMessage);
+      } catch (error) {
+        req.emit("error", error);
+      }
+    });
+  }
+  return req;
+}
+
+// src/ws.ts
+var import_events2 = require("events");
+init_runtime();
+var CLOSE_CODES = {
+  NORMAL: 1e3,
+  GOING_AWAY: 1001,
+  PROTOCOL_ERROR: 1002,
+  UNSUPPORTED_DATA: 1003,
+  NO_STATUS: 1005,
+  ABNORMAL: 1006,
+  INVALID_DATA: 1007,
+  POLICY_VIOLATION: 1008,
+  MESSAGE_TOO_BIG: 1009,
+  EXTENSION_REQUIRED: 1010,
+  INTERNAL_ERROR: 1011,
+  SERVICE_RESTART: 1012,
+  TRY_AGAIN_LATER: 1013,
+  BAD_GATEWAY: 1014,
+  TLS_HANDSHAKE_FAIL: 1015
+};
+function queueCallback3(callback, error) {
+  if (callback) {
+    queueMicrotask(() => callback(error));
+  }
+}
+function createNativeWebSocket(url, protocols) {
+  if (runtime === "node" && typeof globalThis.WebSocket === "undefined") {
+    throw new Error("WebSocket is not available. Please use Node.js 18+ or install ws package.");
+  }
+  return new globalThis.WebSocket(url, protocols);
+}
+var WebSocket = class extends import_events2.EventEmitter {
+  constructor(address, protocols, _options) {
+    super();
+    this.readyState = 0 /* CONNECTING */;
+    this.protocol = "";
+    this.extensions = "";
+    this.binaryType = "nodebuffer";
+    this.url = typeof address === "string" ? address : address.toString();
+    const protocolsArray = Array.isArray(protocols) ? protocols : protocols ? [protocols] : void 0;
+    this._socket = createNativeWebSocket(this.url, protocolsArray);
+    this._setupNativeSocket();
+  }
+  _setupNativeSocket() {
+    this._socket.onopen = () => {
+      this.readyState = 1 /* OPEN */;
+      this.emit("open");
+    };
+    this._socket.onmessage = (event) => {
+      const isBinary = event.data instanceof ArrayBuffer || event.data instanceof Blob;
+      this.emit("message", event.data, isBinary);
+    };
+    this._socket.onclose = (event) => {
+      this.readyState = 3 /* CLOSED */;
+      this.emit("close", event.code, event.reason);
+    };
+    this._socket.onerror = () => {
+      this.emit("error", new Error("WebSocket error"));
+    };
+  }
+  /**
+   * Send data through WebSocket
+   */
+  send(data, options, callback) {
+    const cb = typeof options === "function" ? options : callback;
+    if (this.readyState !== 1 /* OPEN */) {
+      return queueCallback3(cb, new Error("WebSocket is not open"));
+    }
+    try {
+      this._socket.send(data);
+      queueCallback3(cb);
+    } catch (error) {
+      queueCallback3(cb, error);
+    }
+  }
+  /**
+   * Close the WebSocket connection
+   */
+  close(code, reason) {
+    if (this.readyState === 3 /* CLOSED */ || this.readyState === 2 /* CLOSING */) {
+      return;
+    }
+    this.readyState = 2 /* CLOSING */;
+    this._socket.close(code, typeof reason === "string" ? reason : reason?.toString());
+  }
+  /**
+   * Pause the socket (no-op for native WebSocket)
+   */
+  pause() {
+  }
+  /**
+   * Resume the socket (no-op for native WebSocket)
+   */
+  resume() {
+  }
+  /**
+   * Send a ping frame (no-op for native WebSocket)
+   */
+  ping(_data, _mask, callback) {
+    queueCallback3(callback);
+  }
+  /**
+   * Send a pong frame (no-op for native WebSocket)
+   */
+  pong(_data, _mask, callback) {
+    queueCallback3(callback);
+  }
+  /**
+   * Terminate the connection
+   */
+  terminate() {
+    this._socket.close();
+    this.readyState = 3 /* CLOSED */;
+  }
+  /**
+   * Get buffered amount
+   */
+  get bufferedAmount() {
+    return this._socket.bufferedAmount || 0;
+  }
+};
+var WebSocketServer = class extends import_events2.EventEmitter {
+  constructor(options, callback) {
+    super();
+    this.clients = /* @__PURE__ */ new Set();
+    this.options = options || {};
+    this.path = options?.path || "/";
+    if (runtime === "node") {
+      if (options?.server) {
+        this._httpServer = options.server;
+        this._setupUpgradeHandler();
+      } else if (options?.noServer) {
+      } else {
+        const http2 = require("http");
+        this._httpServer = http2.createServer();
+        this._setupUpgradeHandler();
+        if (options?.port) {
+          this._httpServer.listen(options.port, options.host, callback);
+        }
+      }
+    } else {
+      queueCallback3(callback);
+    }
+  }
+  _setupUpgradeHandler() {
+    this._httpServer.on("upgrade", (request3, socket, head) => {
+      console.log("[WebSocket] Upgrade request:", request3.url, "Expected:", this.path);
+      if (this.path && this.path !== "/" && request3.url !== this.path) {
+        console.log("[WebSocket] Path mismatch, ignoring");
+        return;
+      }
+      this.handleUpgrade(request3, socket, head, (client) => {
+        console.log("[WebSocket] Client connected");
+        this.emit("connection", client, request3);
+      });
+    });
+  }
+  /**
+   * Handle HTTP upgrade for WebSocket
+   */
+  handleUpgrade(request3, socket, _head, callback) {
+    const key = request3.headers["sec-websocket-key"];
+    if (!key) {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+      return;
+    }
+    const crypto = require("crypto");
+    const acceptKey = crypto.createHash("sha1").update(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64");
+    const headers = [
+      "HTTP/1.1 101 Switching Protocols",
+      "Upgrade: websocket",
+      "Connection: Upgrade",
+      `Sec-WebSocket-Accept: ${acceptKey}`,
+      "",
+      ""
+    ];
+    socket.write(headers.join("\r\n"));
+    const client = this._createClientFromSocket(socket);
+    if (this.options.clientTracking !== false) {
+      this.clients.add(client);
+      client.on("close", () => {
+        this.clients.delete(client);
+      });
+    }
+    callback(client);
+  }
+  _createClientFromSocket(socket) {
+    const client = Object.create(WebSocket.prototype);
+    import_events2.EventEmitter.call(client);
+    client.readyState = 1 /* OPEN */;
+    client.url = "ws://localhost";
+    client.protocol = "";
+    client.extensions = "";
+    client.binaryType = "nodebuffer";
+    client._socket = socket;
+    socket.on("data", (data) => {
+      try {
+        const message = this._parseFrame(data);
+        if (message) {
+          client.emit("message", message, false);
+        }
+      } catch (error) {
+        client.emit("error", error);
+      }
+    });
+    socket.on("end", () => {
+      client.readyState = 3 /* CLOSED */;
+      client.emit("close", CLOSE_CODES.NORMAL, "");
+    });
+    socket.on("error", (error) => {
+      client.emit("error", error);
+    });
+    client.send = (data, _options, callback) => {
+      try {
+        const frame = this._createFrame(data);
+        socket.write(frame);
+        queueCallback3(callback);
+      } catch (error) {
+        queueCallback3(callback, error);
+      }
+    };
+    client.close = (_code, _reason) => {
+      socket.end();
+      client.readyState = 3 /* CLOSED */;
+    };
+    return client;
+  }
+  _parseFrame(data) {
+    if (data.length < 2) return null;
+    const firstByte = data[0];
+    const secondByte = data[1];
+    const opcode = firstByte & 15;
+    const isMasked = (secondByte & 128) === 128;
+    let payloadLength = secondByte & 127;
+    let offset = 2;
+    if (payloadLength === 126) {
+      payloadLength = data.readUInt16BE(2);
+      offset = 4;
+    } else if (payloadLength === 127) {
+      payloadLength = Number(data.readBigUInt64BE(2));
+      offset = 10;
+    }
+    let payload = data.subarray(offset);
+    if (isMasked) {
+      const maskKey = data.subarray(offset, offset + 4);
+      payload = data.subarray(offset + 4, offset + 4 + payloadLength);
+      for (let i = 0; i < payload.length; i++) {
+        payload[i] ^= maskKey[i % 4];
+      }
+    }
+    if (opcode === 1) {
+      return payload.toString("utf8");
+    }
+    return null;
+  }
+  _createFrame(data) {
+    const payload = typeof data === "string" ? Buffer.from(data) : data;
+    const payloadLength = Buffer.isBuffer(payload) ? payload.length : 0;
+    let frame;
+    let offset = 2;
+    if (payloadLength < 126) {
+      frame = Buffer.allocUnsafe(2 + payloadLength);
+      frame[1] = payloadLength;
+    } else if (payloadLength < 65536) {
+      frame = Buffer.allocUnsafe(4 + payloadLength);
+      frame[1] = 126;
+      frame.writeUInt16BE(payloadLength, 2);
+      offset = 4;
+    } else {
+      frame = Buffer.allocUnsafe(10 + payloadLength);
+      frame[1] = 127;
+      frame.writeBigUInt64BE(BigInt(payloadLength), 2);
+      offset = 10;
+    }
+    frame[0] = 129;
+    if (Buffer.isBuffer(payload)) {
+      payload.copy(frame, offset);
+    }
+    return frame;
+  }
+  /**
+   * Close the server
+   */
+  close(callback) {
+    this.clients.forEach((client) => client.close());
+    this.clients.clear();
+    if (this._httpServer) {
+      this._httpServer.close(callback);
+    } else {
+      this.emit("close");
+      queueCallback3(callback);
+    }
+  }
+  /**
+   * Check if server should handle request
+   */
+  shouldHandle(request3) {
+    if (this.path && request3.url !== this.path) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get server address
+   */
+  address() {
+    if (this._httpServer && this._httpServer.address) {
+      return this._httpServer.address();
+    }
+    return null;
+  }
+};
+
+// src/chokidar.ts
+var import_events3 = require("events");
+init_runtime();
+function normalizePath2(path) {
+  return path.replace(/\\/g, "/");
+}
+function emitEvent(watcher, eventType, path) {
+  watcher.emit(eventType, path);
+  watcher.emit("all", eventType, path);
+}
+function matchesAnyPattern(path, patterns) {
+  return patterns.some((pattern) => matchesPattern(path, pattern));
+}
+function handleRenameEvent(watcher, fullPath, fs2) {
+  try {
+    fs2.statSync(fullPath);
+    emitEvent(watcher, "add", fullPath);
+  } catch {
+    emitEvent(watcher, "unlink", fullPath);
+  }
+}
+function setupFsWatch(watcher, baseDir, patterns, fs2) {
+  try {
+    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      const fullPath = normalizePath2(`${baseDir}/${filename}`);
+      if (!matchesAnyPattern(fullPath, patterns)) return;
+      if (eventType === "rename") {
+        handleRenameEvent(watcher, fullPath, fs2);
+      } else if (eventType === "change") {
+        emitEvent(watcher, "change", fullPath);
+      }
+    });
+    watcher._setWatcher(nativeWatcher);
+    watcher["_watched"].add(baseDir);
+    queueMicrotask(() => watcher.emit("ready"));
+  } catch (error) {
+    watcher.emit("error", error);
+  }
+}
+var FSWatcher = class extends import_events3.EventEmitter {
+  constructor(options) {
+    super();
+    this._closed = false;
+    this._watched = /* @__PURE__ */ new Set();
+    this.options = options || {};
+  }
+  /**
+   * Add paths to be watched
+   */
+  add(paths) {
+    if (this._closed) {
+      throw new Error("Watcher has been closed");
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.add(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.add(path));
+    }
+    return this;
+  }
+  /**
+   * Stop watching paths
+   */
+  unwatch(paths) {
+    if (this._closed) {
+      return this;
+    }
+    const pathArray = Array.isArray(paths) ? paths : [paths];
+    if (runtime === "node") {
+      if (this._watcher) {
+        this._watcher.unwatch(pathArray);
+      }
+    } else {
+      pathArray.forEach((path) => this._watched.delete(path));
+    }
+    return this;
+  }
+  /**
+   * Close the watcher
+   */
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    if (runtime === "node") {
+      if (this._watcher) {
+        await this._watcher.close();
+      }
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * Get watched paths
+   */
+  getWatched() {
+    if (runtime === "node" && this._watcher) {
+      return this._watcher.getWatched();
+    }
+    const result = {};
+    this._watched.forEach((path) => {
+      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
+      const file = path.substring(path.lastIndexOf("/") + 1);
+      if (!result[dir]) {
+        result[dir] = [];
       }
+      result[dir].push(file);
+    });
+    return result;
+  }
+  /**
+   * Internal method to set native watcher
+   * @internal
+   */
+  _setWatcher(watcher) {
+    this._watcher = watcher;
+  }
+};
+function getBaseDirectory(pattern) {
+  const parts = pattern.split(/[\\\/]/);
+  let baseDir = "";
+  for (const part of parts) {
+    if (part.includes("*") || part.includes("?")) {
+      break;
     }
+    baseDir = baseDir ? `${baseDir}/${part}` : part;
   }
-  return null;
+  return baseDir || ".";
 }
-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") {
+function matchesPattern(filePath, pattern) {
+  const regexPattern = normalizePath2(pattern).replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\?/g, ".");
+  const regex = new RegExp(`^${regexPattern}$`);
+  const normalizedPath = normalizePath2(filePath);
+  return regex.test(normalizedPath);
+}
+function watch(paths, options) {
+  const watcher = new FSWatcher(options);
+  const pathArray = Array.isArray(paths) ? paths : [paths];
+  const watchMap = /* @__PURE__ */ new Map();
+  pathArray.forEach((path) => {
+    const baseDir = getBaseDirectory(path);
+    if (!watchMap.has(baseDir)) {
+      watchMap.set(baseDir, []);
+    }
+    watchMap.get(baseDir).push(path);
+  });
+  if (runtime === "node") {
+    const fs2 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+  } else if (runtime === "bun") {
+    const fs2 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
+  } else if (runtime === "deno") {
+    const baseDirs = Array.from(watchMap.keys());
+    const allPatterns = Array.from(watchMap.values()).flat();
+    (async () => {
       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");
+        const denoWatcher = Deno.watchFs(baseDirs);
+        for await (const event of denoWatcher) {
+          if (watcher["_closed"]) break;
+          for (const path of event.paths) {
+            const normalizedPath = normalizePath2(path);
+            if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
+            switch (event.kind) {
+              case "create":
+                emitEvent(watcher, "add", path);
+                break;
+              case "modify":
+                emitEvent(watcher, "change", path);
+                break;
+              case "remove":
+                emitEvent(watcher, "unlink", path);
+                break;
+            }
+          }
+        }
+      } catch (error) {
+        if (!watcher["_closed"]) {
+          watcher.emit("error", error);
+        }
       }
-    } else {
-      const { pathToFileURL } = await import("url");
-      const configModule = await import(pathToFileURL(configPath).href);
-      return configModule.default || configModule;
-    }
+    })();
+    pathArray.forEach((path) => watcher.add(path));
+    queueMicrotask(() => watcher.emit("ready"));
   }
+  return watcher;
 }
-function mergeConfig(config, cliArgs) {
-  if (!config) {
-    return cliArgs;
+
+// src/server.ts
+init_fs();
+init_path();
+
+// src/mime-types.ts
+init_runtime();
+var MIME_TYPES = {
+  // Text
+  "txt": "text/plain",
+  "html": "text/html",
+  "htm": "text/html",
+  "css": "text/css",
+  "js": "text/javascript",
+  "mjs": "text/javascript",
+  "json": "application/json",
+  "xml": "application/xml",
+  "csv": "text/csv",
+  "md": "text/markdown",
+  "markdown": "text/x-markdown",
+  // Images
+  "png": "image/png",
+  "jpg": "image/jpeg",
+  "jpeg": "image/jpeg",
+  "gif": "image/gif",
+  "svg": "image/svg+xml",
+  "webp": "image/webp",
+  "ico": "image/x-icon",
+  "bmp": "image/bmp",
+  "tiff": "image/tiff",
+  "tif": "image/tiff",
+  // Audio
+  "mp3": "audio/mpeg",
+  "wav": "audio/wav",
+  "ogg": "audio/ogg",
+  "aac": "audio/aac",
+  "m4a": "audio/mp4",
+  "flac": "audio/flac",
+  // Video
+  "mp4": "video/mp4",
+  "webm": "video/webm",
+  "avi": "video/x-msvideo",
+  "mov": "video/quicktime",
+  "mkv": "video/x-matroska",
+  "flv": "video/x-flv",
+  // Application
+  "pdf": "application/pdf",
+  "zip": "application/zip",
+  "gz": "application/gzip",
+  "tar": "application/x-tar",
+  "rar": "application/x-rar-compressed",
+  "7z": "application/x-7z-compressed",
+  // Documents
+  "doc": "application/msword",
+  "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "xls": "application/vnd.ms-excel",
+  "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "ppt": "application/vnd.ms-powerpoint",
+  "pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  // Fonts
+  "woff": "font/woff",
+  "woff2": "font/woff2",
+  "ttf": "font/ttf",
+  "otf": "font/otf",
+  "eot": "application/vnd.ms-fontobject",
+  // Web
+  "wasm": "application/wasm",
+  "manifest": "application/manifest+json",
+  // Binary
+  "bin": "application/octet-stream",
+  "exe": "application/x-msdownload",
+  "dll": "application/x-msdownload",
+  // TypeScript/Modern JS
+  "ts": "text/typescript",
+  "tsx": "text/tsx",
+  "jsx": "text/jsx"
+};
+var TYPE_TO_EXTENSIONS = {};
+for (const ext in MIME_TYPES) {
+  const type = MIME_TYPES[ext];
+  if (!TYPE_TO_EXTENSIONS[type]) {
+    TYPE_TO_EXTENSIONS[type] = [];
   }
-  return {
-    ...config,
-    ...Object.fromEntries(
-      Object.entries(cliArgs).filter(([_, v]) => v !== void 0)
-    )
-  };
+  TYPE_TO_EXTENSIONS[type].push(ext);
+}
+function getExtension(path) {
+  const match = /\.([^./\\]+)$/.exec(path);
+  return match ? match[1].toLowerCase() : "";
+}
+function lookup(path) {
+  const ext = getExtension(path) || path.toLowerCase();
+  return MIME_TYPES[ext] || false;
 }
 
 // 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");
+init_runtime();
 
 // src/dom.ts
+function resolveElement(rootElement) {
+  return typeof rootElement === "string" ? document.getElementById(rootElement.replace("#", "")) : rootElement;
+}
+function ensureElement(el, rootElement) {
+  if (!el) {
+    throw new Error(`Element not found: ${rootElement}`);
+  }
+  return el;
+}
+function shouldSkipChild(child) {
+  return child == null || child === false;
+}
+function isPrimitiveJson(json2) {
+  return json2 == null || typeof json2 === "boolean" || typeof json2 === "string" || typeof json2 === "number";
+}
 var DomNode = class {
   constructor() {
     this.elementCache = /* @__PURE__ */ new WeakMap();
@@ -309,11 +2445,11 @@ var DomNode = class {
     const renderChildren = (target) => {
       for (let i = 0; i < len; i++) {
         const child = children[i];
-        if (child == null || child === false) continue;
+        if (shouldSkipChild(child)) 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);
+            !shouldSkipChild(c) && this.renderToDOM(c, target);
           }
         } else {
           this.renderToDOM(child, target);
@@ -330,10 +2466,8 @@ var DomNode = class {
     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}`);
-    }
+    const el = ensureElement(resolveElement(rootElement), rootElement);
+    el.innerHTML = "";
     if (vNode.children && vNode.children.length > 500) {
       const fragment = document.createDocumentFragment();
       this.renderToDOM(vNode, fragment);
@@ -344,10 +2478,7 @@ var DomNode = class {
     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 el = ensureElement(resolveElement(rootElement), rootElement);
     const len = vNodes.length;
     if (len > 3e3) {
       const fragment = document.createDocumentFragment();
@@ -376,10 +2507,7 @@ var DomNode = class {
     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 el = ensureElement(resolveElement(rootElement), rootElement);
     const len = vNodes.length;
     let index = 0;
     const renderChunk = () => {
@@ -489,7 +2617,7 @@ var DomNode = class {
       const end = Math.min(items.length, Math.ceil((scrollTop + viewportHeight) / itemHeight) + bufferSize);
       return { start, end };
     };
-    const render = () => {
+    const render2 = () => {
       const { start, end } = getVisibleRange();
       const wrapper = document.createElement("div");
       wrapper.style.cssText = `height:${totalHeight}px;position:relative`;
@@ -504,12 +2632,12 @@ var DomNode = class {
     };
     const scrollHandler = () => {
       scrollTop = container.scrollTop;
-      requestAnimationFrame(render);
+      requestAnimationFrame(render2);
     };
     container.addEventListener("scroll", scrollHandler);
-    render();
+    render2();
     return {
-      render,
+      render: render2,
       destroy: () => {
         container.removeEventListener("scroll", scrollHandler);
         container.innerHTML = "";
@@ -586,10 +2714,10 @@ var DomNode = class {
       if (pretty && hasComplexChildren) {
         html += newLine;
         for (const child of resolvedChildren) {
-          if (child == null || child === false) continue;
+          if (shouldSkipChild(child)) continue;
           if (Array.isArray(child)) {
             for (const c of child) {
-              if (c != null && c !== false) {
+              if (!shouldSkipChild(c)) {
                 html += this.renderToString(c, { pretty, indent: indent + 1 });
               }
             }
@@ -600,10 +2728,10 @@ var DomNode = class {
         html += indentStr;
       } else {
         for (const child of resolvedChildren) {
-          if (child == null || child === false) continue;
+          if (shouldSkipChild(child)) continue;
           if (Array.isArray(child)) {
             for (const c of child) {
-              if (c != null && c !== false) {
+              if (!shouldSkipChild(c)) {
                 html += this.renderToString(c, { pretty: false, indent: 0 });
               }
             }
@@ -744,17 +2872,14 @@ var DomNode = class {
     }
     return currentValue;
   }
-  jsonToVNode(json) {
-    if (this.isState(json)) {
-      return this.createReactiveChild(json, (v) => v);
+  jsonToVNode(json2) {
+    if (this.isState(json2)) {
+      return this.createReactiveChild(json2, (v) => v);
     }
-    if (json == null || typeof json === "boolean") {
-      return json;
+    if (isPrimitiveJson(json2)) {
+      return json2;
     }
-    if (typeof json === "string" || typeof json === "number") {
-      return json;
-    }
-    const { tag, attributes = {}, children } = json;
+    const { tag, attributes = {}, children } = json2;
     const props = {};
     for (const key in attributes) {
       const value = attributes[key];
@@ -790,17 +2915,14 @@ var DomNode = class {
     }
     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;
+  vNodeJsonToVNode(json2) {
+    if (this.isState(json2)) {
+      return this.createReactiveChild(json2, (v) => v);
     }
-    if (typeof json === "string" || typeof json === "number") {
-      return json;
+    if (isPrimitiveJson(json2)) {
+      return json2;
     }
-    const { tagName, props = {}, children = [] } = json;
+    const { tagName, props = {}, children = [] } = json2;
     const resolvedProps = {};
     for (const key in props) {
       const value = props[key];
@@ -819,57 +2941,28 @@ var DomNode = class {
     }
     return { tagName, props: resolvedProps, children: childrenArray };
   }
-  renderJson(rootElement, json) {
-    const vNode = this.jsonToVNode(json);
+  renderJson(rootElement, json2) {
+    const vNode = this.jsonToVNode(json2);
     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);
+  renderVNode(rootElement, json2) {
+    const vNode = this.vNodeJsonToVNode(json2);
     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);
+  renderJsonToString(json2, options = {}) {
+    const vNode = this.jsonToVNode(json2);
     return this.renderToString(vNode, options);
   }
-  renderVNodeToString(json, options = {}) {
-    const vNode = this.vNodeJsonToVNode(json);
+  renderVNodeToString(json2, options = {}) {
+    const vNode = this.vNodeJsonToVNode(json2);
     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;
@@ -922,8 +3015,49 @@ var DomNode = class {
   }
 };
 var dom = new DomNode();
+var render = dom.render.bind(dom);
+var renderToString = dom.renderToString.bind(dom);
 
 // src/server.ts
+var json = (res, data, status = 200) => (res.writeHead(status, { "Content-Type": "application/json" }), res.end(JSON.stringify(data)));
+var sendError = (res, code, msg) => {
+  res.writeHead(code, { "Content-Type": "text/plain" });
+  res.end(msg);
+};
+var send404 = (res, msg = "Not Found") => sendError(res, 404, msg);
+var send403 = (res, msg = "Forbidden") => sendError(res, 403, msg);
+var send500 = (res, msg = "Internal Server Error") => sendError(res, 500, msg);
+var createElitImportMap = (basePath = "", mode = "dev") => {
+  const srcPath = mode === "dev" ? basePath ? `${basePath}/node_modules/elit/src` : "/node_modules/elit/src" : basePath ? `${basePath}/dist` : "/dist";
+  const fileExt = mode === "dev" ? ".ts" : ".mjs";
+  return `<script type="importmap">{"imports":{"elit":"${srcPath}/index${fileExt}","elit/":"${srcPath}/","elit/dom":"${srcPath}/dom${fileExt}","elit/state":"${srcPath}/state${fileExt}","elit/style":"${srcPath}/style${fileExt}","elit/el":"${srcPath}/el${fileExt}","elit/router":"${srcPath}/router${fileExt}","elit/hmr":"${srcPath}/hmr${fileExt}","elit/types":"${srcPath}/types${fileExt}"}}</script>`;
+};
+var createHMRScript = (port, wsPath) => `<script>(function(){let ws;let retries=0;let maxRetries=5;function connect(){ws=new WebSocket('ws://'+window.location.hostname+':${port}${wsPath}');ws.onopen=()=>{console.log('[Elit HMR] Connected');retries=0};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=()=>{if(retries<maxRetries){retries++;setTimeout(connect,1000*retries)}else if(retries===maxRetries){console.log('[Elit HMR] Connection closed. Start dev server to reconnect.')}};ws.onerror=()=>{ws.close()}}connect()})();</script>`;
+var rewriteRelativePaths = (html, basePath) => {
+  if (!basePath) return html;
+  html = html.replace(/(<script[^>]+src=["'])(?!https?:\/\/|\/)(\.\/)?([^"']+)(["'])/g, `$1${basePath}/$3$4`);
+  html = html.replace(/(<link[^>]+href=["'])(?!https?:\/\/|\/)(\.\/)?([^"']+)(["'])/g, `$1${basePath}/$3$4`);
+  return html;
+};
+var normalizeBasePath = (basePath) => basePath && basePath !== "/" ? basePath : "";
+async function findSpecialDir(startDir, targetDir) {
+  let currentDir = startDir;
+  const maxLevels = 5;
+  for (let i = 0; i < maxLevels; i++) {
+    const targetPath = resolve(currentDir, targetDir);
+    try {
+      const stats = await stat(targetPath);
+      if (stats.isDirectory()) {
+        return currentDir;
+      }
+    } catch {
+    }
+    const parentDir = resolve(currentDir, "..");
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
 function rewritePath(path, pathRewrite) {
   if (!pathRewrite) return path;
   for (const [from, to] of Object.entries(pathRewrite)) {
@@ -944,34 +3078,49 @@ function createProxyHandler(proxyConfigs) {
     try {
       const targetUrl = new URL(target);
       const isHttps = targetUrl.protocol === "https:";
-      const requestLib = isHttps ? import_https.request : import_http.request;
+      const requestLib = isHttps ? request2 : 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 || {}
+      const proxyUrl = `${isHttps ? "https" : "http"}://${targetUrl.hostname}:${targetUrl.port || (isHttps ? 443 : 80)}${proxyPath}`;
+      const proxyReqHeaders = {};
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value !== void 0) {
+          proxyReqHeaders[key] = value;
         }
-      };
+      }
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          if (value !== void 0) {
+            proxyReqHeaders[key] = value;
+          }
+        }
+      }
       if (changeOrigin) {
-        proxyReqOptions.headers.host = targetUrl.host;
+        proxyReqHeaders.host = targetUrl.host;
       }
-      delete proxyReqOptions.headers["host"];
-      const proxyReq = requestLib(proxyReqOptions, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
+      delete proxyReqHeaders["host"];
+      const proxyReqOptions = {
+        method: req.method,
+        headers: proxyReqHeaders
+      };
+      const proxyReq = requestLib(proxyUrl, proxyReqOptions, (proxyRes) => {
+        const outgoingHeaders = {};
+        for (const [key, value] of Object.entries(proxyRes.headers)) {
+          if (value !== void 0) {
+            outgoingHeaders[key] = value;
+          }
+        }
+        res.writeHead(proxyRes.statusCode || 200, outgoingHeaders);
+        proxyRes.on("data", (chunk) => res.write(chunk));
+        proxyRes.on("end", () => res.end());
       });
       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" }));
+          json(res, { error: "Bad Gateway", message: "Proxy error" }, 502);
         }
       });
-      req.pipe(proxyReq);
+      req.on("data", (chunk) => proxyReq.write(chunk));
+      req.on("end", () => proxyReq.end());
       return true;
     } catch (error) {
       console.error("[Proxy] Invalid proxy configuration for %s:", path, error);
@@ -1017,10 +3166,10 @@ var SharedState = class {
   }
   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));
+    this.listeners.forEach((ws) => ws.readyState === 1 /* OPEN */ && ws.send(message));
   }
   sendTo(ws) {
-    if (ws.readyState === import_ws.WebSocket.OPEN) {
+    if (ws.readyState === 1 /* OPEN */) {
       ws.send(JSON.stringify({ type: "state:init", key: this.key, value: this._value, timestamp: Date.now() }));
     }
   }
@@ -1086,13 +3235,14 @@ var defaultOptions = {
   ignore: ["node_modules/**", "dist/**", ".git/**", "**/*.d.ts"],
   logging: true,
   middleware: [],
-  worker: []
+  worker: [],
+  mode: "dev"
 };
 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;
+  const clientsToNormalize = config.clients?.length ? config.clients : config.root ? [{ root: config.root, basePath: config.basePath || "", index: config.index, ssr: config.ssr, api: config.api, proxy: config.proxy, mode: config.mode }] : null;
   if (!clientsToNormalize) throw new Error('DevServerOptions must include either "clients" array or "root" directory');
   const normalizedClients = clientsToNormalize.map((client) => {
     let basePath = client.basePath || "";
@@ -1101,22 +3251,28 @@ function createDevServer(options) {
       while (basePath.endsWith("/")) basePath = basePath.slice(0, -1);
       basePath = basePath ? "/" + basePath : "";
     }
+    let indexPath = client.index;
+    if (indexPath) {
+      indexPath = indexPath.replace(/^\.\//, "/");
+      if (!indexPath.startsWith("/")) {
+        indexPath = "/" + indexPath;
+      }
+    }
     return {
       root: client.root,
       basePath,
+      index: indexPath,
       ssr: client.ssr,
-      proxyHandler: client.proxy ? createProxyHandler(client.proxy) : void 0
+      api: client.api,
+      proxyHandler: client.proxy ? createProxyHandler(client.proxy) : void 0,
+      mode: client.mode || "dev"
     };
   });
   const globalProxyHandler = config.proxy ? createProxyHandler(config.proxy) : null;
-  const server = (0, import_http.createServer)(async (req, res) => {
+  const server = 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) return send404(res, "404 Not Found");
     if (matchedClient.proxyHandler) {
       try {
         const proxied = await matchedClient.proxyHandler(req, res);
@@ -1140,42 +3296,52 @@ function createDevServer(options) {
       }
     }
     const url = matchedClient.basePath ? originalUrl.slice(matchedClient.basePath.length) || "/" : originalUrl;
+    if (matchedClient.api && url.startsWith("/api")) {
+      const handled = await matchedClient.api.handle(req, res);
+      if (handled) return;
+    }
     if (config.api && url.startsWith("/api")) {
       const handled = await config.api.handle(req, res);
       if (handled) return;
     }
-    let filePath = url === "/" ? "/index.html" : url;
+    let filePath;
+    if (url === "/" && matchedClient.ssr && !matchedClient.index) {
+      return serveSSR(res, matchedClient);
+    } else {
+      filePath = url === "/" ? matchedClient.index || "/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;
+      return send403(res, "403 Forbidden");
     }
     const isDistRequest = filePath.startsWith("/dist/");
+    const isNodeModulesRequest = filePath.startsWith("/node_modules/");
     let normalizedPath;
-    const tempPath = (0, import_path2.normalize)(filePath).replace(/\\/g, "/").replace(/^\/+/, "");
+    const tempPath = 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;
+      return send403(res, "403 Forbidden");
     }
     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;
+    const rootDir = await realpath(resolve(matchedClient.root));
+    let baseDir = rootDir;
+    if (isDistRequest || isNodeModulesRequest) {
+      const targetDir = isDistRequest ? "dist" : "node_modules";
+      const foundDir = await findSpecialDir(matchedClient.root, targetDir);
+      baseDir = foundDir ? await realpath(foundDir) : 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;
+      const unresolvedPath = resolve(join(baseDir, normalizedPath));
+      if (!unresolvedPath.startsWith(baseDir.endsWith(sep) ? baseDir : baseDir + sep)) {
+        if (config.logging) console.log(`[403] File access outside of root (before symlink): ${unresolvedPath}`);
+        return send403(res, "403 Forbidden");
       }
+      fullPath = await realpath(unresolvedPath);
       if (config.logging && filePath === "/src/pages") {
         console.log(`[DEBUG] Initial resolve succeeded: ${fullPath}`);
       }
@@ -1187,12 +3353,10 @@ function createDevServer(options) {
       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)) {
+          const tsFullPath = await realpath(resolve(join(baseDir, tsPath)));
+          if (!tsFullPath.startsWith(baseDir.endsWith(sep) ? baseDir : baseDir + 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;
+            return send403(res, "403 Forbidden");
           }
           resolvedPath = tsFullPath;
         } catch {
@@ -1200,19 +3364,19 @@ function createDevServer(options) {
       }
       if (!resolvedPath && !normalizedPath.includes(".")) {
         try {
-          resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)((0, import_path2.join)(baseDir, normalizedPath + ".ts")));
+          resolvedPath = await realpath(resolve(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")));
+            resolvedPath = await realpath(resolve(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")));
+              resolvedPath = await realpath(resolve(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")));
+                resolvedPath = await realpath(resolve(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}`);
@@ -1222,134 +3386,173 @@ function createDevServer(options) {
         }
       }
       if (!resolvedPath) {
-        res.writeHead(404, { "Content-Type": "text/plain" });
-        res.end("404 Not Found");
+        if (!res.headersSent) {
+          if (filePath === "/index.html" && matchedClient.ssr) {
+            return serveSSR(res, matchedClient);
+          }
+          if (config.logging) console.log(`[404] ${filePath}`);
+          return send404(res, "404 Not Found");
+        }
         return;
       }
       fullPath = resolvedPath;
     }
     try {
-      const stats = await (0, import_promises.stat)(fullPath);
+      const stats = await 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")));
+          indexPath = await realpath(resolve(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")));
+            indexPath = await realpath(resolve(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;
+            if (matchedClient.ssr) {
+              return serveSSR(res, matchedClient);
+            }
+            return send404(res, "404 Not Found");
           }
         }
         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;
+      if (config.logging) console.log(`[404] ${filePath}`);
+      return send404(res, "404 Not Found");
     }
     try {
-      const stats = await (0, import_promises.stat)(fullPath);
+      const stats = await 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;
+          const indexPath = await realpath(resolve(join(fullPath, "index.html")));
+          if (!indexPath.startsWith(rootDir + sep) && indexPath !== rootDir) {
+            return send403(res, "403 Forbidden");
           }
-          await (0, import_promises.stat)(indexPath);
+          await stat(indexPath);
           return serveFile(indexPath, res, matchedClient);
         } catch {
-          res.writeHead(404, { "Content-Type": "text/plain" });
-          res.end("404 Not Found");
-          return;
+          return send404(res, "404 Not Found");
         }
       }
       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");
+      if (!res.headersSent) {
+        if (config.logging) console.log(`[404] ${filePath}`);
+        send404(res, "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, ".."));
+      const rootDir = await realpath(resolve(client.root));
+      const unresolvedPath = resolve(filePath);
+      const isNodeModules = filePath.includes("/node_modules/") || filePath.includes("\\node_modules\\");
+      const isDist = filePath.includes("/dist/") || filePath.includes("\\dist\\");
+      const projectRoot = await realpath(resolve(client.root, ".."));
+      const isInProjectRoot = unresolvedPath.startsWith(projectRoot + sep) || unresolvedPath === projectRoot;
+      if (!unresolvedPath.startsWith(rootDir + sep) && unresolvedPath !== rootDir && !isInProjectRoot) {
+        if (!isNodeModules && !isDist) {
+          if (config.logging) console.log(`[403] Attempted to serve file outside allowed directories: ${filePath}`);
+          return send403(res, "403 Forbidden");
+        }
+      }
       let resolvedPath;
       try {
-        resolvedPath = await (0, import_promises.realpath)((0, import_path2.resolve)(filePath));
+        resolvedPath = await realpath(unresolvedPath);
       } 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;
+        return send404(res, "404 Not Found");
       }
-      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";
+      let content = await readFile(resolvedPath);
+      const ext = extname(resolvedPath);
+      let mimeType = lookup(resolvedPath) || "application/octet-stream";
       if (ext === ".ts" || ext === ".tsx") {
         try {
-          const result = await (0, import_esbuild.build)({
-            stdin: {
-              contents: content.toString(),
+          let transpiled;
+          if (isDeno) {
+            const result = await Deno.emit(resolvedPath, {
+              check: false,
+              compilerOptions: {
+                sourceMap: true,
+                inlineSourceMap: true,
+                target: "ES2020",
+                module: "esnext"
+              },
+              sources: {
+                [resolvedPath]: content.toString()
+              }
+            });
+            transpiled = result.files[resolvedPath.replace(/\.tsx?$/, ".js")] || "";
+          } else if (isBun) {
+            const transpiler = new Bun.Transpiler({
               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);
+              target: "browser"
+            });
+            transpiled = transpiler.transformSync(content.toString());
+          } else {
+            const { build: build2 } = await import("esbuild");
+            const result = await build2({
+              stdin: {
+                contents: content.toString(),
+                loader: ext === ".tsx" ? "tsx" : "ts",
+                resolveDir: resolve(resolvedPath, ".."),
+                sourcefile: resolvedPath
+              },
+              format: "esm",
+              target: "es2020",
+              write: false,
+              bundle: false,
+              sourcemap: "inline"
+            });
+            transpiled = result.outputFiles[0].text;
+          }
+          transpiled = transpiled.replace(
+            /from\s+["']([^"']+)\.ts(x?)["']/g,
+            (_, path, tsx) => `from "${path}.js${tsx}"`
+          );
+          transpiled = transpiled.replace(
+            /import\s+["']([^"']+)\.ts(x?)["']/g,
+            (_, path, tsx) => `import "${path}.js${tsx}"`
+          );
+          content = Buffer.from(transpiled);
           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;
+          return send500(res, `TypeScript compilation error:
+${error}`);
         }
       }
       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>`;
+        const wsPath = normalizeBasePath(client.basePath);
+        const hmrScript = createHMRScript(config.port, wsPath);
         let html = content.toString();
+        let ssrStyles = "";
+        if (client.ssr) {
+          try {
+            const result = client.ssr();
+            let ssrHtml;
+            if (typeof result === "string") {
+              ssrHtml = result;
+            } else if (typeof result === "object" && result !== null && "tagName" in result) {
+              ssrHtml = dom.renderToString(result);
+            } else {
+              ssrHtml = String(result);
+            }
+            const styleMatches = ssrHtml.match(/<style[^>]*>[\s\S]*?<\/style>/g);
+            if (styleMatches) {
+              ssrStyles = styleMatches.join("\n");
+            }
+          } catch (error) {
+            if (config.logging) console.error("[Warning] Failed to extract styles from SSR:", error);
+          }
+        }
+        const basePath = normalizeBasePath(client.basePath);
+        html = rewriteRelativePaths(html, basePath);
         if (client.basePath && client.basePath !== "/") {
           const baseTag = `<base href="${client.basePath}/">`;
           if (!html.includes("<base")) {
@@ -1365,7 +3568,10 @@ ${error}`);
             }
           }
         }
-        html = html.includes("</head>") ? html.replace("</head>", `${importMap}</head>`) : html;
+        const elitImportMap = createElitImportMap(basePath, client.mode);
+        const headInjection = ssrStyles ? `${ssrStyles}
+${elitImportMap}` : elitImportMap;
+        html = html.includes("</head>") ? html.replace("</head>", `${headInjection}</head>`) : html;
         html = html.includes("</body>") ? html.replace("</body>", `${hmrScript}</body>`) : html + hmrScript;
         content = Buffer.from(html);
       }
@@ -1386,19 +3592,16 @@ ${error}`);
         res.writeHead(200, headers);
         res.end(content);
       }
-      if (config.logging) console.log(`[200] ${(0, import_path2.relative)(client.root, filePath)}`);
+      if (config.logging) console.log(`[200] ${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);
+      send500(res, "500 Internal Server Error");
     }
   }
   function serveSSR(res, client) {
     try {
       if (!client.ssr) {
-        res.writeHead(500, { "Content-Type": "text/plain" });
-        res.end("SSR function not configured");
-        return;
+        return send500(res, "SSR function not configured");
       }
       const result = client.ssr();
       let html;
@@ -1414,24 +3617,30 @@ ${error}`);
       } 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>`;
+      const basePath = normalizeBasePath(client.basePath);
+      html = rewriteRelativePaths(html, basePath);
+      const hmrScript = createHMRScript(config.port, basePath);
+      const elitImportMap = createElitImportMap(basePath, client.mode);
+      html = html.includes("</head>") ? html.replace("</head>", `${elitImportMap}</head>`) : html;
       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);
+      send500(res, "500 SSR Error");
     }
   }
-  const wss = new import_ws.WebSocketServer({ server });
-  wss.on("connection", (ws) => {
+  const wss = new WebSocketServer({ server });
+  if (config.logging) {
+    console.log("[HMR] WebSocket server initialized");
+  }
+  wss.on("connection", (ws, req) => {
     wsClients.add(ws);
     const message = { type: "connected", timestamp: Date.now() };
     ws.send(JSON.stringify(message));
     if (config.logging) {
-      console.log("[HMR] Client connected");
+      console.log("[HMR] Client connected from", req.socket.remoteAddress);
     }
     ws.on("message", (data) => {
       try {
@@ -1467,17 +3676,17 @@ ${error}`);
     });
   });
   const watchPaths = normalizedClients.flatMap(
-    (client) => config.watch.map((pattern) => (0, import_path2.join)(client.root, pattern))
+    (client) => config.watch.map((pattern) => join(client.root, pattern))
   );
-  const watcher = (0, import_chokidar.watch)(watchPaths, {
-    ignored: config.ignore,
+  const watcher = watch(watchPaths, {
+    ignored: (path) => config.ignore.some((pattern) => path.includes(pattern.replace("/**", "").replace("**/", ""))),
     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));
+    wsClients.forEach((client) => client.readyState === 1 /* 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}`));
@@ -1524,10 +3733,10 @@ ${error}`);
     wss.close();
     wsClients.forEach((client) => client.close());
     wsClients.clear();
-    return new Promise((resolve4) => {
+    return new Promise((resolve2) => {
       server.close(() => {
         if (config.logging) console.log("[Server] Closed");
-        resolve4();
+        resolve2();
       });
     });
   };
@@ -1543,9 +3752,47 @@ ${error}`);
 }
 
 // src/build.ts
-var import_esbuild2 = require("esbuild");
-var import_fs2 = require("fs");
-var import_path3 = require("path");
+init_fs();
+init_path();
+init_runtime();
+function ensureDir(dirPath) {
+  try {
+    mkdirSync(dirPath, { recursive: true });
+  } catch (error) {
+  }
+}
+function calculateBuildMetrics(startTime, outputPath) {
+  const buildTime = Date.now() - startTime;
+  const stats = statSync(outputPath);
+  return { buildTime, size: stats.size };
+}
+function readFileAsString2(filePath) {
+  const contentBuffer = readFileSync(filePath, "utf-8");
+  return typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString("utf-8");
+}
+function getMinifyOptions(minify) {
+  return minify ? {
+    minifyWhitespace: true,
+    minifyIdentifiers: true,
+    minifySyntax: true,
+    legalComments: "none",
+    mangleProps: /^_/,
+    keepNames: false
+  } : {};
+}
+function logBuildInfo(config, outputPath) {
+  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}`);
+}
+function logBuildSuccess(buildTime, size) {
+  console.log(`
+\u2705 Build successful!`);
+  console.log(`  Time: ${buildTime}ms`);
+  console.log(`  Size: ${formatBytes(size)}`);
+}
 var defaultOptions2 = {
   outDir: "dist",
   minify: true,
@@ -1556,42 +3803,35 @@ var defaultOptions2 = {
   logging: true,
   external: []
 };
-async function build2(options) {
+async function build(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);
+  const entryPath = resolve(config.entry);
+  const outDir = resolve(config.outDir);
   let outFile = config.outFile;
   if (!outFile) {
-    const baseName = (0, import_path3.basename)(config.entry, (0, import_path3.extname)(config.entry));
+    const baseName = basename(config.entry, 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) {
-  }
+  const outputPath = join(outDir, outFile);
+  ensureDir(outDir);
   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}`);
+    logBuildInfo(config, outputPath);
   }
   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)$/ }, () => {
+    setup(build2) {
+      build2.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)$/ }, () => {
+      build2.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$/ }, () => {
+      build2.onLoad({ filter: /[\\/](server|config|cli)\.ts$/ }, () => {
         return {
           contents: "export {}",
           loader: "js"
@@ -1615,54 +3855,83 @@ async function build2(options) {
       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
+    let result;
+    let buildTime;
+    let size;
+    if (runtime === "node") {
+      const { build: esbuild } = await import("esbuild");
+      result = await esbuild({
+        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
+        ...getMinifyOptions(config.minify)
+      });
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    } else if (runtime === "bun") {
+      result = await Bun.build({
+        entrypoints: [entryPath],
+        outdir: outDir,
+        target: "bun",
+        format: config.format === "cjs" ? "cjs" : "esm",
+        minify: config.minify,
+        sourcemap: config.sourcemap ? "external" : "none",
+        external: config.external,
+        naming: outFile,
+        define
+      });
+      if (!result.success) {
+        throw new Error("Bun build failed: " + JSON.stringify(result.logs));
       }
-    });
-    const buildTime = Date.now() - startTime;
-    const stats = (0, import_fs2.statSync)(outputPath);
-    const size = stats.size;
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    } else {
+      result = await Deno.emit(entryPath, {
+        bundle: "module",
+        check: false,
+        compilerOptions: {
+          target: config.target,
+          module: config.format === "cjs" ? "commonjs" : "esnext",
+          sourceMap: config.sourcemap
+        }
+      });
+      const bundledCode = result.files["deno:///bundle.js"];
+      if (bundledCode) {
+        await Deno.writeTextFile(outputPath, bundledCode);
+      }
+      ({ buildTime, size } = calculateBuildMetrics(startTime, outputPath));
+    }
     if (config.logging) {
-      console.log(`
-\u2705 Build successful!`);
-      console.log(`  Time: ${buildTime}ms`);
-      console.log(`  Size: ${formatBytes(size)}`);
-      if (result.metafile) {
+      logBuildSuccess(buildTime, size);
+      if (runtime === "node" && 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);
+            const sortedInputs = Object.entries(mainOutput.inputs).sort(([, a], [, b]) => {
+              const aBytes = a.bytesInOutput || 0;
+              const bBytes = b.bytesInOutput || 0;
+              return bBytes - aBytes;
+            }).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 infoBytes = info.bytesInOutput || 0;
+                console.log(`     ${fileName.padEnd(30)} ${formatBytes(infoBytes)}`);
               });
             }
           }
@@ -1679,19 +3948,19 @@ async function build2(options) {
         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 });
+        const fromPath = resolve(copyItem.from);
+        const toPath = resolve(outDir, copyItem.to);
+        const targetDir = dirname(toPath);
+        if (!existsSync(targetDir)) {
+          ensureDir(targetDir);
         }
-        if ((0, import_fs2.existsSync)(fromPath)) {
+        if (existsSync(fromPath)) {
           if (copyItem.transform) {
-            const content = (0, import_fs2.readFileSync)(fromPath, "utf-8");
+            const content = readFileAsString2(fromPath);
             const transformed = copyItem.transform(content, config);
-            (0, import_fs2.writeFileSync)(toPath, transformed);
+            writeFileSync(toPath, transformed);
           } else {
-            (0, import_fs2.copyFileSync)(fromPath, toPath);
+            copyFileSync(fromPath, toPath);
           }
           if (config.logging) {
             console.log(`  \u2713 ${copyItem.from} \u2192 ${copyItem.to}`);
@@ -1726,6 +3995,50 @@ function formatBytes(bytes) {
 
 // src/cli.ts
 var COMMANDS = ["dev", "build", "preview", "help", "version"];
+function setupShutdownHandlers(closeFunc) {
+  const shutdown = async () => {
+    console.log("\n[Server] Shutting down...");
+    await closeFunc();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+async function executeBuild(options) {
+  try {
+    await build(options);
+  } catch (error) {
+    process.exit(1);
+  }
+}
+function validateEntry(entry, buildIndex) {
+  if (!entry) {
+    if (buildIndex !== void 0) {
+      console.error(`Error: Entry file is required for build #${buildIndex + 1}`);
+    } else {
+      console.error("Error: Entry file is required");
+      console.error("Specify in config file or use --entry <file>");
+    }
+    process.exit(1);
+  }
+}
+function ensureEnv(options, env) {
+  if (!options.env) {
+    options.env = env;
+  }
+}
+function parseArgs(args, handlers, options) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const handler = handlers[arg];
+    if (handler) {
+      const index = { current: i };
+      handler(options, args[i + 1], index);
+      i = index.current;
+    }
+  }
+  return options;
+}
 async function main() {
   const args = process.argv.slice(2);
   const command = args[0] || "help";
@@ -1760,14 +4073,9 @@ async function runDev(args) {
   if (!options.root && (!options.clients || options.clients.length === 0)) {
     options.root = process.cwd();
   }
+  options.mode = "dev";
   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);
+  setupShutdownHandlers(() => devServer.close());
 }
 async function runBuild(args) {
   const cliOptions = parseBuildArgs(args);
@@ -1778,34 +4086,19 @@ async function runBuild(args) {
     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);
-      }
+      ensureEnv(options, env);
+      validateEntry(options.entry);
+      await executeBuild(options);
     } 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);
-        }
+        ensureEnv(buildConfig, env);
+        validateEntry(buildConfig.entry, i);
         console.log(`[${i + 1}/${builds.length}] Building ${buildConfig.entry}...`);
         try {
-          await build2(buildConfig);
+          await build(buildConfig);
         } catch (error) {
           console.error(`Build #${i + 1} failed`);
           process.exit(1);
@@ -1819,19 +4112,9 @@ async function runBuild(args) {
     }
   } 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);
-    }
+    ensureEnv(options, env);
+    validateEntry(options.entry);
+    await executeBuild(options);
   }
 }
 async function runPreview(args) {
@@ -1862,6 +4145,7 @@ async function runPreview(args) {
     const defaultOutDir = Array.isArray(buildConfig) ? buildConfig[0]?.outDir : buildConfig?.outDir;
     options.root = mergedOptions.root || defaultOutDir || "dist";
     options.basePath = mergedOptions.basePath;
+    options.index = mergedOptions.index;
     console.log("Starting preview server...");
     console.log(`  Root:  ${options.root}`);
   }
@@ -1883,115 +4167,128 @@ async function runPreview(args) {
   if (mergedOptions.ssr) {
     options.ssr = mergedOptions.ssr;
   }
+  options.mode = "preview";
   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);
+  setupShutdownHandlers(() => devServer.close());
 }
 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;
+  const handlers = {
+    "-p": (opts, value, index) => {
+      opts.port = parseInt(value, 10);
+      index.current++;
+    },
+    "--port": (opts, value, index) => {
+      opts.port = parseInt(value, 10);
+      index.current++;
+    },
+    "-h": (opts, value, index) => {
+      opts.host = value;
+      index.current++;
+    },
+    "--host": (opts, value, index) => {
+      opts.host = value;
+      index.current++;
+    },
+    "-r": (opts, value, index) => {
+      opts.root = value;
+      index.current++;
+    },
+    "--root": (opts, value, index) => {
+      opts.root = value;
+      index.current++;
+    },
+    "--no-open": (opts) => {
+      opts.open = false;
+    },
+    "--silent": (opts) => {
+      opts.logging = false;
     }
-  }
-  return options;
+  };
+  return parseArgs(args, handlers, 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;
+  const handlers = {
+    "-e": (opts, value, index) => {
+      opts.entry = value;
+      index.current++;
+    },
+    "--entry": (opts, value, index) => {
+      opts.entry = value;
+      index.current++;
+    },
+    "-o": (opts, value, index) => {
+      opts.outDir = value;
+      index.current++;
+    },
+    "--out-dir": (opts, value, index) => {
+      opts.outDir = value;
+      index.current++;
+    },
+    "--no-minify": (opts) => {
+      opts.minify = false;
+    },
+    "--sourcemap": (opts) => {
+      opts.sourcemap = true;
+    },
+    "-f": (opts, value, index) => {
+      opts.format = value;
+      index.current++;
+    },
+    "--format": (opts, value, index) => {
+      opts.format = value;
+      index.current++;
+    },
+    "--silent": (opts) => {
+      opts.logging = false;
     }
-  }
-  return options;
+  };
+  return parseArgs(args, handlers, 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;
+  const handlers = {
+    "-p": (opts, value, index) => {
+      opts.port = parseInt(value, 10);
+      index.current++;
+    },
+    "--port": (opts, value, index) => {
+      opts.port = parseInt(value, 10);
+      index.current++;
+    },
+    "-h": (opts, value, index) => {
+      opts.host = value;
+      index.current++;
+    },
+    "--host": (opts, value, index) => {
+      opts.host = value;
+      index.current++;
+    },
+    "-r": (opts, value, index) => {
+      opts.root = value;
+      index.current++;
+    },
+    "--root": (opts, value, index) => {
+      opts.root = value;
+      index.current++;
+    },
+    "-b": (opts, value, index) => {
+      opts.basePath = value;
+      index.current++;
+    },
+    "--base-path": (opts, value, index) => {
+      opts.basePath = value;
+      index.current++;
+    },
+    "--no-open": (opts) => {
+      opts.open = false;
+    },
+    "--silent": (opts) => {
+      opts.logging = false;
     }
-  }
-  return options;
+  };
+  return parseArgs(args, handlers, options);
 }
 function printHelp() {
   console.log(`