elit 3.2.0 → 3.2.2

package/dist/server.js

@@ -732,205 +732,205 @@ async function processDenoEntriesAsync(iterator, withFileTypes) {
   }
   return entries;
 }
-async function readFile(path2, options) {
+async function readFile(path, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.readFile(path2, opts);
+    return fsPromises.readFile(path, opts);
   } else if (isBun) {
-    const file = Bun.file(path2);
+    const file = Bun.file(path);
     const content = await file.arrayBuffer();
     return decodeContent(content, opts.encoding);
   } else if (isDeno) {
-    const content = await Deno.readFile(path2);
+    const content = await Deno.readFile(path);
     return decodeContent(content, opts.encoding);
   }
   throw new Error("Unsupported runtime");
 }
-function readFileSync(path2, options) {
+function readFileSync(path, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fs.readFileSync(path2, opts);
+    return fs.readFileSync(path, opts);
   } else if (isBun) {
-    const file = Bun.file(path2);
+    const file = Bun.file(path);
     const content = file.arrayBuffer();
     return decodeContent(content, opts.encoding);
   } else if (isDeno) {
-    const content = Deno.readFileSync(path2);
+    const content = Deno.readFileSync(path);
     return decodeContent(content, opts.encoding);
   }
   throw new Error("Unsupported runtime");
 }
-async function writeFile(path2, data, options) {
+async function writeFile(path, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.writeFile(path2, data, opts);
+    return fsPromises.writeFile(path, data, opts);
   } else if (isBun) {
-    await Bun.write(path2, data);
+    await Bun.write(path, data);
   } else if (isDeno) {
-    await Deno.writeFile(path2, dataToUint8Array(data));
+    await Deno.writeFile(path, dataToUint8Array(data));
   }
 }
-function writeFileSync(path2, data, options) {
+function writeFileSync(path, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    fs.writeFileSync(path2, data, opts);
+    fs.writeFileSync(path, data, opts);
   } else if (isBun) {
-    Bun.write(path2, data);
+    Bun.write(path, data);
   } else if (isDeno) {
-    Deno.writeFileSync(path2, dataToUint8Array(data));
+    Deno.writeFileSync(path, dataToUint8Array(data));
   }
 }
-async function appendFile(path2, data, options) {
+async function appendFile(path, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.appendFile(path2, data, opts);
+    return fsPromises.appendFile(path, data, opts);
   } else {
-    if (await exists(path2)) {
-      const existing = await readFile(path2);
+    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(path2, combined, opts);
+      await writeFile(path, combined, opts);
     } else {
-      await writeFile(path2, data, opts);
+      await writeFile(path, data, opts);
     }
   }
 }
-function appendFileSync(path2, data, options) {
+function appendFileSync(path, data, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    fs.appendFileSync(path2, data, opts);
+    fs.appendFileSync(path, data, opts);
   } else {
-    if (existsSync(path2)) {
-      const existing = readFileSync(path2);
+    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(path2, combined, opts);
+      writeFileSync(path, combined, opts);
     } else {
-      writeFileSync(path2, data, opts);
+      writeFileSync(path, data, opts);
     }
   }
 }
-async function exists(path2) {
+async function exists(path) {
   try {
-    await stat(path2);
+    await stat(path);
     return true;
   } catch {
     return false;
   }
 }
-function existsSync(path2) {
+function existsSync(path) {
   try {
-    statSync(path2);
+    statSync(path);
     return true;
   } catch {
     return false;
   }
 }
-async function stat(path2) {
+async function stat(path) {
   if (isNode) {
-    return fsPromises.stat(path2);
+    return fsPromises.stat(path);
   } else if (isBun) {
-    const file = Bun.file(path2);
+    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 '${path2}'`);
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
     }
-    return createStatsObject(path2, size, false);
+    return createStatsObject(path, size, false);
   } else if (isDeno) {
-    const info = await Deno.stat(path2);
+    const info = await Deno.stat(path);
     return createStatsFromDenoFileInfo(info);
   }
   throw new Error("Unsupported runtime");
 }
-function statSync(path2) {
+function statSync(path) {
   if (isNode) {
-    return fs.statSync(path2);
+    return fs.statSync(path);
   } else if (isBun) {
-    const file = Bun.file(path2);
+    const file = Bun.file(path);
     const size = file.size;
     try {
       file.arrayBuffer();
     } catch {
-      throw new Error(`ENOENT: no such file or directory, stat '${path2}'`);
+      throw new Error(`ENOENT: no such file or directory, stat '${path}'`);
     }
-    return createStatsObject(path2, size, false);
+    return createStatsObject(path, size, false);
   } else if (isDeno) {
-    const info = Deno.statSync(path2);
+    const info = Deno.statSync(path);
     return createStatsFromDenoFileInfo(info);
   }
   throw new Error("Unsupported runtime");
 }
-async function mkdir(path2, options) {
+async function mkdir(path, options) {
   const opts = typeof options === "number" ? { mode: options } : options || {};
   if (isNode) {
-    await fsPromises.mkdir(path2, opts);
+    await fsPromises.mkdir(path, opts);
   } else if (isBun) {
-    await Deno.mkdir(path2, { recursive: opts.recursive });
+    await Deno.mkdir(path, { recursive: opts.recursive });
   } else if (isDeno) {
-    await Deno.mkdir(path2, { recursive: opts.recursive });
+    await Deno.mkdir(path, { recursive: opts.recursive });
   }
 }
-function mkdirSync(path2, options) {
+function mkdirSync(path, options) {
   const opts = typeof options === "number" ? { mode: options } : options || {};
   if (isNode) {
-    fs.mkdirSync(path2, opts);
+    fs.mkdirSync(path, opts);
   } else if (isBun) {
-    Deno.mkdirSync(path2, { recursive: opts.recursive });
+    Deno.mkdirSync(path, { recursive: opts.recursive });
   } else if (isDeno) {
-    Deno.mkdirSync(path2, { recursive: opts.recursive });
+    Deno.mkdirSync(path, { recursive: opts.recursive });
   }
 }
-async function readdir(path2, options) {
+async function readdir(path, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fsPromises.readdir(path2, opts);
+    return fsPromises.readdir(path, opts);
   } else if (isBunOrDeno) {
-    return processDenoEntriesAsync(Deno.readDir(path2), opts.withFileTypes);
+    return processDenoEntriesAsync(Deno.readDir(path), opts.withFileTypes);
   }
   throw new Error("Unsupported runtime");
 }
-function readdirSync(path2, options) {
+function readdirSync(path, options) {
   const opts = parseOptions(options, {});
   if (isNode) {
-    return fs.readdirSync(path2, opts);
+    return fs.readdirSync(path, opts);
   } else if (isBunOrDeno) {
-    return processDenoEntries(Deno.readDirSync(path2), opts.withFileTypes);
+    return processDenoEntries(Deno.readDirSync(path), opts.withFileTypes);
   }
   throw new Error("Unsupported runtime");
 }
-async function unlink(path2) {
+async function unlink(path) {
   if (isNode) {
-    return fsPromises.unlink(path2);
+    return fsPromises.unlink(path);
   } else if (isBun) {
-    await Deno.remove(path2);
+    await Deno.remove(path);
   } else if (isDeno) {
-    await Deno.remove(path2);
+    await Deno.remove(path);
   }
 }
-function unlinkSync(path2) {
+function unlinkSync(path) {
   if (isNode) {
-    fs.unlinkSync(path2);
+    fs.unlinkSync(path);
   } else if (isBun) {
-    Deno.removeSync(path2);
+    Deno.removeSync(path);
   } else if (isDeno) {
-    Deno.removeSync(path2);
+    Deno.removeSync(path);
   }
 }
-async function rmdir(path2, options) {
+async function rmdir(path, options) {
   if (isNode) {
-    return fsPromises.rmdir(path2, options);
+    return fsPromises.rmdir(path, options);
   } else if (isBun) {
-    await Deno.remove(path2, { recursive: options?.recursive });
+    await Deno.remove(path, { recursive: options?.recursive });
   } else if (isDeno) {
-    await Deno.remove(path2, { recursive: options?.recursive });
+    await Deno.remove(path, { recursive: options?.recursive });
   }
 }
-function rmdirSync(path2, options) {
+function rmdirSync(path, options) {
   if (isNode) {
-    fs.rmdirSync(path2, options);
+    fs.rmdirSync(path, options);
   } else if (isBun) {
-    Deno.removeSync(path2, { recursive: options?.recursive });
+    Deno.removeSync(path, { recursive: options?.recursive });
   } else if (isDeno) {
-    Deno.removeSync(path2, { recursive: options?.recursive });
+    Deno.removeSync(path, { recursive: options?.recursive });
   }
 }
 async function rename(oldPath, newPath) {
@@ -969,27 +969,27 @@ function copyFileSync(src, dest, flags) {
     Deno.copyFileSync(src, dest);
   }
 }
-async function realpath(path2, options) {
+async function realpath(path, options) {
   if (isNode) {
-    return fsPromises.realpath(path2, options);
+    return fsPromises.realpath(path, options);
   } else if (isBun) {
-    const fs3 = require("fs/promises");
-    return fs3.realpath(path2, options);
+    const fs2 = require("fs/promises");
+    return fs2.realpath(path, options);
   } else if (isDeno) {
-    return await Deno.realPath(path2);
+    return await Deno.realPath(path);
   }
-  return path2;
+  return path;
 }
-function realpathSync(path2, options) {
+function realpathSync(path, options) {
   if (isNode) {
-    return fs.realpathSync(path2, options);
+    return fs.realpathSync(path, options);
   } else if (isBun) {
-    const fs3 = require("fs");
-    return fs3.realpathSync(path2, options);
+    const fs2 = require("fs");
+    return fs2.realpathSync(path, options);
   } else if (isDeno) {
-    return Deno.realPathSync(path2);
+    return Deno.realPathSync(path);
   }
-  return path2;
+  return path;
 }
 function createStatsObject(_path, size, isDir) {
   const now = Date.now();
@@ -1132,14 +1132,12 @@ __export(server_exports, {
   cors: () => cors,
   createDevServer: () => createDevServer,
   createProxyHandler: () => createProxyHandler,
-  database: () => database,
   errorHandler: () => errorHandler,
   html: () => html,
   json: () => json,
   logger: () => logger,
   rateLimit: () => rateLimit,
   security: () => security,
-  serverDatabase: () => serverDatabase,
   status: () => status,
   text: () => text
 });
@@ -1528,32 +1526,32 @@ var WebSocketServer = class extends import_events2.EventEmitter {
 // src/chokidar.ts
 var import_events3 = require("events");
 init_runtime();
-function normalizePath(path2) {
-  return path2.replace(/\\/g, "/");
+function normalizePath(path) {
+  return path.replace(/\\/g, "/");
 }
-function emitEvent(watcher, eventType, path2) {
-  watcher.emit(eventType, path2);
-  watcher.emit("all", eventType, path2);
+function emitEvent(watcher, eventType, path) {
+  watcher.emit(eventType, path);
+  watcher.emit("all", eventType, path);
 }
-function matchesAnyPattern(path2, patterns) {
-  return patterns.some((pattern) => matchesPattern(path2, pattern));
+function matchesAnyPattern(path, patterns) {
+  return patterns.some((pattern) => matchesPattern(path, pattern));
 }
-function handleRenameEvent(watcher, fullPath, fs3) {
+function handleRenameEvent(watcher, fullPath, fs2) {
   try {
-    fs3.statSync(fullPath);
+    fs2.statSync(fullPath);
     emitEvent(watcher, "add", fullPath);
   } catch {
     emitEvent(watcher, "unlink", fullPath);
   }
 }
-function setupFsWatch(watcher, baseDir, patterns, fs3) {
+function setupFsWatch(watcher, baseDir, patterns, fs2) {
   try {
-    const nativeWatcher = fs3.watch(baseDir, { recursive: true }, (eventType, filename) => {
+    const nativeWatcher = fs2.watch(baseDir, { recursive: true }, (eventType, filename) => {
       if (!filename) return;
       const fullPath = normalizePath(`${baseDir}/${filename}`);
       if (!matchesAnyPattern(fullPath, patterns)) return;
       if (eventType === "rename") {
-        handleRenameEvent(watcher, fullPath, fs3);
+        handleRenameEvent(watcher, fullPath, fs2);
       } else if (eventType === "change") {
         emitEvent(watcher, "change", fullPath);
       }
@@ -1585,7 +1583,7 @@ var FSWatcher = class extends import_events3.EventEmitter {
         this._watcher.add(pathArray);
       }
     } else {
-      pathArray.forEach((path2) => this._watched.add(path2));
+      pathArray.forEach((path) => this._watched.add(path));
     }
     return this;
   }
@@ -1602,7 +1600,7 @@ var FSWatcher = class extends import_events3.EventEmitter {
         this._watcher.unwatch(pathArray);
       }
     } else {
-      pathArray.forEach((path2) => this._watched.delete(path2));
+      pathArray.forEach((path) => this._watched.delete(path));
     }
     return this;
   }
@@ -1629,9 +1627,9 @@ var FSWatcher = class extends import_events3.EventEmitter {
       return this._watcher.getWatched();
     }
     const result = {};
-    this._watched.forEach((path2) => {
-      const dir = path2.substring(0, path2.lastIndexOf("/")) || ".";
-      const file = path2.substring(path2.lastIndexOf("/") + 1);
+    this._watched.forEach((path) => {
+      const dir = path.substring(0, path.lastIndexOf("/")) || ".";
+      const file = path.substring(path.lastIndexOf("/") + 1);
       if (!result[dir]) {
         result[dir] = [];
       }
@@ -1668,19 +1666,19 @@ function watch(paths, options) {
   const watcher = new FSWatcher(options);
   const pathArray = Array.isArray(paths) ? paths : [paths];
   const watchMap = /* @__PURE__ */ new Map();
-  pathArray.forEach((path2) => {
-    const baseDir = getBaseDirectory(path2);
+  pathArray.forEach((path) => {
+    const baseDir = getBaseDirectory(path);
     if (!watchMap.has(baseDir)) {
       watchMap.set(baseDir, []);
     }
-    watchMap.get(baseDir).push(path2);
+    watchMap.get(baseDir).push(path);
   });
   if (runtime === "node") {
-    const fs3 = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs3));
+    const fs2 = require("fs");
+    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs2));
   } else if (runtime === "bun") {
-    const fs3 = require("fs");
-    watchMap.forEach((patterns, baseDir) => setupFsWatch(watcher, baseDir, patterns, fs3));
+    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();
@@ -1689,18 +1687,18 @@ function watch(paths, options) {
         const denoWatcher = Deno.watchFs(baseDirs);
         for await (const event of denoWatcher) {
           if (watcher["_closed"]) break;
-          for (const path2 of event.paths) {
-            const normalizedPath = normalizePath(path2);
+          for (const path of event.paths) {
+            const normalizedPath = normalizePath(path);
             if (!matchesAnyPattern(normalizedPath, allPatterns)) continue;
             switch (event.kind) {
               case "create":
-                emitEvent(watcher, "add", path2);
+                emitEvent(watcher, "add", path);
                 break;
               case "modify":
-                emitEvent(watcher, "change", path2);
+                emitEvent(watcher, "change", path);
                 break;
               case "remove":
-                emitEvent(watcher, "unlink", path2);
+                emitEvent(watcher, "unlink", path);
                 break;
             }
           }
@@ -1711,7 +1709,7 @@ function watch(paths, options) {
         }
       }
     })();
-    pathArray.forEach((path2) => watcher.add(path2));
+    pathArray.forEach((path) => watcher.add(path));
     queueMicrotask(() => watcher.emit("ready"));
   }
   return watcher;
@@ -1733,38 +1731,38 @@ function getCwd() {
   }
   return "/";
 }
-function findLastSeparator(path2) {
-  return Math.max(path2.lastIndexOf("/"), path2.lastIndexOf("\\"));
+function findLastSeparator(path) {
+  return Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
 }
 function createPathOps(isWin) {
   return {
     sep: getSeparator(isWin),
     delimiter: isWin ? ";" : ":",
-    normalize: (path2) => normalizePath2(path2, isWin),
+    normalize: (path) => normalizePath2(path, isWin),
     join: (...paths) => joinPaths(paths, isWin),
     resolve: (...paths) => resolvePaths(paths, isWin),
-    isAbsolute: (path2) => isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2),
+    isAbsolute: (path) => isWin ? isAbsoluteWin(path) : isAbsolutePosix(path),
     relative: (from, to) => relativePath(from, to, isWin),
-    dirname: (path2) => getDirname(path2, isWin),
-    basename: (path2, ext) => getBasename(path2, ext, isWin),
-    extname: (path2) => getExtname(path2),
-    parse: (path2) => parsePath(path2, 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(path2) {
-  return path2.length > 0 && path2[0] === "/";
+function isAbsolutePosix(path) {
+  return path.length > 0 && path[0] === "/";
 }
-function isAbsoluteWin(path2) {
-  const len = path2.length;
+function isAbsoluteWin(path) {
+  const len = path.length;
   if (len === 0) return false;
-  const code = path2.charCodeAt(0);
+  const code = path.charCodeAt(0);
   if (code === 47 || code === 92) {
     return true;
   }
   if (code >= 65 && code <= 90 || code >= 97 && code <= 122) {
-    if (len > 2 && path2.charCodeAt(1) === 58) {
-      const code2 = path2.charCodeAt(2);
+    if (len > 2 && path.charCodeAt(1) === 58) {
+      const code2 = path.charCodeAt(2);
       if (code2 === 47 || code2 === 92) {
         return true;
       }
@@ -1783,12 +1781,12 @@ var isWindows = (() => {
 var sep = isWindows ? "\\" : "/";
 var posix = createPathOps(false);
 var win32 = createPathOps(true);
-function normalizePath2(path2, isWin) {
-  if (path2.length === 0) return ".";
+function normalizePath2(path, isWin) {
+  if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const isAbsolute = isWin ? isAbsoluteWin(path2) : isAbsolutePosix(path2);
-  const trailingSeparator = path2[path2.length - 1] === separator || isWin && path2[path2.length - 1] === "/";
-  let normalized = path2.replace(isWin ? /[\/\\]+/g : /\/+/g, separator);
+  const isAbsolute = 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++) {
@@ -1823,12 +1821,12 @@ function joinPaths(paths, isWin) {
   const separator = getSeparator(isWin);
   let joined = "";
   for (let i = 0; i < paths.length; i++) {
-    const path2 = paths[i];
-    if (path2 && path2.length > 0) {
+    const path = paths[i];
+    if (path && path.length > 0) {
       if (joined.length === 0) {
-        joined = path2;
+        joined = path;
       } else {
-        joined += separator + path2;
+        joined += separator + path;
       }
     }
   }
@@ -1840,9 +1838,9 @@ function resolvePaths(paths, isWin) {
   let resolved = "";
   let isAbsolute = false;
   for (let i = paths.length - 1; i >= 0 && !isAbsolute; i--) {
-    const path2 = paths[i];
-    if (path2 && path2.length > 0) {
-      resolved = path2 + (resolved.length > 0 ? separator + resolved : "");
+    const path = paths[i];
+    if (path && path.length > 0) {
+      resolved = path + (resolved.length > 0 ? separator + resolved : "");
       isAbsolute = isWin ? isAbsoluteWin(resolved) : isAbsolutePosix(resolved);
     }
   }
@@ -1878,51 +1876,51 @@ function relativePath(from, to, isWin) {
   }
   return result.join(separator) || ".";
 }
-function getDirname(path2, isWin) {
-  if (path2.length === 0) return ".";
+function getDirname(path, isWin) {
+  if (path.length === 0) return ".";
   const separator = getSeparator(isWin);
-  const normalized = normalizePath2(path2, isWin);
+  const normalized = normalizePath2(path, isWin);
   const lastSepIndex = normalized.lastIndexOf(separator);
   if (lastSepIndex === -1) return ".";
   if (lastSepIndex === 0) return separator;
   return normalized.slice(0, lastSepIndex);
 }
-function getBasename(path2, ext, isWin) {
-  if (path2.length === 0) return "";
-  const lastSepIndex = isWin ? findLastSeparator(path2) : path2.lastIndexOf("/");
-  let base = lastSepIndex === -1 ? path2 : path2.slice(lastSepIndex + 1);
+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(path2) {
-  const lastDotIndex = path2.lastIndexOf(".");
-  const lastSepIndex = findLastSeparator(path2);
-  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path2.length - 1) {
+function getExtname(path) {
+  const lastDotIndex = path.lastIndexOf(".");
+  const lastSepIndex = findLastSeparator(path);
+  if (lastDotIndex === -1 || lastDotIndex < lastSepIndex || lastDotIndex === path.length - 1) {
     return "";
   }
-  return path2.slice(lastDotIndex);
+  return path.slice(lastDotIndex);
 }
-function parsePath(path2, isWin) {
+function parsePath(path, isWin) {
   let root = "";
   if (isWin) {
-    if (path2.length >= 2 && path2[1] === ":") {
-      root = path2.slice(0, 2);
-      if (path2.length > 2 && (path2[2] === "\\" || path2[2] === "/")) {
+    if (path.length >= 2 && path[1] === ":") {
+      root = path.slice(0, 2);
+      if (path.length > 2 && (path[2] === "\\" || path[2] === "/")) {
         root += "\\";
       }
-    } else if (path2[0] === "\\" || path2[0] === "/") {
+    } else if (path[0] === "\\" || path[0] === "/") {
       root = "\\";
     }
   } else {
-    if (path2[0] === "/") {
+    if (path[0] === "/") {
       root = "/";
     }
   }
-  const dir = getDirname(path2, isWin);
-  const base = getBasename(path2, void 0, isWin);
-  const ext = getExtname(path2);
+  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 };
 }
@@ -1934,8 +1932,8 @@ function formatPath(pathObject, isWin) {
   if (dir === pathObject.root) return dir + base;
   return dir + separator + base;
 }
-function normalize(path2) {
-  return normalizePath2(path2, isWindows);
+function normalize(path) {
+  return normalizePath2(path, isWindows);
 }
 function join(...paths) {
   return joinPaths(paths, isWindows);
@@ -1946,8 +1944,8 @@ function resolve(...paths) {
 function relative(from, to) {
   return relativePath(from, to, isWindows);
 }
-function extname(path2) {
-  return getExtname(path2);
+function extname(path) {
+  return getExtname(path);
 }
 
 // src/mime-types.ts
@@ -2030,12 +2028,12 @@ for (const ext in MIME_TYPES) {
   }
   TYPE_TO_EXTENSIONS[type].push(ext);
 }
-function getExtension(path2) {
-  const match = /\.([^./\\]+)$/.exec(path2);
+function getExtension(path) {
+  const match = /\.([^./\\]+)$/.exec(path);
   return match ? match[1].toLowerCase() : "";
 }
-function lookup(path2) {
-  const ext = getExtension(path2) || path2.toLowerCase();
+function lookup(path) {
+  const ext = getExtension(path) || path.toLowerCase();
   return MIME_TYPES[ext] || false;
 }
 
@@ -2682,497 +2680,29 @@ var dom = new DomNode();
 var render = dom.render.bind(dom);
 var renderToString = dom.renderToString.bind(dom);
 
-// src/database.ts
-var import_node_vm = __toESM(require("vm"));
-var import_node_path = __toESM(require("path"));
-var import_node_fs = __toESM(require("fs"));
-var esbuild = __toESM(require("esbuild"));
-var Database = class {
-  constructor(config) {
-    this._config = {
-      dir: resolve(process.cwd(), "databases")
-    };
-    this._config = { ...this._config, ...config };
-    this._registerModules = config.registerModules || {};
-    this._ctx = import_node_vm.default.createContext(this._registerModules);
-  }
-  set config(config) {
-    this._config = { ...this._config, ...config };
-  }
-  register(context) {
-    this._registerModules = { ...this._registerModules, ...context };
-    this._ctx = import_node_vm.default.createContext(this._registerModules);
-  }
-  plugin(moduleName, moduleContent) {
-    this.register({ [moduleName]: moduleContent });
-  }
-  resolvePath(fileList, query) {
-    const aliases = { "@db": this._config.dir || resolve(process.cwd(), "databases") };
-    let resolvedPath = query;
-    for (const [alias, target] of Object.entries(aliases)) {
-      if (resolvedPath.startsWith(alias + "/")) {
-        resolvedPath = resolvedPath.replace(alias, target);
-        break;
-      }
-    }
-    resolvedPath = import_node_path.default.normalize(resolvedPath);
-    return fileList.find((file) => {
-      const normalizedFile = import_node_path.default.normalize(file);
-      const fileWithoutExt = normalizedFile.replace(/\.[^/.]+$/, "");
-      return normalizedFile === resolvedPath || fileWithoutExt === resolvedPath || normalizedFile === resolvedPath + ".ts" || normalizedFile === resolvedPath + ".js";
-    });
-  }
-  async moduleLinker(specifier, referencingModule) {
-    const dbFiles = import_node_fs.default.readdirSync(this._config.dir || resolve(process.cwd(), "databases")).filter((f) => f.endsWith(".ts")).map((f) => import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), f));
-    const dbResult = this.resolvePath(dbFiles, specifier);
-    if (dbResult) {
-      try {
-        const actualModule = await import(dbResult);
-        const exportNames = Object.keys(actualModule);
-        return new import_node_vm.default.SyntheticModule(
-          exportNames,
-          function() {
-            exportNames.forEach((key) => {
-              this.setExport(key, actualModule[key]);
-            });
-          },
-          { identifier: specifier, context: referencingModule.context }
-        );
-      } catch (err) {
-        console.error(`Failed to load database module ${specifier}:`, err);
-        throw err;
-      }
-    }
-    throw new Error(`Module ${specifier} is not allowed or not found.`);
-  }
-  async vmRun(code, _options) {
-    const logs = [];
-    const customConsole = ["log", "error", "warn", "info", "debug", "trace"].reduce((acc, type) => {
-      acc[type] = (...args) => logs.push({ type, args });
-      return acc;
-    }, {});
-    const systemBase = {
-      update,
-      remove,
-      rename: rename2,
-      read,
-      create,
-      save
-    };
-    this.register({
-      dbConsole: { ...customConsole, ...systemBase }
-    });
-    let stringCode;
-    if (typeof code === "function") {
-      const funcStr = code.toString();
-      if (funcStr.includes("=>")) {
-        const arrowIndex = funcStr.indexOf("=>");
-        let start = arrowIndex + 2;
-        while (start < funcStr.length && funcStr[start] === " ") start++;
-        if (funcStr[start] === "{") start++;
-        let end = funcStr.lastIndexOf("}");
-        if (start < end) {
-          stringCode = funcStr.substring(start, end);
-        } else {
-          stringCode = funcStr.substring(start);
-        }
-      } else if (funcStr.includes("function")) {
-        const funcIndex = funcStr.indexOf("function");
-        let start = funcIndex + 8;
-        while (start < funcStr.length && funcStr[start] === " ") start++;
-        if (funcStr[start] === "(") start++;
-        if (start < funcStr.length && funcStr[start] !== "(") {
-          while (start < funcStr.length && funcStr[start] !== " " && funcStr[start] !== "(") start++;
-        }
-        if (funcStr[start] === "(") start++;
-        while (start < funcStr.length && funcStr[start] === " ") start++;
-        if (funcStr[start] === "{") start++;
-        const end = funcStr.lastIndexOf("}");
-        if (start < end) {
-          stringCode = funcStr.substring(start, end);
-        } else {
-          stringCode = funcStr.substring(start);
-        }
-      } else {
-        stringCode = funcStr;
-      }
-      stringCode = stringCode.trim();
-      let importPos = 0;
-      while ((importPos = stringCode.indexOf("import(", importPos)) !== -1) {
-        const fromPos = stringCode.indexOf(".from(", importPos);
-        if (fromPos === -1) break;
-        const quoteStart = stringCode.indexOf("(", fromPos + 7) + 1;
-        if (quoteStart === -1) break;
-        const quoteChar = stringCode[quoteStart];
-        if (quoteChar !== '"' && quoteChar !== "'") break;
-        const quoteEnd = stringCode.indexOf(quoteChar, quoteStart + 1);
-        if (quoteEnd === -1) break;
-        const modulePath = stringCode.substring(quoteStart + 1, quoteEnd);
-        const importArgEnd = fromPos - 1;
-        const importArgStart = importPos + 7;
-        const trimmed = stringCode.substring(importArgStart, importArgEnd).trim();
-        let replacement;
-        if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
-          const inner = trimmed.slice(1, -1).trim();
-          replacement = `import { ${inner} } from "${modulePath}"`;
-        } else {
-          replacement = `import ${trimmed} from "${modulePath}"`;
-        }
-        const before = stringCode.substring(0, importPos);
-        const after = stringCode.substring(quoteEnd + 2);
-        stringCode = before + replacement + after;
-      }
-      const lines = stringCode.split("\n");
-      const trimmedLines = lines.map((line) => line.trim());
-      stringCode = trimmedLines.join("\n").trim();
-    } else {
-      stringCode = code;
-    }
-    const result = await esbuild.build({
-      stdin: {
-        contents: stringCode,
-        loader: this._config.language || "ts"
-      },
-      format: "esm",
-      target: "es2020",
-      write: false,
-      bundle: false,
-      sourcemap: false
-    });
-    const js = result.outputFiles[0].text;
-    const mod = new import_node_vm.default.SourceTextModule(js, { context: this._ctx, identifier: import_node_path.default.join(this._config.dir || resolve(process.cwd(), "databases"), "virtual-entry.js") });
-    await mod.link(this.moduleLinker.bind(this));
-    await mod.evaluate();
-    return {
-      namespace: mod.namespace,
-      logs
-    };
-  }
-  /**
-   * Execute database code and return results
-   */
-  async execute(code, options) {
-    return await this.vmRun(code, options);
-  }
-};
-function create(dbName, code) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const dbPath = import_node_path.default.join(baseDir, `${dbName}.ts`);
-  import_node_fs.default.appendFileSync(dbPath, code.toString(), "utf8");
-}
-function read(dbName) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const dbPath = import_node_path.default.join(baseDir, `${dbName}.ts`);
-  if (!import_node_fs.default.existsSync(dbPath)) {
-    throw new Error(`Database '${dbName}' not found`);
-  }
-  return import_node_fs.default.readFileSync(dbPath, "utf8");
-}
-function remove(dbName, fnName) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const dbPath = import_node_path.default.join(baseDir, `${dbName}.ts`);
-  if (!import_node_fs.default.existsSync(dbPath)) return false;
-  if (!fnName) {
-    const bak2 = `${dbPath}.bak`;
-    try {
-      import_node_fs.default.copyFileSync(dbPath, bak2);
-    } catch (e) {
-    }
-    try {
-      import_node_fs.default.unlinkSync(dbPath);
-      return "Removed successfully";
-    } catch (e) {
-      return "Removed failed";
-    }
-  }
-  const bak = `${dbPath}.bak`;
-  try {
-    import_node_fs.default.copyFileSync(dbPath, bak);
-  } catch (e) {
-  }
-  let src = import_node_fs.default.readFileSync(dbPath, "utf8");
-  const escaped = fnName.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-  const startRe = new RegExp(
-    `function\\s+${escaped}\\s*\\(|\\bclass\\s+${escaped}\\b|\\b(?:const|let|var)\\s+${escaped}\\s*=\\s*(?:function\\b|class\\b|\\(|\\{|\\[)`,
-    "m"
-  );
-  const startMatch = src.match(startRe);
-  if (startMatch) {
-    const startIdx = startMatch.index;
-    const len = src.length;
-    const idxCurly = src.indexOf("{", startIdx);
-    const idxBracket = src.indexOf("[", startIdx);
-    let braceOpen = -1;
-    if (idxCurly === -1) braceOpen = idxBracket;
-    else if (idxBracket === -1) braceOpen = idxCurly;
-    else braceOpen = Math.min(idxCurly, idxBracket);
-    if (braceOpen !== -1) {
-      const openingChar = src[braceOpen];
-      const closingChar = openingChar === "[" ? "]" : "}";
-      let i = braceOpen + 1;
-      let depth = 1;
-      while (i < len && depth > 0) {
-        const ch = src[i];
-        if (ch === openingChar) depth++;
-        else if (ch === closingChar) depth--;
-        i++;
-      }
-      let braceClose = i;
-      let endIdx = braceClose;
-      if (src.slice(braceClose, braceClose + 1) === ";")
-        endIdx = braceClose + 1;
-      const before = src.slice(0, startIdx);
-      const after = src.slice(endIdx);
-      src = before + after;
-    } else {
-      const semi = src.indexOf(";", startIdx);
-      let endIdx = semi !== -1 ? semi + 1 : src.indexOf("\n\n", startIdx);
-      if (endIdx === -1) endIdx = len;
-      src = src.slice(0, startIdx) + src.slice(endIdx);
-    }
-  }
-  const exportRe = new RegExp(
-    `export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`,
-    "g"
-  );
-  src = src.replace(exportRe, "");
-  src = src.replace(/\n{3,}/g, "\n\n");
-  import_node_fs.default.writeFileSync(dbPath, src, "utf8");
-  return `Removed ${fnName} from database ${dbName}.`;
-}
-function rename2(oldName, newName) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const oldPath = import_node_path.default.join(baseDir, `${oldName}.ts`);
-  const newPath = import_node_path.default.join(baseDir, `${newName}.ts`);
-  if (!import_node_fs.default.existsSync(oldPath)) {
-    return `Error: File '${oldName}.ts' does not exist in the database`;
-  }
-  if (import_node_fs.default.existsSync(newPath)) {
-    return `Error: File '${newName}.ts' already exists in the database`;
-  }
-  try {
-    import_node_fs.default.renameSync(oldPath, newPath);
-    return `Successfully renamed '${oldName}.ts' to '${newName}.ts'`;
-  } catch (error) {
-    return `Error renaming file: ${error instanceof Error ? error.message : String(error)}`;
-  }
-}
-function save(dbName, code) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const dbPath = import_node_path.default.join(baseDir, `${dbName}.ts`);
-  let fileContent = typeof code === "function" ? code.toString() : code;
-  import_node_fs.default.writeFileSync(dbPath, fileContent, "utf8");
-}
-function update(dbName, fnName, code) {
-  const DIR = "databases";
-  const basePath = process.cwd();
-  const baseDir = import_node_path.default.resolve(basePath, DIR);
-  const dbPath = import_node_path.default.join(baseDir, `${dbName}.ts`);
-  let src;
-  if (!import_node_fs.default.existsSync(dbPath)) {
-    try {
-      import_node_fs.default.writeFileSync(dbPath, "", "utf8");
-      return `Created new database file: ${dbPath}`;
-    } catch (e) {
-      return `Failed to create dbPath file: ${dbPath}`;
-    }
-  }
-  src = import_node_fs.default.readFileSync(dbPath, "utf8");
-  const originalSrc = src;
-  const escaped = fnName.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-  const startRe = new RegExp(
-    `function\\s+${escaped}\\s*\\(|\\bclass\\s+${escaped}\\b|\\b(?:const|let|var)\\s+${escaped}\\s*=\\s*(?:function\\b|class\\b|\\(|\\{|\\[)`,
-    "m"
-  );
-  const startMatch = src.match(startRe);
-  let declKind = null;
-  if (startMatch) {
-    let startIdx = startMatch.index;
-    const snippet = src.slice(startIdx, startIdx + 80);
-    if (/^function\b/.test(snippet)) declKind = "functionDecl";
-    else if (/^class\b/.test(snippet)) declKind = "classDecl";
-    else if (/^\b(?:const|let|var)\b/.test(snippet)) declKind = "varAssign";
-  }
-  let newCode;
-  if (typeof code === "function") {
-    const fnStr = code.toString();
-    if (declKind === "functionDecl") {
-      if (/^function\s+\w+/.test(fnStr)) newCode = fnStr;
-      else
-        newCode = `function ${fnName}${fnStr.replace(
-          /^function\s*\(/,
-          "("
-        )}`;
-    } else if (declKind === "classDecl") {
-      if (/^class\s+\w+/.test(fnStr)) newCode = fnStr;
-      else if (/^class\s*\{/.test(fnStr))
-        newCode = fnStr.replace(/^class\s*\{/, `class ${fnName} {`);
-      else newCode = `const ${fnName} = ${fnStr};`;
-    } else {
-      newCode = `const ${fnName} = ${fnStr};`;
-    }
-  } else {
-    newCode = `const ${fnName} = ${valueToCode(code, 0)};`;
-  }
-  if (startMatch) {
-    const startIdx = startMatch.index;
-    const idxCurly = src.indexOf("{", startIdx);
-    const idxBracket = src.indexOf("[", startIdx);
-    let braceOpen = -1;
-    if (idxCurly === -1) braceOpen = idxBracket;
-    else if (idxBracket === -1) braceOpen = idxCurly;
-    else braceOpen = Math.min(idxCurly, idxBracket);
-    if (braceOpen === -1) {
-      const exportRe = new RegExp(
-        `export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`,
-        "m"
-      );
-      if (exportRe.test(src)) {
-        src = src.replace(
-          exportRe,
-          `${newCode}
-
-export const ${fnName}: any = ${fnName};`
-        );
-      } else {
-        src = src + `
-
-${newCode}
-
-export const ${fnName}: any = ${fnName};`;
-      }
-    } else {
-      const openingChar = src[braceOpen];
-      const closingChar = openingChar === "[" ? "]" : "}";
-      let i = braceOpen + 1;
-      let depth = 1;
-      const len = src.length;
-      while (i < len && depth > 0) {
-        const ch = src[i];
-        if (ch === openingChar) depth++;
-        else if (ch === closingChar) depth--;
-        i++;
-      }
-      let braceClose = i;
-      let endIdx = braceClose;
-      if (src.slice(braceClose, braceClose + 1) === ";")
-        endIdx = braceClose + 1;
-      const before = src.slice(0, startIdx);
-      const after = src.slice(endIdx);
-      src = before + newCode + after;
-    }
-  } else {
-    const exportRe = new RegExp(
-      `export\\s+const\\s+${escaped}\\s*:\\s*any\\s*=\\s*${escaped}\\s*;?`,
-      "m"
-    );
-    if (exportRe.test(src)) {
-      src = src.replace(
-        exportRe,
-        `${newCode}
-
-export const ${fnName}: any = ${fnName};`
-      );
-    } else {
-      src = src + `
-
-${newCode}
-
-export const ${fnName}: any = ${fnName};`;
-    }
-  }
-  import_node_fs.default.writeFileSync(dbPath, src, "utf8");
-  if (src === originalSrc) {
-    return `Saved ${fnName} to database ${dbName}.`;
-  } else {
-    return `Updated ${dbName} with ${fnName}.`;
-  }
-}
-function valueToCode(val, depth = 0) {
-  const indentUnit = "    ";
-  const indent = indentUnit.repeat(depth);
-  const indentInner = indentUnit.repeat(depth + 1);
-  if (val === null) return "null";
-  const t = typeof val;
-  if (t === "string") return JSON.stringify(val);
-  if (t === "number" || t === "boolean") return String(val);
-  if (t === "function") return val.toString();
-  if (Array.isArray(val)) {
-    if (val.length === 0) return "[]";
-    const items = val.map((v) => valueToCode(v, depth + 1));
-    return "[\n" + items.map((it) => indentInner + it).join(",\n") + "\n" + indent + "]";
-  }
-  if (t === "object") {
-    const keys = Object.keys(val);
-    if (keys.length === 0) return "{}";
-    const entries = keys.map((k) => {
-      const keyPart = isIdentifier(k) ? k : JSON.stringify(k);
-      const v = valueToCode(val[k], depth + 1);
-      return indentInner + keyPart + ": " + v;
-    });
-    return "{\n" + entries.join(",\n") + "\n" + indent + "}";
-  }
-  return String(val);
-}
-function isIdentifier(key) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key);
-}
-var dbConsole = {
-  create,
-  read,
-  remove,
-  rename: rename2,
-  save,
-  update,
-  ...console
-};
-
 // src/server.ts
-var ServerDatabase = class {
-  constructor() {
-    this._db = null;
-  }
-  async initialize(config) {
-    this._db = new Database(config);
-  }
-  database() {
-    return this._db;
-  }
-};
-var serverDatabase = new ServerDatabase();
-var database = serverDatabase.database;
 var ServerRouter = class {
   constructor() {
     this.routes = [];
     this.middlewares = [];
     // Express-like .all() method - matches all HTTP methods
-    this.all = (path2, ...handlers) => this.addRoute("ALL", path2, handlers);
+    this.all = (path, ...handlers) => this.addRoute("ALL", path, handlers);
     // Support per-route middleware: accept middleware(s) before the final handler
-    this.get = (path2, ...handlers) => this.addRoute("GET", path2, handlers);
-    this.post = (path2, ...handlers) => this.addRoute("POST", path2, handlers);
-    this.put = (path2, ...handlers) => this.addRoute("PUT", path2, handlers);
-    this.delete = (path2, ...handlers) => this.addRoute("DELETE", path2, handlers);
-    this.patch = (path2, ...handlers) => this.addRoute("PATCH", path2, handlers);
-    this.options = (path2, ...handlers) => this.addRoute("OPTIONS", path2, handlers);
-    this.head = (path2, ...handlers) => this.addRoute("HEAD", path2, handlers);
+    this.get = (path, ...handlers) => this.addRoute("GET", path, handlers);
+    this.post = (path, ...handlers) => this.addRoute("POST", path, handlers);
+    this.put = (path, ...handlers) => this.addRoute("PUT", path, handlers);
+    this.delete = (path, ...handlers) => this.addRoute("DELETE", path, handlers);
+    this.patch = (path, ...handlers) => this.addRoute("PATCH", path, handlers);
+    this.options = (path, ...handlers) => this.addRoute("OPTIONS", path, handlers);
+    this.head = (path, ...handlers) => this.addRoute("HEAD", path, handlers);
   }
   // Accept both internal Middleware and Express-style `(req, res, next?)` functions
   // Also support path-based middleware like Express: use(path, middleware)
   use(...args) {
     if (typeof args[0] === "string") {
-      const path2 = args[0];
+      const path = args[0];
       const middlewares = args.slice(1);
-      return this.addRoute("ALL", path2, middlewares);
+      return this.addRoute("ALL", path, middlewares);
     }
     const mw = args[0];
     this.middlewares.push(this.toMiddleware(mw));
@@ -3203,8 +2733,8 @@ var ServerRouter = class {
       await next();
     };
   }
-  addRoute(method, path2, handlers) {
-    const { pattern, paramNames } = this.pathToRegex(path2);
+  addRoute(method, path, handlers) {
+    const { pattern, paramNames } = this.pathToRegex(path);
     if (!handlers || handlers.length === 0) throw new Error("Route must include a handler");
     const rawMiddlewares = handlers.slice(0, handlers.length - 1);
     const rawLast = handlers[handlers.length - 1];
@@ -3233,9 +2763,9 @@ var ServerRouter = class {
     this.routes.push({ method, pattern, paramNames, handler: last, middlewares });
     return this;
   }
-  pathToRegex(path2) {
+  pathToRegex(path) {
     const paramNames = [];
-    const pattern = path2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/").replace(/:(\w+)/g, (_, name) => (paramNames.push(name), "([^\\/]+)"));
+    const pattern = path.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\//g, "\\/").replace(/:(\w+)/g, (_, name) => (paramNames.push(name), "([^\\/]+)"));
     return { pattern: new RegExp(`^${pattern}$`), paramNames };
   }
   parseQuery(url) {
@@ -3293,11 +2823,11 @@ var ServerRouter = class {
     });
   }
   async handle(req, res) {
-    const method = req.method, url = req.url || "/", path2 = url.split("?")[0];
+    const method = req.method, url = req.url || "/", path = url.split("?")[0];
     for (const route of this.routes) {
       if (route.method !== "ALL" && route.method !== method) continue;
-      if (!route.pattern.test(path2)) continue;
-      const match = path2.match(route.pattern);
+      if (!route.pattern.test(path)) continue;
+      const match = path.match(route.pattern);
       const params = Object.fromEntries(route.paramNames.map((name, i2) => [name, match[i2 + 1]]));
       let body = {};
       if (["POST", "PUT", "PATCH"].includes(method)) {
@@ -3732,21 +3262,21 @@ function security() {
     await next();
   };
 }
-function rewritePath(path2, pathRewrite) {
-  if (!pathRewrite) return path2;
+function rewritePath(path, pathRewrite) {
+  if (!pathRewrite) return path;
   for (const [from, to] of Object.entries(pathRewrite)) {
     const regex = new RegExp(from);
-    if (regex.test(path2)) {
-      return path2.replace(regex, to);
+    if (regex.test(path)) {
+      return path.replace(regex, to);
     }
   }
-  return path2;
+  return path;
 }
 function createProxyHandler(proxyConfigs) {
   return async (req, res) => {
     const url = req.url || "/";
-    const path2 = url.split("?")[0];
-    const proxy = proxyConfigs.find((p) => path2.startsWith(p.context));
+    const path = url.split("?")[0];
+    const proxy = proxyConfigs.find((p) => path.startsWith(p.context));
     if (!proxy) return false;
     const { target, changeOrigin, pathRewrite, headers } = proxy;
     try {
@@ -3798,7 +3328,7 @@ function createProxyHandler(proxyConfigs) {
       req.on("end", () => proxyReq.end());
       return true;
     } catch (error) {
-      console.error("[Proxy] Invalid proxy configuration for %s:", path2, error);
+      console.error("[Proxy] Invalid proxy configuration for %s:", path, error);
       return false;
     }
   };
@@ -3919,9 +3449,6 @@ function createDevServer(options) {
   if (config.mode === "dev") {
     clearImportMapCache();
   }
-  serverDatabase.initialize(config.database ? config.database : {
-    dir: resolve(process.cwd(), "databases")
-  });
   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) => {
@@ -4213,8 +3740,8 @@ export default css;
             });
             transpiled = transpiler.transformSync(content.toString());
           } else {
-            const { build: build2 } = await import("esbuild");
-            const result = await build2({
+            const { build } = await import("esbuild");
+            const result = await build({
               stdin: {
                 contents: content.toString(),
                 loader: ext === ".tsx" ? "tsx" : "ts",
@@ -4231,19 +3758,19 @@ export default css;
           }
           transpiled = transpiled.replace(
             /from\s+["']([^"']+)\.ts(x?)["']/g,
-            (_, path2, tsx) => `from "${path2}.js${tsx}"`
+            (_, path, tsx) => `from "${path}.js${tsx}"`
           );
           transpiled = transpiled.replace(
             /import\s+["']([^"']+)\.ts(x?)["']/g,
-            (_, path2, tsx) => `import "${path2}.js${tsx}"`
+            (_, path, tsx) => `import "${path}.js${tsx}"`
           );
           transpiled = transpiled.replace(
             /import\s+["']([^"']+\.css)["']/g,
-            (_, path2) => `import "${path2}?inline"`
+            (_, path) => `import "${path}?inline"`
           );
           transpiled = transpiled.replace(
             /from\s+["']([^"']+\.css)["']/g,
-            (_, path2) => `from "${path2}?inline"`
+            (_, path) => `from "${path}?inline"`
           );
           content = Buffer.from(transpiled);
           mimeType = "application/javascript";
@@ -4405,17 +3932,17 @@ ${elitImportMap}` : elitImportMap;
     (client) => config.watch.map((pattern) => join(client.root, pattern))
   );
   const watcher = watch(watchPaths, {
-    ignored: (path2) => config.ignore.some((pattern) => path2.includes(pattern.replace("/**", "").replace("**/", ""))),
+    ignored: (path) => config.ignore.some((pattern) => path.includes(pattern.replace("/**", "").replace("**/", ""))),
     ignoreInitial: true,
     persistent: true
   });
-  watcher.on("change", (path2) => {
-    if (config.logging) console.log(`[HMR] File changed: ${path2}`);
-    const message = JSON.stringify({ type: "update", path: path2, timestamp: Date.now() });
+  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 === 1 /* OPEN */ && client.send(message));
   });
-  watcher.on("add", (path2) => config.logging && console.log(`[HMR] File added: ${path2}`));
-  watcher.on("unlink", (path2) => config.logging && console.log(`[HMR] File removed: ${path2}`));
+  watcher.on("add", (path) => config.logging && console.log(`[HMR] File added: ${path}`));
+  watcher.on("unlink", (path) => config.logging && console.log(`[HMR] File removed: ${path}`));
   server.setMaxListeners(20);
   server.listen(config.port, config.host, () => {
     if (config.logging) {
@@ -4488,14 +4015,12 @@ ${elitImportMap}` : elitImportMap;
   cors,
   createDevServer,
   createProxyHandler,
-  database,
   errorHandler,
   html,
   json,
   logger,
   rateLimit,
   security,
-  serverDatabase,
   status,
   text
 });