speexjs 0.3.0 → 0.5.0

package/dist/server/index.js

@@ -10,6 +10,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -30,1697 +33,1868 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS({
-  "node_modules/better-sqlite3/lib/util.js"(exports) {
+// src/server/http/status.ts
+var HttpStatus;
+var init_status = __esm({
+  "src/server/http/status.ts"() {
     "use strict";
-    exports.getBooleanOption = (options, key) => {
-      let value = false;
-      if (key in options && typeof (value = options[key]) !== "boolean") {
-        throw new TypeError(`Expected the "${key}" option to be a boolean`);
-      }
-      return value;
+    HttpStatus = {
+      OK: 200,
+      CREATED: 201,
+      ACCEPTED: 202,
+      NO_CONTENT: 204,
+      RESET_CONTENT: 205,
+      PARTIAL_CONTENT: 206,
+      MOVED_PERMANENTLY: 301,
+      FOUND: 302,
+      SEE_OTHER: 303,
+      NOT_MODIFIED: 304,
+      TEMPORARY_REDIRECT: 307,
+      PERMANENT_REDIRECT: 308,
+      BAD_REQUEST: 400,
+      UNAUTHORIZED: 401,
+      PAYMENT_REQUIRED: 402,
+      FORBIDDEN: 403,
+      NOT_FOUND: 404,
+      METHOD_NOT_ALLOWED: 405,
+      NOT_ACCEPTABLE: 406,
+      REQUEST_TIMEOUT: 408,
+      CONFLICT: 409,
+      GONE: 410,
+      LENGTH_REQUIRED: 411,
+      PRECONDITION_FAILED: 412,
+      PAYLOAD_TOO_LARGE: 413,
+      URI_TOO_LONG: 414,
+      UNSUPPORTED_MEDIA_TYPE: 415,
+      UNPROCESSABLE_ENTITY: 422,
+      TOO_MANY_REQUESTS: 429,
+      INTERNAL_SERVER_ERROR: 500,
+      NOT_IMPLEMENTED: 501,
+      BAD_GATEWAY: 502,
+      SERVICE_UNAVAILABLE: 503,
+      GATEWAY_TIMEOUT: 504,
+      HTTP_VERSION_NOT_SUPPORTED: 505
     };
-    exports.cppdb = /* @__PURE__ */ Symbol();
-    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
-  }
-});
-
-// node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS({
-  "node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
-    "use strict";
-    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-    function SqliteError(message, code) {
-      if (new.target !== SqliteError) {
-        return new SqliteError(message, code);
-      }
-      if (typeof code !== "string") {
-        throw new TypeError("Expected second argument to be a string");
-      }
-      Error.call(this, message);
-      descriptor.value = "" + message;
-      Object.defineProperty(this, "message", descriptor);
-      Error.captureStackTrace(this, SqliteError);
-      this.code = code;
-    }
-    Object.setPrototypeOf(SqliteError, Error);
-    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-    Object.defineProperty(SqliteError.prototype, "name", descriptor);
-    module.exports = SqliteError;
   }
 });
 
-// node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS({
-  "node_modules/file-uri-to-path/index.js"(exports, module) {
+// src/server/http/headers.ts
+var HeadersMap;
+var init_headers = __esm({
+  "src/server/http/headers.ts"() {
     "use strict";
-    var sep = __require("path").sep || "/";
-    module.exports = fileUriToPath;
-    function fileUriToPath(uri) {
-      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
-        throw new TypeError("must pass in a file:// URI to convert to a file path");
-      }
-      var rest = decodeURI(uri.substring(7));
-      var firstSlash = rest.indexOf("/");
-      var host = rest.substring(0, firstSlash);
-      var path3 = rest.substring(firstSlash + 1);
-      if ("localhost" == host) host = "";
-      if (host) {
-        host = sep + sep + host;
+    HeadersMap = class {
+      data;
+      constructor(initial) {
+        this.data = /* @__PURE__ */ new Map();
+        if (initial) {
+          for (const key of Object.keys(initial)) {
+            const value = initial[key];
+            if (value !== void 0) {
+              this.set(key, Array.isArray(value) ? value.join(", ") : value);
+            }
+          }
+        }
       }
-      path3 = path3.replace(/^(.+)\|/, "$1:");
-      if (sep == "\\") {
-        path3 = path3.replace(/\//g, "\\");
+      get(name) {
+        const values = this.data.get(name.toLowerCase());
+        if (values !== void 0 && values.length > 0) {
+          return values[0];
+        }
+        return void 0;
       }
-      if (/^.+\:/.test(path3)) {
-      } else {
-        path3 = sep + path3;
+      getAll(name) {
+        const values = this.data.get(name.toLowerCase());
+        return values ?? [];
       }
-      return host + path3;
-    }
-  }
-});
-
-// node_modules/bindings/bindings.js
-var require_bindings = __commonJS({
-  "node_modules/bindings/bindings.js"(exports, module) {
-    "use strict";
-    var fs3 = __require("fs");
-    var path3 = __require("path");
-    var fileURLToPath = require_file_uri_to_path();
-    var join5 = path3.join;
-    var dirname4 = path3.dirname;
-    var exists = fs3.accessSync && function(path4) {
-      try {
-        fs3.accessSync(path4);
-      } catch (e) {
-        return false;
+      set(name, value) {
+        this.data.set(name.toLowerCase(), [value]);
       }
-      return true;
-    } || fs3.existsSync || path3.existsSync;
-    var defaults = {
-      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
-      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
-      platform: process.platform,
-      arch: process.arch,
-      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
-      version: process.versions.node,
-      bindings: "bindings.node",
-      try: [
-        // node-gyp's linked version in the "build" dir
-        ["module_root", "build", "bindings"],
-        // node-waf and gyp_addon (a.k.a node-gyp)
-        ["module_root", "build", "Debug", "bindings"],
-        ["module_root", "build", "Release", "bindings"],
-        // Debug files, for development (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Debug", "bindings"],
-        ["module_root", "Debug", "bindings"],
-        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Release", "bindings"],
-        ["module_root", "Release", "bindings"],
-        // Legacy from node-waf, node <= 0.4.x
-        ["module_root", "build", "default", "bindings"],
-        // Production "Release" buildtype binary (meh...)
-        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-        // node-qbs builds
-        ["module_root", "addon-build", "release", "install-root", "bindings"],
-        ["module_root", "addon-build", "debug", "install-root", "bindings"],
-        ["module_root", "addon-build", "default", "install-root", "bindings"],
-        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
-      ]
-    };
-    function bindings(opts) {
-      if (typeof opts == "string") {
-        opts = { bindings: opts };
-      } else if (!opts) {
-        opts = {};
+      append(name, value) {
+        const key = name.toLowerCase();
+        const existing = this.data.get(key);
+        if (existing !== void 0) {
+          existing.push(value);
+        } else {
+          this.data.set(key, [value]);
+        }
       }
-      Object.keys(defaults).map(function(i2) {
-        if (!(i2 in opts)) opts[i2] = defaults[i2];
-      });
-      if (!opts.module_root) {
-        opts.module_root = exports.getRoot(exports.getFileName());
+      has(name) {
+        return this.data.has(name.toLowerCase());
       }
-      if (path3.extname(opts.bindings) != ".node") {
-        opts.bindings += ".node";
+      delete(name) {
+        this.data.delete(name.toLowerCase());
       }
-      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
-      var tries = [], i = 0, l = opts.try.length, n, b, err;
-      for (; i < l; i++) {
-        n = join5.apply(
-          null,
-          opts.try[i].map(function(p) {
-            return opts[p] || p;
-          })
-        );
-        tries.push(n);
-        try {
-          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-          if (!opts.path) {
-            b.path = n;
-          }
-          return b;
-        } catch (e) {
-          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
-            throw e;
+      *entries() {
+        for (const [key, values] of this.data) {
+          for (const value of values) {
+            yield [key, value];
           }
         }
       }
-      err = new Error(
-        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
-          return opts.arrow + a;
-        }).join("\n")
-      );
-      err.tries = tries;
-      throw err;
-    }
-    module.exports = exports = bindings;
-    exports.getFileName = function getFileName(calling_file) {
-      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
-      Error.stackTraceLimit = 10;
-      Error.prepareStackTrace = function(e, st) {
-        for (var i = 0, l = st.length; i < l; i++) {
-          fileName = st[i].getFileName();
-          if (fileName !== __filename) {
-            if (calling_file) {
-              if (fileName !== calling_file) {
-                return;
-              }
-            } else {
-              return;
-            }
-          }
+      *keys() {
+        for (const key of this.data.keys()) {
+          yield key;
         }
-      };
-      Error.captureStackTrace(dummy);
-      dummy.stack;
-      Error.prepareStackTrace = origPST;
-      Error.stackTraceLimit = origSTL;
-      var fileSchema = "file://";
-      if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath(fileName);
       }
-      return fileName;
-    };
-    exports.getRoot = function getRoot(file) {
-      var dir = dirname4(file), prev;
-      while (true) {
-        if (dir === ".") {
-          dir = process.cwd();
+      *values() {
+        for (const [, values] of this.data) {
+          for (const value of values) {
+            yield value;
+          }
         }
-        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
-          return dir;
+      }
+      toJSON() {
+        const result = {};
+        for (const [key, values] of this.data) {
+          result[key] = values.length === 1 ? values[0] : values;
         }
-        if (prev === dir) {
-          throw new Error(
-            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
-          );
+        return result;
+      }
+      toNodeHeaders() {
+        const result = {};
+        for (const [key, values] of this.data) {
+          if (key === "set-cookie") {
+            result[key] = values;
+          } else {
+            result[key] = values.join(", ");
+          }
         }
-        prev = dir;
-        dir = join5(dir, "..");
+        return result;
+      }
+      get size() {
+        return this.data.size;
+      }
+      [Symbol.iterator]() {
+        return this.entries();
       }
     };
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
-    "use strict";
-    var { cppdb } = require_util();
-    exports.prepare = function prepare(sql) {
-      return this[cppdb].prepare(sql, this, false);
-    };
-    exports.exec = function exec(sql) {
-      this[cppdb].exec(sql);
-      return this;
-    };
-    exports.close = function close() {
-      this[cppdb].close();
-      return this;
-    };
-    exports.loadExtension = function loadExtension(...args) {
-      this[cppdb].loadExtension(...args);
-      return this;
-    };
-    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-      this[cppdb].defaultSafeIntegers(...args);
-      return this;
-    };
-    exports.unsafeMode = function unsafeMode(...args) {
-      this[cppdb].unsafeMode(...args);
-      return this;
-    };
-    exports.getters = {
-      name: {
-        get: function name() {
-          return this[cppdb].name;
-        },
-        enumerable: true
-      },
-      open: {
-        get: function open() {
-          return this[cppdb].open;
-        },
-        enumerable: true
-      },
-      inTransaction: {
-        get: function inTransaction() {
-          return this[cppdb].inTransaction;
-        },
-        enumerable: true
-      },
-      readonly: {
-        get: function readonly() {
-          return this[cppdb].readonly;
-        },
-        enumerable: true
-      },
-      memory: {
-        get: function memory() {
-          return this[cppdb].memory;
-        },
-        enumerable: true
-      }
-    };
+// src/server/http/cookie.ts
+function parseCookies(header) {
+  const result = {};
+  if (!header) return result;
+  const pairs = header.split(";");
+  for (const pair of pairs) {
+    const trimmed = pair.trim();
+    if (!trimmed) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) {
+      result[trimmed] = "";
+      continue;
+    }
+    const name = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1);
+    }
+    if (name) {
+      result[decodeURIComponent(name)] = decodeURIComponent(value);
+    }
+  }
+  return result;
+}
+function serializeCookieValue(name, value) {
+  return `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+}
+function serializeCookie(name, value, options) {
+  const parts = [serializeCookieValue(name, value)];
+  if (options) {
+    if (options.maxAge !== void 0) {
+      parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
+    }
+    if (options.expires !== void 0) {
+      parts.push(`Expires=${options.expires.toUTCString()}`);
+    }
+    if (options.path !== void 0) {
+      parts.push(`Path=${options.path}`);
+    } else {
+      parts.push("Path=/");
+    }
+    if (options.domain !== void 0) {
+      parts.push(`Domain=${options.domain}`);
+    }
+    if (options.secure) {
+      parts.push("Secure");
+    }
+    if (options.httpOnly) {
+      parts.push("HttpOnly");
+    }
+    if (options.sameSite !== void 0) {
+      parts.push(`SameSite=${options.sameSite}`);
+    }
+  }
+  return parts.join("; ");
+}
+function clearCookie(name, options) {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: /* @__PURE__ */ new Date(0)
+  });
+}
+var init_cookie = __esm({
+  "src/server/http/cookie.ts"() {
+    "use strict";
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+// src/server/http/upload.ts
+import { randomUUID } from "crypto";
+import { writeFile, readFile, unlink, mkdir } from "fs/promises";
+import { join, extname, basename, dirname } from "path";
+import { tmpdir } from "os";
+var IMAGE_MIME_TYPES, VIDEO_MIME_TYPES, SuperUploadedFile;
+var init_upload = __esm({
+  "src/server/http/upload.ts"() {
     "use strict";
-    var { cppdb } = require_util();
-    var controllers = /* @__PURE__ */ new WeakMap();
-    module.exports = function transaction(fn) {
-      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
-      const db = this[cppdb];
-      const controller = getController(db, this);
-      const { apply } = Function.prototype;
-      const properties = {
-        default: { value: wrapTransaction(apply, fn, db, controller.default) },
-        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
-        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
-        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
-        database: { value: this, enumerable: true }
-      };
-      Object.defineProperties(properties.default.value, properties);
-      Object.defineProperties(properties.deferred.value, properties);
-      Object.defineProperties(properties.immediate.value, properties);
-      Object.defineProperties(properties.exclusive.value, properties);
-      return properties.default.value;
-    };
-    var getController = (db, self) => {
-      let controller = controllers.get(db);
-      if (!controller) {
-        const shared = {
-          commit: db.prepare("COMMIT", self, false),
-          rollback: db.prepare("ROLLBACK", self, false),
-          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
-          release: db.prepare("RELEASE `	_bs3.	`", self, false),
-          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
-        };
-        controllers.set(db, controller = {
-          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
-          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
-          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
-          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
-        });
+    IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
+      "image/jpeg",
+      "image/png",
+      "image/gif",
+      "image/webp",
+      "image/svg+xml",
+      "image/bmp",
+      "image/tiff",
+      "image/avif"
+    ]);
+    VIDEO_MIME_TYPES = /* @__PURE__ */ new Set([
+      "video/mp4",
+      "video/mpeg",
+      "video/webm",
+      "video/ogg",
+      "video/quicktime",
+      "video/x-msvideo",
+      "video/x-matroska"
+    ]);
+    SuperUploadedFile = class _SuperUploadedFile {
+      fieldName;
+      originalName;
+      mimeType;
+      size;
+      path;
+      extension;
+      buffer;
+      constructor(opts) {
+        this.fieldName = opts.fieldName;
+        this.originalName = opts.originalName;
+        this.mimeType = opts.mimeType;
+        this.size = opts.size;
+        this.path = opts.path;
+        this.extension = extname(opts.originalName).toLowerCase();
+        this.buffer = opts.buffer ?? null;
       }
-      return controller;
-    };
-    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-      let before, after, undo;
-      if (db.inTransaction) {
-        before = savepoint;
-        after = release;
-        undo = rollbackTo;
-      } else {
-        before = begin;
-        after = commit;
-        undo = rollback;
+      async move(destination, filename) {
+        const destName = filename ?? basename(this.path);
+        const destPath = join(destination, destName);
+        await mkdir(dirname(destPath), { recursive: true });
+        const buf = await this.toBuffer();
+        await writeFile(destPath, buf);
+        return destPath;
       }
-      before.run();
-      try {
-        const result = apply.call(fn, this, arguments);
-        if (result && typeof result.then === "function") {
-          throw new TypeError("Transaction function cannot return a promise");
+      async toBuffer() {
+        if (this.buffer !== null) return this.buffer;
+        this.buffer = await readFile(this.path);
+        return this.buffer;
+      }
+      toBase64() {
+        if (this.buffer === null) {
+          throw new Error(
+            "Buffer not loaded. Call toBuffer() first or read the file into memory."
+          );
         }
-        after.run();
-        return result;
-      } catch (ex) {
-        if (db.inTransaction) {
-          undo.run();
-          if (undo !== rollback) after.run();
+        return this.buffer.toString("base64");
+      }
+      isImage() {
+        return IMAGE_MIME_TYPES.has(this.mimeType);
+      }
+      isVideo() {
+        return VIDEO_MIME_TYPES.has(this.mimeType);
+      }
+      static async createFromBuffer(fieldName, originalName, mimeType, buffer, tempDir) {
+        const tmp = tempDir ?? tmpdir();
+        const fileName = `${randomUUID()}${extname(originalName)}`;
+        const filePath = join(tmp, fileName);
+        await writeFile(filePath, buffer);
+        return new _SuperUploadedFile({
+          fieldName,
+          originalName,
+          mimeType: mimeType || "application/octet-stream",
+          size: buffer.length,
+          path: filePath,
+          buffer
+        });
+      }
+      async cleanup() {
+        try {
+          await unlink(this.path);
+        } catch {
         }
-        throw ex;
       }
     };
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module.exports = function pragma(source, options) {
-      if (options == null) options = {};
-      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      const simple = getBooleanOption(options, "simple");
-      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
-      return simple ? stmt.pluck().get() : stmt.all();
-    };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
-    "use strict";
-    var fs3 = __require("fs");
-    var path3 = __require("path");
-    var { promisify: promisify2 } = __require("util");
-    var { cppdb } = require_util();
-    var fsAccess = promisify2(fs3.access);
-    module.exports = async function backup(filename, options) {
-      if (options == null) options = {};
-      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      filename = filename.trim();
-      const attachedName = "attached" in options ? options.attached : "main";
-      const handler = "progress" in options ? options.progress : null;
-      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
-      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
-      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path3.dirname(filename)).catch(() => {
-        throw new TypeError("Cannot save backup because the directory does not exist");
-      });
-      const isNewFile = await fsAccess(filename).then(() => false, () => true);
-      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
-    };
-    var runBackup = (backup, handler) => {
-      let rate = 0;
-      let useDefault = true;
-      return new Promise((resolve4, reject) => {
-        setImmediate(function step() {
-          try {
-            const progress = backup.transfer(rate);
-            if (!progress.remainingPages) {
-              backup.close();
-              resolve4(progress);
-              return;
-            }
-            if (useDefault) {
-              useDefault = false;
-              rate = 100;
-            }
-            if (handler) {
-              const ret = handler(progress);
-              if (ret !== void 0) {
-                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
-                else throw new TypeError("Expected progress callback to return a number or undefined");
-              }
-            }
-            setImmediate(step);
-          } catch (err) {
-            backup.close();
-            reject(err);
-          }
-        });
-      });
-    };
+// src/server/http/request.ts
+function parseQueryParams(searchParams) {
+  const result = {};
+  for (const key of searchParams.keys()) {
+    const values = searchParams.getAll(key);
+    result[key] = values.length === 1 ? values[0] : values;
   }
-});
-
-// node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
-    "use strict";
-    var { cppdb } = require_util();
-    module.exports = function serialize(options) {
-      if (options == null) options = {};
-      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
-      const attachedName = "attached" in options ? options.attached : "main";
-      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-      return this[cppdb].serialize(attachedName);
-    };
+  return result;
+}
+function parseIp(req) {
+  const forwarded = req.headers["x-forwarded-for"];
+  if (forwarded !== void 0) {
+    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0];
+    if (first !== void 0) return first.trim();
   }
-});
-
-// node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+  const realIp = req.headers["x-real-ip"];
+  if (realIp !== void 0) {
+    return Array.isArray(realIp) ? realIp[0] : realIp;
+  }
+  const remote = req.socket.remoteAddress;
+  if (remote !== void 0) {
+    if (remote.startsWith("::ffff:")) return remote.slice(7);
+    return remote;
+  }
+  return "127.0.0.1";
+}
+function parseUrlEncoded(text) {
+  const result = {};
+  const pairs = text.split("&");
+  for (const pair of pairs) {
+    if (!pair) continue;
+    const eqIndex = pair.indexOf("=");
+    if (eqIndex === -1) {
+      result[decodeURIComponent(pair)] = "";
+    } else {
+      const key = decodeURIComponent(pair.slice(0, eqIndex));
+      const value = decodeURIComponent(pair.slice(eqIndex + 1));
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function parseMultipartBody(body, boundary) {
+  const result = [];
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  let start = 0;
+  let searchFrom = 0;
+  while (true) {
+    const boundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (boundaryIndex === -1) break;
+    searchFrom = boundaryIndex + boundaryBuffer.length;
+    if (searchFrom < body.length && body[searchFrom] === 45 && body[searchFrom + 1] === 45) {
+      break;
+    }
+    if (searchFrom >= body.length) break;
+    if (body[searchFrom] === 13) searchFrom++;
+    if (body[searchFrom] === 10) searchFrom++;
+    start = searchFrom;
+    const nextBoundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
+    if (nextBoundaryIndex === -1) break;
+    let partEnd = nextBoundaryIndex;
+    if (partEnd >= 2 && body[partEnd - 2] === 13 && body[partEnd - 1] === 10) {
+      partEnd -= 2;
+    }
+    const partData = body.slice(start, partEnd);
+    const headerEndIndex = partData.indexOf(Buffer.from("\r\n\r\n"));
+    if (headerEndIndex === -1) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    const headerSection = partData.slice(0, headerEndIndex).toString("utf-8");
+    const contentData = partData.slice(headerEndIndex + 4);
+    const disposition = parseDisposition(headerSection);
+    if (disposition === void 0) {
+      searchFrom = nextBoundaryIndex;
+      continue;
+    }
+    if (disposition.filename !== void 0) {
+      const contentType = parseContentType(headerSection);
+      result.push({
+        type: "file",
+        name: disposition.name,
+        filename: disposition.filename,
+        mimeType: contentType,
+        data: Buffer.from(contentData)
+      });
+    } else {
+      result.push({
+        type: "field",
+        name: disposition.name,
+        value: contentData.toString("utf-8").trim()
+      });
+    }
+    searchFrom = nextBoundaryIndex;
+  }
+  return result;
+}
+function parseDisposition(headerSection) {
+  const match = headerSection.match(
+    /content-disposition:\s*form-data;\s*(.+)/i
+  );
+  if (match === null) return void 0;
+  const params = match[1];
+  const nameMatch = params.match(/name="([^"]*)"/i);
+  const filenameMatch = params.match(/filename="([^"]*)"/i);
+  if (nameMatch === null) return void 0;
+  return {
+    name: nameMatch[1],
+    filename: filenameMatch?.[1]
+  };
+}
+function parseContentType(headerSection) {
+  const match = headerSection.match(/content-type:\s*([^\s;]+)/i);
+  return match?.[1] ?? "application/octet-stream";
+}
+var SuperRequest, ValidationError;
+var init_request = __esm({
+  "src/server/http/request.ts"() {
     "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module.exports = function defineFunction(name, options, fn) {
-      if (options == null) options = {};
-      if (typeof options === "function") {
-        fn = options;
-        options = {};
+    init_headers();
+    init_cookie();
+    init_upload();
+    SuperRequest = class {
+      raw;
+      _headers;
+      _query;
+      _cookies = null;
+      _ip;
+      _params = {};
+      bodyCache = null;
+      _bodyReadPromise = null;
+      constructor(raw) {
+        this.raw = raw;
+        this._headers = new HeadersMap(
+          raw.headers
+        );
+        const parsedUrl = new URL(raw.url ?? "/", "http://localhost");
+        this._query = parseQueryParams(parsedUrl.searchParams);
+        this._ip = parseIp(raw);
+        this.path = parsedUrl.pathname;
+        this.url = raw.url ?? "/";
+        this.method = (raw.method ?? "GET").toUpperCase();
       }
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-      const deterministic = getBooleanOption(options, "deterministic");
-      const directOnly = getBooleanOption(options, "directOnly");
-      const varargs = getBooleanOption(options, "varargs");
-      let argCount = -1;
-      if (!varargs) {
-        argCount = fn.length;
-        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
-        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      method;
+      url;
+      path;
+      get headers() {
+        return this._headers;
       }
-      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
-      return this;
-    };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module.exports = function defineAggregate(name, options) {
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
-      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-      const start = "start" in options ? options.start : null;
-      const step = getFunctionOption(options, "step", true);
-      const inverse = getFunctionOption(options, "inverse", false);
-      const result = getFunctionOption(options, "result", false);
-      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-      const deterministic = getBooleanOption(options, "deterministic");
-      const directOnly = getBooleanOption(options, "directOnly");
-      const varargs = getBooleanOption(options, "varargs");
-      let argCount = -1;
-      if (!varargs) {
-        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
-        if (argCount > 0) argCount -= 1;
-        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      get query() {
+        return this._query;
       }
-      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
-      return this;
-    };
-    var getFunctionOption = (options, key, required) => {
-      const value = key in options ? options[key] : null;
-      if (typeof value === "function") return value;
-      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
-      if (required) throw new TypeError(`Missing required option "${key}"`);
-      return null;
-    };
-    var getLength = ({ length }) => {
-      if (Number.isInteger(length) && length >= 0) return length;
-      throw new TypeError("Expected function.length to be a positive integer");
-    };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
-    "use strict";
-    var { cppdb } = require_util();
-    module.exports = function defineTable(name, factory) {
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
-      let eponymous = false;
-      if (typeof factory === "object" && factory !== null) {
-        eponymous = true;
-        factory = defer(parseTableDefinition(factory, "used", name));
-      } else {
-        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
-        factory = wrapFactory(factory);
+      get params() {
+        return this._params;
       }
-      this[cppdb].table(factory, name, eponymous);
-      return this;
-    };
-    function wrapFactory(factory) {
-      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
-        const thisObject = {
-          module: moduleName,
-          database: databaseName,
-          table: tableName
-        };
-        const def = apply.call(factory, thisObject, args);
-        if (typeof def !== "object" || def === null) {
-          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+      set params(value) {
+        this._params = value;
+      }
+      get ip() {
+        return this._ip;
+      }
+      async ensureBody() {
+        if (this.bodyCache !== null) return this.bodyCache;
+        if (this._bodyReadPromise === null) {
+          this._bodyReadPromise = this.readBodyFromStream();
         }
-        return parseTableDefinition(def, "returned", moduleName);
-      };
-    }
-    function parseTableDefinition(def, verb, moduleName) {
-      if (!hasOwnProperty.call(def, "rows")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+        this.bodyCache = await this._bodyReadPromise;
+        return this.bodyCache;
       }
-      if (!hasOwnProperty.call(def, "columns")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      async readBodyFromStream() {
+        const chunks = [];
+        const MAX_BODY_SIZE = 10 * 1024 * 1024;
+        let totalSize = 0;
+        for await (const chunk of this.raw) {
+          const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+          totalSize += buf.length;
+          if (totalSize > MAX_BODY_SIZE) {
+            throw new Error("Request body too large. Maximum size is 10MB.");
+          }
+          chunks.push(buf);
+        }
+        const raw = Buffer.concat(chunks);
+        const text = raw.toString("utf-8");
+        let json = void 0;
+        if (this.isContentType("application/json")) {
+          try {
+            json = JSON.parse(text);
+          } catch {
+            json = void 0;
+          }
+        }
+        let formData = null;
+        let multipartParsed = null;
+        let files = null;
+        if (this.isContentType("application/x-www-form-urlencoded")) {
+          formData = parseUrlEncoded(text);
+        } else if (this.isContentType("multipart/form-data")) {
+          const boundary = this.getMultipartBoundary();
+          if (boundary !== void 0) {
+            multipartParsed = parseMultipartBody(raw, boundary);
+            formData = {};
+            files = {};
+            for (const part of multipartParsed) {
+              if (part.type === "field") {
+                formData[part.name] = part.value;
+              } else if (part.type === "file") {
+                const uploadedFile = await SuperUploadedFile.createFromBuffer(
+                  part.name,
+                  part.filename,
+                  part.mimeType,
+                  part.data
+                );
+                files[part.name] = uploadedFile;
+              }
+            }
+          }
+        }
+        return {
+          raw,
+          text,
+          json,
+          parsed: json ?? text,
+          formData,
+          files,
+          multipartParsed
+        };
       }
-      const rows = def.rows;
-      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      isContentType(expected) {
+        const ct = this._headers.get("content-type");
+        if (ct === void 0) return false;
+        return ct.toLowerCase().startsWith(expected);
       }
-      let columns = def.columns;
-      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      getMultipartBoundary() {
+        const ct = this._headers.get("content-type");
+        if (ct === void 0) return void 0;
+        const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+        if (match !== null) {
+          return match[1] ?? match[2];
+        }
+        return void 0;
       }
-      if (columns.length !== new Set(columns).size) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      async body() {
+        const cache = await this.ensureBody();
+        return cache.parsed;
       }
-      if (!columns.length) {
-        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      async json() {
+        const cache = await this.ensureBody();
+        if (cache.json !== void 0) return cache.json;
+        throw new Error("Request body is not valid JSON");
       }
-      let parameters;
-      if (hasOwnProperty.call(def, "parameters")) {
-        parameters = def.parameters;
-        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+      async text() {
+        const cache = await this.ensureBody();
+        return cache.text;
+      }
+      async formData() {
+        const cache = await this.ensureBody();
+        if (cache.formData !== null) return cache.formData;
+        if (cache.multipartParsed !== null) {
+          const result = {};
+          for (const part of cache.multipartParsed) {
+            if (part.type === "field") {
+              result[part.name] = part.value;
+            }
+          }
+          return result;
         }
-      } else {
-        parameters = inferParameters(rows);
+        return {};
       }
-      if (parameters.length !== new Set(parameters).size) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      async file(name) {
+        const cache = await this.ensureBody();
+        if (cache.files !== null) {
+          return cache.files[name];
+        }
+        return void 0;
       }
-      if (parameters.length > 32) {
-        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      async files() {
+        const cache = await this.ensureBody();
+        return cache.files ?? {};
       }
-      for (const parameter of parameters) {
-        if (columns.includes(parameter)) {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+      cookie(name) {
+        if (this._cookies === null) {
+          const cookieHeader = this._headers.get("cookie");
+          this._cookies = cookieHeader !== void 0 ? parseCookies(cookieHeader) : {};
         }
+        return this._cookies[name];
       }
-      let safeIntegers = 2;
-      if (hasOwnProperty.call(def, "safeIntegers")) {
-        const bool = def.safeIntegers;
-        if (typeof bool !== "boolean") {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+      async validate(schema) {
+        const data = await this.body();
+        const result = schema.validate(data);
+        if (!result.success) {
+          const messages = (result.errors ?? []).map((e) => {
+            const path3 = e.path ?? "";
+            return path3 ? `${path3}: ${e.message}` : e.message;
+          }).join("; ");
+          throw new ValidationError(messages, result.errors ?? []);
         }
-        safeIntegers = +bool;
+        return result.data;
       }
-      let directOnly = false;
-      if (hasOwnProperty.call(def, "directOnly")) {
-        directOnly = def.directOnly;
-        if (typeof directOnly !== "boolean") {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+      isAjax() {
+        const requestedWith = this._headers.get("x-requested-with");
+        return requestedWith?.toLowerCase() === "xmlhttprequest";
+      }
+      wantsJson() {
+        const accept = this._headers.get("accept");
+        if (accept !== void 0 && accept.includes("application/json")) {
+          return true;
         }
+        return this.isAjax();
       }
-      const columnDefinitions = [
-        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
-        ...columns.map(identifier)
-      ];
-      return [
-        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
-        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
-        parameters,
-        safeIntegers,
-        directOnly
-      ];
-    }
-    function wrapGenerator(generator, columnMap, moduleName) {
-      return function* virtualTable(...args) {
-        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
-        for (let i = 0; i < columnMap.size; ++i) {
-          output.push(null);
+      bearerToken() {
+        const auth = this._headers.get("authorization");
+        if (auth === void 0) return void 0;
+        const match = auth.match(/^Bearer\s+(.+)$/i);
+        return match?.[1];
+      }
+      get rawRequest() {
+        return this.raw;
+      }
+    };
+    ValidationError = class extends Error {
+      constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = "ValidationError";
+      }
+      errors;
+    };
+  }
+});
+
+// src/server/http/response.ts
+import { createReadStream, stat } from "fs";
+import { basename as basename2, extname as extname2, resolve } from "path";
+import { promisify } from "util";
+function joinPath(root, filePath) {
+  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
+  const normalizedPath = filePath.replace(/\\/g, "/").replace(/^\//, "");
+  return `${normalizedRoot}/${normalizedPath}`;
+}
+var statAsync, MIME_TYPES, SuperResponse;
+var init_response = __esm({
+  "src/server/http/response.ts"() {
+    "use strict";
+    init_cookie();
+    init_headers();
+    init_status();
+    statAsync = promisify(stat);
+    MIME_TYPES = {
+      ".html": "text/html",
+      ".css": "text/css",
+      ".js": "application/javascript",
+      ".mjs": "application/javascript",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp",
+      ".ico": "image/x-icon",
+      ".pdf": "application/pdf",
+      ".txt": "text/plain",
+      ".xml": "application/xml",
+      ".zip": "application/zip",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".eot": "application/vnd.ms-fontobject",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".mp3": "audio/mpeg",
+      ".wav": "audio/wav"
+    };
+    SuperResponse = class {
+      raw;
+      _statusCode = HttpStatus.OK;
+      _headers = new HeadersMap();
+      _cookies = [];
+      _body = null;
+      _sent = false;
+      _contentTypeSet = false;
+      constructor(raw) {
+        this.raw = raw;
+      }
+      status(code) {
+        this._statusCode = code;
+        return this;
+      }
+      header(name, value) {
+        this._headers.set(name, value);
+        return this;
+      }
+      setHeader(name, value) {
+        return this.header(name, value);
+      }
+      getHeader(name) {
+        return this._headers.get(name);
+      }
+      removeHeader(name) {
+        this._headers.delete(name);
+        return this;
+      }
+      hasHeader(name) {
+        return this._headers.has(name);
+      }
+      type(contentType) {
+        this._headers.set("content-type", contentType);
+        this._contentTypeSet = true;
+        return this;
+      }
+      json(data, status) {
+        if (status !== void 0) this._statusCode = status;
+        const body = JSON.stringify(data);
+        return this.send(body, void 0, "application/json");
+      }
+      send(body, status, contentType) {
+        if (status !== void 0) this._statusCode = status;
+        this._body = body;
+        if (contentType !== void 0 && !this._contentTypeSet) {
+          this._headers.set("content-type", contentType);
         }
-        for (const row of generator(...args)) {
-          if (Array.isArray(row)) {
-            extractRowArray(row, output, columnMap.size, moduleName);
-            yield output;
-          } else if (typeof row === "object" && row !== null) {
-            extractRowObject(row, output, columnMap, moduleName);
-            yield output;
-          } else {
-            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+        return this;
+      }
+      html(html, status) {
+        return this.send(html, status, "text/html; charset=utf-8");
+      }
+      redirect(url2, status = HttpStatus.FOUND) {
+        if (url2.includes("\r") || url2.includes("\n")) {
+          throw new Error("Invalid redirect URL");
+        }
+        this._statusCode = status;
+        this._headers.set("location", url2);
+        this._body = null;
+        return this;
+      }
+      stream(stream, status) {
+        if (status !== void 0) this._statusCode = status;
+        this.flushHeaders();
+        this.raw.statusCode = this._statusCode;
+        stream.pipe(this.raw);
+        stream.on("end", () => {
+          this._sent = true;
+        });
+        stream.on("error", (_err) => {
+          if (!this._sent) {
+            this._sent = true;
+            this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+            this.raw.end();
           }
+        });
+        return this;
+      }
+      async file(filePath, options) {
+        const fullPath = options?.root ? joinPath(options.root, filePath) : filePath;
+        const resolved = resolve(fullPath);
+        const root = options?.root ? resolve(options.root) : null;
+        if (root !== null && !resolved.startsWith(root)) {
+          this._statusCode = HttpStatus.FORBIDDEN;
+          this._body = null;
+          return this;
         }
-      };
-    }
-    function extractRowArray(row, output, columnCount, moduleName) {
-      if (row.length !== columnCount) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+        try {
+          const stats = await statAsync(fullPath);
+          if (!stats.isFile()) {
+            this._statusCode = HttpStatus.NOT_FOUND;
+            this._body = null;
+            return this;
+          }
+          const ext = extname2(fullPath);
+          const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+          this._headers.set("content-type", mimeType);
+          this._headers.set("content-length", String(stats.size));
+          if (options?.cacheControl !== false) {
+            const maxAge = options?.maxAge ?? 0;
+            this._headers.set("cache-control", `public, max-age=${maxAge}`);
+          }
+          if (options?.lastModified !== false) {
+            this._headers.set("last-modified", stats.mtime.toUTCString());
+          }
+          if (options?.headers !== void 0) {
+            for (const [key, value] of Object.entries(options.headers)) {
+              this._headers.set(key, value);
+            }
+          }
+          this.flushHeaders();
+          this.raw.statusCode = this._statusCode;
+          const readStream = createReadStream(fullPath);
+          readStream.pipe(this.raw);
+          readStream.on("end", () => {
+            this._sent = true;
+          });
+          readStream.on("error", () => {
+            if (!this._sent) {
+              this._sent = true;
+              this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
+              this.raw.end();
+            }
+          });
+        } catch {
+          this._statusCode = HttpStatus.NOT_FOUND;
+          this._body = null;
+        }
+        return this;
       }
-      const offset = output.length - columnCount;
-      for (let i = 0; i < columnCount; ++i) {
-        output[i + offset] = row[i];
+      async download(filePath, filename) {
+        const downloadName = filename ?? basename2(filePath);
+        this._headers.set(
+          "content-disposition",
+          `attachment; filename="${downloadName}"`
+        );
+        await this.file(filePath);
+        return this;
       }
-    }
-    function extractRowObject(row, output, columnMap, moduleName) {
-      let count = 0;
-      for (const key of Object.keys(row)) {
-        const index = columnMap.get(key);
-        if (index === void 0) {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+      attachment(filename) {
+        if (filename !== void 0) {
+          this._headers.set(
+            "content-disposition",
+            `attachment; filename="${filename}"`
+          );
+        } else {
+          this._headers.set("content-disposition", "attachment");
         }
-        output[index] = row[key];
-        count += 1;
+        return this;
       }
-      if (count !== columnMap.size) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      cookie(name, value, options) {
+        this._cookies.push(serializeCookie(name, value, options));
+        return this;
       }
-    }
-    function inferParameters({ length }) {
-      if (!Number.isInteger(length) || length < 0) {
-        throw new TypeError("Expected function.length to be a positive integer");
+      clearCookie(name, options) {
+        this._cookies.push(clearCookie(name, options));
+        return this;
       }
-      const params = [];
-      for (let i = 0; i < length; ++i) {
-        params.push(`$${i + 1}`);
+      get statusCode() {
+        return this._statusCode;
       }
-      return params;
-    }
-    var { hasOwnProperty } = Object.prototype;
-    var { apply } = Function.prototype;
-    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
-    });
-    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
-    var defer = (x) => () => x;
+      get headersSent() {
+        return this._sent;
+      }
+      get rawResponse() {
+        return this.raw;
+      }
+      async flush() {
+        if (this._sent) return;
+        this._sent = true;
+        this.flushHeaders();
+        this.raw.statusCode = this._statusCode;
+        if (this._body !== null) {
+          this.raw.end(this._body);
+        } else {
+          this.raw.end();
+        }
+      }
+      flushHeaders() {
+        if (this._cookies.length > 0) {
+          this.raw.setHeader("Set-Cookie", this._cookies);
+        }
+        for (const [name, value] of this._headers.entries()) {
+          if (name.toLowerCase() !== "set-cookie") {
+            this.raw.setHeader(name, value);
+          }
+        }
+      }
+    };
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+// src/server/errors.ts
+function registerExceptionHandler(exceptionType, handler) {
+  exceptionHandlers.set(exceptionType, handler);
+}
+function getDefaultErrorName(status) {
+  const names = {
+    400: "BAD_REQUEST",
+    401: "UNAUTHORIZED",
+    403: "FORBIDDEN",
+    404: "NOT_FOUND",
+    405: "METHOD_NOT_ALLOWED",
+    409: "CONFLICT",
+    422: "UNPROCESSABLE_ENTITY",
+    429: "TOO_MANY_REQUESTS",
+    500: "INTERNAL_SERVER_ERROR",
+    503: "SERVICE_UNAVAILABLE"
+  };
+  return names[status] ?? "UNKNOWN_ERROR";
+}
+function normalizeError(_err) {
+  const err = _err instanceof Error ? _err : new Error(String(_err));
+  if (err instanceof HttpException) {
+    const handler = exceptionHandlers.get(err.constructor);
+    if (handler !== void 0) {
+      const result = handler(err);
+      if (result instanceof Promise) {
+        return result;
+      }
+      return result;
+    }
+    return err;
+  }
+  if (process.env.NODE_ENV === "production") {
+    return new InternalServerErrorException();
+  }
+  return new InternalServerErrorException(err.message);
+}
+var HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, MethodNotAllowedException, ConflictException, UnprocessableEntityException, TooManyRequestsException, InternalServerErrorException, ServiceUnavailableException, ValidationException, exceptionHandlers;
+var init_errors = __esm({
+  "src/server/errors.ts"() {
     "use strict";
-    var DatabaseInspection = function Database() {
+    HttpException = class extends Error {
+      status;
+      error;
+      constructor(message, status = 500, error) {
+        super(message);
+        this.name = "HttpException";
+        this.status = status;
+        this.error = error ?? getDefaultErrorName(status);
+      }
+      toJSON() {
+        return {
+          error: this.error,
+          message: this.message,
+          statusCode: this.status
+        };
+      }
     };
-    module.exports = function inspect(depth, opts) {
-      return Object.assign(new DatabaseInspection(), this);
+    BadRequestException = class extends HttpException {
+      constructor(message = "Bad Request") {
+        super(message, 400, "BAD_REQUEST");
+      }
     };
-  }
-});
-
-// node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS({
-  "node_modules/better-sqlite3/lib/database.js"(exports, module) {
-    "use strict";
-    var fs3 = __require("fs");
-    var path3 = __require("path");
-    var util = require_util();
-    var SqliteError = require_sqlite_error();
-    var DEFAULT_ADDON;
-    function Database(filenameGiven, options) {
-      if (new.target == null) {
-        return new Database(filenameGiven, options);
+    UnauthorizedException = class extends HttpException {
+      constructor(message = "Unauthorized") {
+        super(message, 401, "UNAUTHORIZED");
       }
-      let buffer;
-      if (Buffer.isBuffer(filenameGiven)) {
-        buffer = filenameGiven;
-        filenameGiven = ":memory:";
+    };
+    ForbiddenException = class extends HttpException {
+      constructor(message = "Forbidden") {
+        super(message, 403, "FORBIDDEN");
       }
-      if (filenameGiven == null) filenameGiven = "";
-      if (options == null) options = {};
-      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
-      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
-      const filename = filenameGiven.trim();
-      const anonymous = filename === "" || filename === ":memory:";
-      const readonly = util.getBooleanOption(options, "readonly");
-      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
-      const timeout = "timeout" in options ? options.timeout : 5e3;
-      const verbose = "verbose" in options ? options.verbose : null;
-      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
-      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
-      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
-      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
-      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
-      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
-      let addon;
-      if (nativeBinding == null) {
-        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
-      } else if (typeof nativeBinding === "string") {
-        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
-        addon = requireFunc(path3.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-      } else {
-        addon = nativeBinding;
+    };
+    NotFoundException = class extends HttpException {
+      constructor(message = "Not Found") {
+        super(message, 404, "NOT_FOUND");
       }
-      if (!addon.isInitialized) {
-        addon.setErrorConstructor(SqliteError);
-        addon.isInitialized = true;
+    };
+    MethodNotAllowedException = class extends HttpException {
+      constructor(message = "Method Not Allowed") {
+        super(message, 405, "METHOD_NOT_ALLOWED");
       }
-      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path3.dirname(filename))) {
-        throw new TypeError("Cannot open database because the directory does not exist");
+    };
+    ConflictException = class extends HttpException {
+      constructor(message = "Conflict") {
+        super(message, 409, "CONFLICT");
       }
-      Object.defineProperties(this, {
-        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
-        ...wrappers.getters
-      });
-    }
-    var wrappers = require_wrappers();
-    Database.prototype.prepare = wrappers.prepare;
-    Database.prototype.transaction = require_transaction();
-    Database.prototype.pragma = require_pragma();
-    Database.prototype.backup = require_backup();
-    Database.prototype.serialize = require_serialize();
-    Database.prototype.function = require_function();
-    Database.prototype.aggregate = require_aggregate();
-    Database.prototype.table = require_table();
-    Database.prototype.loadExtension = wrappers.loadExtension;
-    Database.prototype.exec = wrappers.exec;
-    Database.prototype.close = wrappers.close;
-    Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database.prototype.unsafeMode = wrappers.unsafeMode;
-    Database.prototype[util.inspect] = require_inspect();
-    module.exports = Database;
+    };
+    UnprocessableEntityException = class extends HttpException {
+      constructor(message = "Unprocessable Entity") {
+        super(message, 422, "UNPROCESSABLE_ENTITY");
+      }
+    };
+    TooManyRequestsException = class extends HttpException {
+      constructor(message = "Too Many Requests") {
+        super(message, 429, "TOO_MANY_REQUESTS");
+      }
+    };
+    InternalServerErrorException = class extends HttpException {
+      constructor(message = "Internal Server Error") {
+        super(message, 500, "INTERNAL_SERVER_ERROR");
+      }
+    };
+    ServiceUnavailableException = class extends HttpException {
+      constructor(message = "Service Unavailable") {
+        super(message, 503, "SERVICE_UNAVAILABLE");
+      }
+    };
+    ValidationException = class extends HttpException {
+      errors;
+      constructor(errors, message = "Validation Failed") {
+        super(message, 422, "VALIDATION_ERROR");
+        this.errors = errors;
+      }
+      toJSON() {
+        return {
+          error: this.error,
+          message: this.message,
+          statusCode: this.status,
+          errors: this.errors
+        };
+      }
+    };
+    exceptionHandlers = /* @__PURE__ */ new Map();
   }
 });
 
-// node_modules/better-sqlite3/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/better-sqlite3/lib/index.js"(exports, module) {
+// node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "node_modules/better-sqlite3/lib/util.js"(exports) {
     "use strict";
-    module.exports = require_database();
-    module.exports.SqliteError = require_sqlite_error();
+    exports.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports.cppdb = /* @__PURE__ */ Symbol();
+    exports.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
   }
 });
 
-// src/server/container/index.ts
-var Container = class {
-  bindings = /* @__PURE__ */ new Map();
-  resolving = /* @__PURE__ */ new Set();
-  bind(name, factory) {
-    this.bindings.set(name, { factory, singleton: false });
-    return this;
-  }
-  singleton(name, factory) {
-    this.bindings.set(name, { factory, singleton: true });
-    return this;
-  }
-  instance(name, instance) {
-    this.bindings.set(name, {
-      factory: () => instance,
-      singleton: true,
-      instance
-    });
-    return this;
-  }
-  resolve(name) {
-    const binding = this.bindings.get(name);
-    if (binding === void 0) {
-      throw new Error(`Binding not found: ${name}`);
-    }
-    if (binding.singleton && binding.instance !== void 0) {
-      return binding.instance;
-    }
-    if (this.resolving.has(name)) {
-      throw new Error(
-        `Circular dependency detected: ${name} is already being resolved`
-      );
-    }
-    this.resolving.add(name);
-    try {
-      const instance = binding.factory();
-      if (binding.singleton) {
-        binding.instance = instance;
+// node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
       }
-      return instance;
-    } finally {
-      this.resolving.delete(name);
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
     }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module.exports = SqliteError;
   }
-  has(name) {
-    return this.bindings.has(name);
-  }
-  remove(name) {
-    this.bindings.delete(name);
-  }
-  clear() {
-    this.bindings.clear();
-    this.resolving.clear();
-  }
-  getBindings() {
-    return new Map(this.bindings);
-  }
-};
-
-// src/server/http/status.ts
-var HttpStatus = {
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  RESET_CONTENT: 205,
-  PARTIAL_CONTENT: 206,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  SEE_OTHER: 303,
-  NOT_MODIFIED: 304,
-  TEMPORARY_REDIRECT: 307,
-  PERMANENT_REDIRECT: 308,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  NOT_ACCEPTABLE: 406,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  LENGTH_REQUIRED: 411,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  UNPROCESSABLE_ENTITY: 422,
-  TOO_MANY_REQUESTS: 429,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504,
-  HTTP_VERSION_NOT_SUPPORTED: 505
-};
-
-// src/server/controller/index.ts
-var controllerPrefixMap = /* @__PURE__ */ new WeakMap();
-var controllerRoutesMap = /* @__PURE__ */ new WeakMap();
-function createRouteDecorator(method) {
-  return (path3) => {
-    return (target, context) => {
-      const classTarget = context.static ? target : target.constructor;
-      const routes = controllerRoutesMap.get(classTarget) ?? [];
-      routes.push({ method, path: path3, handler: context.name });
-      controllerRoutesMap.set(classTarget, routes);
-    };
-  };
-}
-var get = createRouteDecorator("GET");
-var post = createRouteDecorator("POST");
-var put = createRouteDecorator("PUT");
-var patch = createRouteDecorator("PATCH");
-var del = createRouteDecorator("DELETE");
-function getControllerPrefix(controllerClass) {
-  return controllerPrefixMap.get(controllerClass) ?? "";
-}
-function getControllerRoutes(controllerClass) {
-  return controllerRoutesMap.get(controllerClass) ?? [];
-}
-
-// src/server/engine/index.ts
-import { createServer as createHttpServer } from "http";
+});
 
-// src/server/http/headers.ts
-var HeadersMap = class {
-  data;
-  constructor(initial) {
-    this.data = /* @__PURE__ */ new Map();
-    if (initial) {
-      for (const key of Object.keys(initial)) {
-        const value = initial[key];
-        if (value !== void 0) {
-          this.set(key, Array.isArray(value) ? value.join(", ") : value);
-        }
+// node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "node_modules/file-uri-to-path/index.js"(exports, module) {
+    "use strict";
+    var sep = __require("path").sep || "/";
+    module.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
       }
-    }
-  }
-  get(name) {
-    const values = this.data.get(name.toLowerCase());
-    if (values !== void 0 && values.length > 0) {
-      return values[0];
-    }
-    return void 0;
-  }
-  getAll(name) {
-    const values = this.data.get(name.toLowerCase());
-    return values ?? [];
-  }
-  set(name, value) {
-    this.data.set(name.toLowerCase(), [value]);
-  }
-  append(name, value) {
-    const key = name.toLowerCase();
-    const existing = this.data.get(key);
-    if (existing !== void 0) {
-      existing.push(value);
-    } else {
-      this.data.set(key, [value]);
-    }
-  }
-  has(name) {
-    return this.data.has(name.toLowerCase());
-  }
-  delete(name) {
-    this.data.delete(name.toLowerCase());
-  }
-  *entries() {
-    for (const [key, values] of this.data) {
-      for (const value of values) {
-        yield [key, value];
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path3 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
       }
-    }
-  }
-  *keys() {
-    for (const key of this.data.keys()) {
-      yield key;
-    }
-  }
-  *values() {
-    for (const [, values] of this.data) {
-      for (const value of values) {
-        yield value;
+      path3 = path3.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path3 = path3.replace(/\//g, "\\");
       }
-    }
-  }
-  toJSON() {
-    const result = {};
-    for (const [key, values] of this.data) {
-      result[key] = values.length === 1 ? values[0] : values;
-    }
-    return result;
-  }
-  toNodeHeaders() {
-    const result = {};
-    for (const [key, values] of this.data) {
-      if (key === "set-cookie") {
-        result[key] = values;
+      if (/^.+\:/.test(path3)) {
       } else {
-        result[key] = values.join(", ");
+        path3 = sep + path3;
       }
-    }
-    return result;
-  }
-  get size() {
-    return this.data.size;
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-};
-
-// src/server/http/cookie.ts
-function parseCookies(header) {
-  const result = {};
-  if (!header) return result;
-  const pairs = header.split(";");
-  for (const pair of pairs) {
-    const trimmed = pair.trim();
-    if (!trimmed) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex === -1) {
-      result[trimmed] = "";
-      continue;
-    }
-    const name = trimmed.slice(0, eqIndex).trim();
-    let value = trimmed.slice(eqIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"')) {
-      value = value.slice(1, -1);
-    }
-    if (name) {
-      result[decodeURIComponent(name)] = decodeURIComponent(value);
-    }
-  }
-  return result;
-}
-function serializeCookieValue(name, value) {
-  return `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
-}
-function serializeCookie(name, value, options) {
-  const parts = [serializeCookieValue(name, value)];
-  if (options) {
-    if (options.maxAge !== void 0) {
-      parts.push(`Max-Age=${Math.floor(options.maxAge)}`);
-    }
-    if (options.expires !== void 0) {
-      parts.push(`Expires=${options.expires.toUTCString()}`);
-    }
-    if (options.path !== void 0) {
-      parts.push(`Path=${options.path}`);
-    } else {
-      parts.push("Path=/");
-    }
-    if (options.domain !== void 0) {
-      parts.push(`Domain=${options.domain}`);
-    }
-    if (options.secure) {
-      parts.push("Secure");
-    }
-    if (options.httpOnly) {
-      parts.push("HttpOnly");
-    }
-    if (options.sameSite !== void 0) {
-      parts.push(`SameSite=${options.sameSite}`);
-    }
-  }
-  return parts.join("; ");
-}
-function clearCookie(name, options) {
-  return serializeCookie(name, "", {
-    ...options,
-    maxAge: 0,
-    expires: /* @__PURE__ */ new Date(0)
-  });
-}
-
-// src/server/http/upload.ts
-import { randomUUID } from "crypto";
-import { writeFile, readFile, unlink, mkdir } from "fs/promises";
-import { join, extname, basename, dirname } from "path";
-import { tmpdir } from "os";
-var IMAGE_MIME_TYPES = /* @__PURE__ */ new Set([
-  "image/jpeg",
-  "image/png",
-  "image/gif",
-  "image/webp",
-  "image/svg+xml",
-  "image/bmp",
-  "image/tiff",
-  "image/avif"
-]);
-var VIDEO_MIME_TYPES = /* @__PURE__ */ new Set([
-  "video/mp4",
-  "video/mpeg",
-  "video/webm",
-  "video/ogg",
-  "video/quicktime",
-  "video/x-msvideo",
-  "video/x-matroska"
-]);
-var SuperUploadedFile = class _SuperUploadedFile {
-  fieldName;
-  originalName;
-  mimeType;
-  size;
-  path;
-  extension;
-  buffer;
-  constructor(opts) {
-    this.fieldName = opts.fieldName;
-    this.originalName = opts.originalName;
-    this.mimeType = opts.mimeType;
-    this.size = opts.size;
-    this.path = opts.path;
-    this.extension = extname(opts.originalName).toLowerCase();
-    this.buffer = opts.buffer ?? null;
-  }
-  async move(destination, filename) {
-    const destName = filename ?? basename(this.path);
-    const destPath = join(destination, destName);
-    await mkdir(dirname(destPath), { recursive: true });
-    const buf = await this.toBuffer();
-    await writeFile(destPath, buf);
-    return destPath;
-  }
-  async toBuffer() {
-    if (this.buffer !== null) return this.buffer;
-    this.buffer = await readFile(this.path);
-    return this.buffer;
-  }
-  toBase64() {
-    if (this.buffer === null) {
-      throw new Error(
-        "Buffer not loaded. Call toBuffer() first or read the file into memory."
-      );
-    }
-    return this.buffer.toString("base64");
-  }
-  isImage() {
-    return IMAGE_MIME_TYPES.has(this.mimeType);
-  }
-  isVideo() {
-    return VIDEO_MIME_TYPES.has(this.mimeType);
-  }
-  static async createFromBuffer(fieldName, originalName, mimeType, buffer, tempDir) {
-    const tmp = tempDir ?? tmpdir();
-    const fileName = `${randomUUID()}${extname(originalName)}`;
-    const filePath = join(tmp, fileName);
-    await writeFile(filePath, buffer);
-    return new _SuperUploadedFile({
-      fieldName,
-      originalName,
-      mimeType: mimeType || "application/octet-stream",
-      size: buffer.length,
-      path: filePath,
-      buffer
-    });
-  }
-  async cleanup() {
-    try {
-      await unlink(this.path);
-    } catch {
+      return host + path3;
     }
   }
-};
+});
 
-// src/server/http/request.ts
-var SuperRequest = class {
-  raw;
-  _headers;
-  _query;
-  _cookies = null;
-  _ip;
-  _params = {};
-  bodyCache = null;
-  _bodyReadPromise = null;
-  constructor(raw) {
-    this.raw = raw;
-    this._headers = new HeadersMap(
-      raw.headers
-    );
-    const parsedUrl = new URL(raw.url ?? "/", "http://localhost");
-    this._query = parseQueryParams(parsedUrl.searchParams);
-    this._ip = parseIp(raw);
-    this.path = parsedUrl.pathname;
-    this.url = raw.url ?? "/";
-    this.method = (raw.method ?? "GET").toUpperCase();
-  }
-  method;
-  url;
-  path;
-  get headers() {
-    return this._headers;
-  }
-  get query() {
-    return this._query;
-  }
-  get params() {
-    return this._params;
-  }
-  set params(value) {
-    this._params = value;
-  }
-  get ip() {
-    return this._ip;
-  }
-  async ensureBody() {
-    if (this.bodyCache !== null) return this.bodyCache;
-    if (this._bodyReadPromise === null) {
-      this._bodyReadPromise = this.readBodyFromStream();
-    }
-    this.bodyCache = await this._bodyReadPromise;
-    return this.bodyCache;
-  }
-  async readBodyFromStream() {
-    const chunks = [];
-    const MAX_BODY_SIZE = 10 * 1024 * 1024;
-    let totalSize = 0;
-    for await (const chunk of this.raw) {
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      totalSize += buf.length;
-      if (totalSize > MAX_BODY_SIZE) {
-        throw new Error("Request body too large. Maximum size is 10MB.");
-      }
-      chunks.push(buf);
-    }
-    const raw = Buffer.concat(chunks);
-    const text = raw.toString("utf-8");
-    let json = void 0;
-    if (this.isContentType("application/json")) {
-      try {
-        json = JSON.parse(text);
-      } catch {
-        json = void 0;
-      }
-    }
-    let formData = null;
-    let multipartParsed = null;
-    let files = null;
-    if (this.isContentType("application/x-www-form-urlencoded")) {
-      formData = parseUrlEncoded(text);
-    } else if (this.isContentType("multipart/form-data")) {
-      const boundary = this.getMultipartBoundary();
-      if (boundary !== void 0) {
-        multipartParsed = parseMultipartBody(raw, boundary);
-        formData = {};
-        files = {};
-        for (const part of multipartParsed) {
-          if (part.type === "field") {
-            formData[part.name] = part.value;
-          } else if (part.type === "file") {
-            const uploadedFile = await SuperUploadedFile.createFromBuffer(
-              part.name,
-              part.filename,
-              part.mimeType,
-              part.data
-            );
-            files[part.name] = uploadedFile;
+// node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/bindings/bindings.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path3 = __require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join5 = path3.join;
+    var dirname4 = path3.dirname;
+    var exists = fs3.accessSync && function(path4) {
+      try {
+        fs3.accessSync(path4);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs3.existsSync || path3.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports.getRoot(exports.getFileName());
+      }
+      if (path3.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join5.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
           }
         }
       }
-    }
-    return {
-      raw,
-      text,
-      json,
-      parsed: json ?? text,
-      formData,
-      files,
-      multipartParsed
-    };
-  }
-  isContentType(expected) {
-    const ct = this._headers.get("content-type");
-    if (ct === void 0) return false;
-    return ct.toLowerCase().startsWith(expected);
-  }
-  getMultipartBoundary() {
-    const ct = this._headers.get("content-type");
-    if (ct === void 0) return void 0;
-    const match = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
-    if (match !== null) {
-      return match[1] ?? match[2];
-    }
-    return void 0;
-  }
-  async body() {
-    const cache = await this.ensureBody();
-    return cache.parsed;
-  }
-  async json() {
-    const cache = await this.ensureBody();
-    if (cache.json !== void 0) return cache.json;
-    throw new Error("Request body is not valid JSON");
-  }
-  async text() {
-    const cache = await this.ensureBody();
-    return cache.text;
-  }
-  async formData() {
-    const cache = await this.ensureBody();
-    if (cache.formData !== null) return cache.formData;
-    if (cache.multipartParsed !== null) {
-      const result = {};
-      for (const part of cache.multipartParsed) {
-        if (part.type === "field") {
-          result[part.name] = part.value;
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module.exports = exports = bindings;
+    exports.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath(fileName);
+      }
+      return fileName;
+    };
+    exports.getRoot = function getRoot(file) {
+      var dir = dirname4(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join5(dir, "..");
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path3 = __require("path");
+    var { promisify: promisify2 } = __require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify2(fs3.access);
+    module.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path3.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve4, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve4(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+    "use strict";
+    var { cppdb } = require_util();
+    module.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
         }
       }
-      return result;
-    }
-    return {};
-  }
-  async file(name) {
-    const cache = await this.ensureBody();
-    if (cache.files !== null) {
-      return cache.files[name];
-    }
-    return void 0;
-  }
-  async files() {
-    const cache = await this.ensureBody();
-    return cache.files ?? {};
-  }
-  cookie(name) {
-    if (this._cookies === null) {
-      const cookieHeader = this._headers.get("cookie");
-      this._cookies = cookieHeader !== void 0 ? parseCookies(cookieHeader) : {};
-    }
-    return this._cookies[name];
-  }
-  async validate(schema) {
-    const data = await this.body();
-    const result = schema.validate(data);
-    if (!result.success) {
-      const messages = (result.errors ?? []).map((e) => {
-        const path3 = e.path ?? "";
-        return path3 ? `${path3}: ${e.message}` : e.message;
-      }).join("; ");
-      throw new ValidationError(messages, result.errors ?? []);
-    }
-    return result.data;
-  }
-  isAjax() {
-    const requestedWith = this._headers.get("x-requested-with");
-    return requestedWith?.toLowerCase() === "xmlhttprequest";
-  }
-  wantsJson() {
-    const accept = this._headers.get("accept");
-    if (accept !== void 0 && accept.includes("application/json")) {
-      return true;
-    }
-    return this.isAjax();
-  }
-  bearerToken() {
-    const auth = this._headers.get("authorization");
-    if (auth === void 0) return void 0;
-    const match = auth.match(/^Bearer\s+(.+)$/i);
-    return match?.[1];
-  }
-  get rawRequest() {
-    return this.raw;
-  }
-};
-var ValidationError = class extends Error {
-  constructor(message, errors) {
-    super(message);
-    this.errors = errors;
-    this.name = "ValidationError";
-  }
-  errors;
-};
-function parseQueryParams(searchParams) {
-  const result = {};
-  for (const key of searchParams.keys()) {
-    const values = searchParams.getAll(key);
-    result[key] = values.length === 1 ? values[0] : values;
-  }
-  return result;
-}
-function parseIp(req) {
-  const forwarded = req.headers["x-forwarded-for"];
-  if (forwarded !== void 0) {
-    const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(",")[0];
-    if (first !== void 0) return first.trim();
-  }
-  const realIp = req.headers["x-real-ip"];
-  if (realIp !== void 0) {
-    return Array.isArray(realIp) ? realIp[0] : realIp;
-  }
-  const remote = req.socket.remoteAddress;
-  if (remote !== void 0) {
-    if (remote.startsWith("::ffff:")) return remote.slice(7);
-    return remote;
-  }
-  return "127.0.0.1";
-}
-function parseUrlEncoded(text) {
-  const result = {};
-  const pairs = text.split("&");
-  for (const pair of pairs) {
-    if (!pair) continue;
-    const eqIndex = pair.indexOf("=");
-    if (eqIndex === -1) {
-      result[decodeURIComponent(pair)] = "";
-    } else {
-      const key = decodeURIComponent(pair.slice(0, eqIndex));
-      const value = decodeURIComponent(pair.slice(eqIndex + 1));
-      result[key] = value;
-    }
-  }
-  return result;
-}
-function parseMultipartBody(body, boundary) {
-  const result = [];
-  const boundaryBuffer = Buffer.from(`--${boundary}`);
-  let start = 0;
-  let searchFrom = 0;
-  while (true) {
-    const boundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
-    if (boundaryIndex === -1) break;
-    searchFrom = boundaryIndex + boundaryBuffer.length;
-    if (searchFrom < body.length && body[searchFrom] === 45 && body[searchFrom + 1] === 45) {
-      break;
-    }
-    if (searchFrom >= body.length) break;
-    if (body[searchFrom] === 13) searchFrom++;
-    if (body[searchFrom] === 10) searchFrom++;
-    start = searchFrom;
-    const nextBoundaryIndex = body.indexOf(boundaryBuffer, searchFrom);
-    if (nextBoundaryIndex === -1) break;
-    let partEnd = nextBoundaryIndex;
-    if (partEnd >= 2 && body[partEnd - 2] === 13 && body[partEnd - 1] === 10) {
-      partEnd -= 2;
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
     }
-    const partData = body.slice(start, partEnd);
-    const headerEndIndex = partData.indexOf(Buffer.from("\r\n\r\n"));
-    if (headerEndIndex === -1) {
-      searchFrom = nextBoundaryIndex;
-      continue;
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
     }
-    const headerSection = partData.slice(0, headerEndIndex).toString("utf-8");
-    const contentData = partData.slice(headerEndIndex + 4);
-    const disposition = parseDisposition(headerSection);
-    if (disposition === void 0) {
-      searchFrom = nextBoundaryIndex;
-      continue;
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
     }
-    if (disposition.filename !== void 0) {
-      const contentType = parseContentType(headerSection);
-      result.push({
-        type: "file",
-        name: disposition.name,
-        filename: disposition.filename,
-        mimeType: contentType,
-        data: Buffer.from(contentData)
-      });
-    } else {
-      result.push({
-        type: "field",
-        name: disposition.name,
-        value: contentData.toString("utf-8").trim()
-      });
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
     }
-    searchFrom = nextBoundaryIndex;
-  }
-  return result;
-}
-function parseDisposition(headerSection) {
-  const match = headerSection.match(
-    /content-disposition:\s*form-data;\s*(.+)/i
-  );
-  if (match === null) return void 0;
-  const params = match[1];
-  const nameMatch = params.match(/name="([^"]*)"/i);
-  const filenameMatch = params.match(/filename="([^"]*)"/i);
-  if (nameMatch === null) return void 0;
-  return {
-    name: nameMatch[1],
-    filename: filenameMatch?.[1]
-  };
-}
-function parseContentType(headerSection) {
-  const match = headerSection.match(/content-type:\s*([^\s;]+)/i);
-  return match?.[1] ?? "application/octet-stream";
-}
-
-// src/server/http/response.ts
-import { createReadStream, stat } from "fs";
-import { basename as basename2, extname as extname2, resolve } from "path";
-import { promisify } from "util";
-var statAsync = promisify(stat);
-var MIME_TYPES = {
-  ".html": "text/html",
-  ".css": "text/css",
-  ".js": "application/javascript",
-  ".mjs": "application/javascript",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".svg": "image/svg+xml",
-  ".webp": "image/webp",
-  ".ico": "image/x-icon",
-  ".pdf": "application/pdf",
-  ".txt": "text/plain",
-  ".xml": "application/xml",
-  ".zip": "application/zip",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".eot": "application/vnd.ms-fontobject",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav"
-};
-var SuperResponse = class {
-  raw;
-  _statusCode = HttpStatus.OK;
-  _headers = new HeadersMap();
-  _cookies = [];
-  _body = null;
-  _sent = false;
-  _contentTypeSet = false;
-  constructor(raw) {
-    this.raw = raw;
-  }
-  status(code) {
-    this._statusCode = code;
-    return this;
-  }
-  header(name, value) {
-    this._headers.set(name, value);
-    return this;
-  }
-  setHeader(name, value) {
-    return this.header(name, value);
-  }
-  getHeader(name) {
-    return this._headers.get(name);
-  }
-  removeHeader(name) {
-    this._headers.delete(name);
-    return this;
-  }
-  hasHeader(name) {
-    return this._headers.has(name);
-  }
-  type(contentType) {
-    this._headers.set("content-type", contentType);
-    this._contentTypeSet = true;
-    return this;
-  }
-  json(data, status) {
-    if (status !== void 0) this._statusCode = status;
-    const body = JSON.stringify(data);
-    return this.send(body, void 0, "application/json");
-  }
-  send(body, status, contentType) {
-    if (status !== void 0) this._statusCode = status;
-    this._body = body;
-    if (contentType !== void 0 && !this._contentTypeSet) {
-      this._headers.set("content-type", contentType);
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
     }
-    return this;
-  }
-  html(html, status) {
-    return this.send(html, status, "text/html; charset=utf-8");
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
   }
-  redirect(url2, status = HttpStatus.FOUND) {
-    if (url2.includes("\r") || url2.includes("\n")) {
-      throw new Error("Invalid redirect URL");
-    }
-    this._statusCode = status;
-    this._headers.set("location", url2);
-    this._body = null;
-    return this;
+});
+
+// node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
+    "use strict";
+    var DatabaseInspection = function Database() {
+    };
+    module.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
   }
-  stream(stream, status) {
-    if (status !== void 0) this._statusCode = status;
-    this.flushHeaders();
-    this.raw.statusCode = this._statusCode;
-    stream.pipe(this.raw);
-    stream.on("end", () => {
-      this._sent = true;
-    });
-    stream.on("error", (_err) => {
-      if (!this._sent) {
-        this._sent = true;
-        this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
-        this.raw.end();
+});
+
+// node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/better-sqlite3/lib/database.js"(exports, module) {
+    "use strict";
+    var fs3 = __require("fs");
+    var path3 = __require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database(filenameGiven, options);
       }
-    });
-    return this;
-  }
-  async file(filePath, options) {
-    const fullPath = options?.root ? joinPath(options.root, filePath) : filePath;
-    const resolved = resolve(fullPath);
-    const root = options?.root ? resolve(options.root) : null;
-    if (root !== null && !resolved.startsWith(root)) {
-      this._statusCode = HttpStatus.FORBIDDEN;
-      this._body = null;
-      return this;
-    }
-    try {
-      const stats = await statAsync(fullPath);
-      if (!stats.isFile()) {
-        this._statusCode = HttpStatus.NOT_FOUND;
-        this._body = null;
-        return this;
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
       }
-      const ext = extname2(fullPath);
-      const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
-      this._headers.set("content-type", mimeType);
-      this._headers.set("content-length", String(stats.size));
-      if (options?.cacheControl !== false) {
-        const maxAge = options?.maxAge ?? 0;
-        this._headers.set("cache-control", `public, max-age=${maxAge}`);
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : __require;
+        addon = requireFunc(path3.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
       }
-      if (options?.lastModified !== false) {
-        this._headers.set("last-modified", stats.mtime.toUTCString());
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
       }
-      if (options?.headers !== void 0) {
-        for (const [key, value] of Object.entries(options.headers)) {
-          this._headers.set(key, value);
-        }
+      if (!anonymous && !filename.startsWith("file:") && !fs3.existsSync(path3.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
       }
-      this.flushHeaders();
-      this.raw.statusCode = this._statusCode;
-      const readStream = createReadStream(fullPath);
-      readStream.pipe(this.raw);
-      readStream.on("end", () => {
-        this._sent = true;
-      });
-      readStream.on("error", () => {
-        if (!this._sent) {
-          this._sent = true;
-          this.raw.statusCode = HttpStatus.INTERNAL_SERVER_ERROR;
-          this.raw.end();
-        }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
       });
-    } catch {
-      this._statusCode = HttpStatus.NOT_FOUND;
-      this._body = null;
     }
-    return this;
+    var wrappers = require_wrappers();
+    Database.prototype.prepare = wrappers.prepare;
+    Database.prototype.transaction = require_transaction();
+    Database.prototype.pragma = require_pragma();
+    Database.prototype.backup = require_backup();
+    Database.prototype.serialize = require_serialize();
+    Database.prototype.function = require_function();
+    Database.prototype.aggregate = require_aggregate();
+    Database.prototype.table = require_table();
+    Database.prototype.loadExtension = wrappers.loadExtension;
+    Database.prototype.exec = wrappers.exec;
+    Database.prototype.close = wrappers.close;
+    Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database.prototype.unsafeMode = wrappers.unsafeMode;
+    Database.prototype[util.inspect] = require_inspect();
+    module.exports = Database;
   }
-  async download(filePath, filename) {
-    const downloadName = filename ?? basename2(filePath);
-    this._headers.set(
-      "content-disposition",
-      `attachment; filename="${downloadName}"`
-    );
-    await this.file(filePath);
-    return this;
+});
+
+// node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/better-sqlite3/lib/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_database();
+    module.exports.SqliteError = require_sqlite_error();
   }
-  attachment(filename) {
-    if (filename !== void 0) {
-      this._headers.set(
-        "content-disposition",
-        `attachment; filename="${filename}"`
-      );
-    } else {
-      this._headers.set("content-disposition", "attachment");
-    }
+});
+
+// src/server/container/index.ts
+var Container = class {
+  bindings = /* @__PURE__ */ new Map();
+  resolving = /* @__PURE__ */ new Set();
+  bind(name, factory) {
+    this.bindings.set(name, { factory, singleton: false });
     return this;
   }
-  cookie(name, value, options) {
-    this._cookies.push(serializeCookie(name, value, options));
+  singleton(name, factory) {
+    this.bindings.set(name, { factory, singleton: true });
     return this;
   }
-  clearCookie(name, options) {
-    this._cookies.push(clearCookie(name, options));
+  instance(name, instance) {
+    this.bindings.set(name, {
+      factory: () => instance,
+      singleton: true,
+      instance
+    });
     return this;
   }
-  get statusCode() {
-    return this._statusCode;
-  }
-  get headersSent() {
-    return this._sent;
-  }
-  get rawResponse() {
-    return this.raw;
-  }
-  async flush() {
-    if (this._sent) return;
-    this._sent = true;
-    this.flushHeaders();
-    this.raw.statusCode = this._statusCode;
-    if (this._body !== null) {
-      this.raw.end(this._body);
-    } else {
-      this.raw.end();
+  resolve(name) {
+    const binding = this.bindings.get(name);
+    if (binding === void 0) {
+      throw new Error(`Binding not found: ${name}`);
     }
-  }
-  flushHeaders() {
-    if (this._cookies.length > 0) {
-      this.raw.setHeader("Set-Cookie", this._cookies);
+    if (binding.singleton && binding.instance !== void 0) {
+      return binding.instance;
+    }
+    if (this.resolving.has(name)) {
+      throw new Error(
+        `Circular dependency detected: ${name} is already being resolved`
+      );
     }
-    for (const [name, value] of this._headers.entries()) {
-      if (name.toLowerCase() !== "set-cookie") {
-        this.raw.setHeader(name, value);
+    this.resolving.add(name);
+    try {
+      const instance = binding.factory();
+      if (binding.singleton) {
+        binding.instance = instance;
       }
+      return instance;
+    } finally {
+      this.resolving.delete(name);
     }
   }
+  has(name) {
+    return this.bindings.has(name);
+  }
+  remove(name) {
+    this.bindings.delete(name);
+  }
+  clear() {
+    this.bindings.clear();
+    this.resolving.clear();
+  }
+  getBindings() {
+    return new Map(this.bindings);
+  }
 };
-function joinPath(root, filePath) {
-  const normalizedRoot = root.replace(/\\/g, "/").replace(/\/$/, "");
-  const normalizedPath = filePath.replace(/\\/g, "/").replace(/^\//, "");
-  return `${normalizedRoot}/${normalizedPath}`;
+
+// src/server/controller/index.ts
+var controllerPrefixMap = /* @__PURE__ */ new WeakMap();
+var controllerRoutesMap = /* @__PURE__ */ new WeakMap();
+function createRouteDecorator(method) {
+  return (path3) => {
+    return (target, context) => {
+      const classTarget = context.static ? target : target.constructor;
+      const routes = controllerRoutesMap.get(classTarget) ?? [];
+      routes.push({ method, path: path3, handler: context.name });
+      controllerRoutesMap.set(classTarget, routes);
+    };
+  };
+}
+var get = createRouteDecorator("GET");
+var post = createRouteDecorator("POST");
+var put = createRouteDecorator("PUT");
+var patch = createRouteDecorator("PATCH");
+var del = createRouteDecorator("DELETE");
+function getControllerPrefix(controllerClass) {
+  return controllerPrefixMap.get(controllerClass) ?? "";
+}
+function getControllerRoutes(controllerClass) {
+  return controllerRoutesMap.get(controllerClass) ?? [];
 }
 
 // src/server/engine/index.ts
+init_request();
+init_response();
+init_errors();
+import { createServer as createHttpServer } from "http";
+import { createServer as createHttpsServer } from "https";
+import { readFileSync } from "fs";
 var NodeEngine = class {
   async createServer(handler) {
     const server = createHttpServer(async (nodeReq, nodeRes) => {
@@ -1730,8 +1904,9 @@ var NodeEngine = class {
         await handler(req, res);
       } catch (_err) {
         if (!res.headersSent) {
-          const message = _err instanceof Error ? _err.message : "Internal Server Error";
-          res.status(500).json({ error: message });
+          const error = _err instanceof Error ? _err : new Error(String(_err));
+          const httpError = normalizeError(error);
+          res.status(httpError.status).json(httpError.toJSON());
           await res.flush();
         }
       }
@@ -1766,7 +1941,11 @@ var NodeEngine = class {
   }
 };
 
+// src/server/index.ts
+init_status();
+
 // src/server/middleware/index.ts
+init_status();
 import { randomUUID as randomUUID2 } from "crypto";
 import { createReadStream as createReadStream2, existsSync, statSync } from "fs";
 import { extname as extname3, join as join2, resolve as resolve2 } from "path";
@@ -4347,10 +4526,15 @@ var Seeder = class {
 
 // src/server/database/model.ts
 var Model = class {
+  /** Primary key */
   id;
   static table = "";
   static connection = null;
   static queryRunner = null;
+  static relationDefs = /* @__PURE__ */ new Map();
+  static eagerLoads = /* @__PURE__ */ new Map();
+  /** @internal cache for loaded relations on instances */
+  _relations = {};
   static setConnection(conn) {
     this.connection = conn;
     this.queryRunner = conn;
@@ -4361,14 +4545,74 @@ var Model = class {
     }
     return new QueryBuilder(this.queryRunner, this.table);
   }
+  // ─── Relations Definition ──────────────────────────────────
+  static hasOne(relatedModel, foreignKey, localKey) {
+    const key = `hasOne:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "hasOne",
+      relatedModel,
+      foreignKey: foreignKey ?? `${this.table}_id`,
+      localKey: localKey ?? "id"
+    });
+  }
+  static hasMany(relatedModel, foreignKey, localKey) {
+    const key = `hasMany:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "hasMany",
+      relatedModel,
+      foreignKey: foreignKey ?? `${this.table}_id`,
+      localKey: localKey ?? "id"
+    });
+  }
+  static belongsTo(relatedModel, foreignKey, ownerKey) {
+    const key = `belongsTo:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "belongsTo",
+      relatedModel,
+      foreignKey: foreignKey ?? `${relatedModel.table}_id`,
+      localKey: ownerKey ?? "id"
+    });
+  }
+  static belongsToMany(relatedModel, pivotTable, foreignPivotKey, relatedPivotKey) {
+    const tables = [this.table, relatedModel.table].sort();
+    const key = `belongsToMany:${relatedModel.table}`;
+    this.relationDefs.set(key, {
+      type: "belongsToMany",
+      relatedModel,
+      foreignKey: foreignPivotKey ?? `${this.table}_id`,
+      localKey: relatedPivotKey ?? `${relatedModel.table}_id`,
+      pivotTable: pivotTable ?? `${tables[0]}_${tables[1]}`
+    });
+  }
+  static morphMany(relatedModel, morphName) {
+    const key = `morphMany:${morphName}`;
+    this.relationDefs.set(key, {
+      type: "morphMany",
+      relatedModel,
+      foreignKey: `${morphName}_id`,
+      localKey: "id",
+      morphName
+    });
+  }
+  // ─── Eager Loading ─────────────────────────────────────────
+  static with(...relations) {
+    for (const rel of relations) {
+      this.eagerLoads.set(rel, true);
+    }
+  }
+  // ─── Query Shortcuts ───────────────────────────────────────
   static async all() {
     const rows = await this.query().get();
-    return rows.map((row) => this.hydrate(row));
+    const instances = rows.map((row) => this.hydrate(row));
+    await this.loadRelations(instances);
+    return instances;
   }
   static async find(id) {
     const row = await this.query().find(id);
     if (!row) return null;
-    return this.hydrate(row);
+    const instance = this.hydrate(row);
+    await this.loadRelations([instance]);
+    return instance;
   }
   static async where(column, value) {
     return this.query().where(column, value);
@@ -4395,6 +4639,7 @@ var Model = class {
     }
     return this.create({ ...attributes, ...values });
   }
+  // ─── Instance Methods ──────────────────────────────────────
   async save() {
     const ModelClass = this.constructor;
     const id = this.id;
@@ -4412,22 +4657,64 @@ var Model = class {
       await ModelClass.query().where("id", id).delete();
     }
   }
-  static belongsTo(relatedModel, foreignKey, ownerKey) {
-    const related = relatedModel.table;
-    const fk = foreignKey ?? `${related}_id`;
-    const ok = ownerKey ?? "id";
-    return this.query().where(fk, ok);
-  }
-  static hasMany(relatedModel, foreignKey, localKey) {
-    const related = relatedModel.table;
-    const fk = foreignKey ?? `${this.table}_id`;
-    const lk = localKey ?? "id";
-    return this.query().join(related, fk, "=", lk);
+  // ─── Relation Loader ───────────────────────────────────────
+  static async loadRelations(instances) {
+    if (instances.length === 0) return;
+    for (const [key, def] of this.relationDefs) {
+      const shouldLoad = this.eagerLoads.size === 0 || this.eagerLoads.has(key.split(":")[1] ?? key);
+      if (!shouldLoad) continue;
+      const localIds = instances.map((i) => i[def.localKey]).filter(Boolean);
+      if (def.type === "belongsTo") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.localKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.find((r) => r[def.localKey] === inst[def.foreignKey]) ?? null;
+        }
+      }
+      if (def.type === "hasMany") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.foreignKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.filter((r) => r[def.foreignKey] === inst[def.localKey]);
+        }
+      }
+      if (def.type === "hasOne") {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().whereIn(def.foreignKey, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.find((r) => r[def.foreignKey] === inst[def.localKey]) ?? null;
+        }
+      }
+      if (def.type === "belongsToMany" && def.pivotTable) {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const pivotQb = new QueryBuilder(this.queryRunner, def.pivotTable);
+        const pivotRows = await pivotQb.whereIn(def.foreignKey, localIds).get();
+        const relatedIds = pivotRows.map((r) => r[def.localKey]);
+        if (relatedIds.length > 0) {
+          const related = await def.relatedModel.query().whereIn("id", relatedIds).get();
+          for (const inst of instances) {
+            const pivots = pivotRows.filter((p) => p[def.foreignKey] === inst[def.localKey]);
+            inst._relations[key] = pivots.map((p) => related.find((r) => r.id === p[def.localKey])).filter(Boolean);
+          }
+        } else {
+          for (const inst of instances) {
+            inst._relations[key] = [];
+          }
+        }
+      }
+      if (def.type === "morphMany" && def.morphName) {
+        if (!def.relatedModel.queryRunner) def.relatedModel.setConnection(this.queryRunner);
+        const related = await def.relatedModel.query().where(`${def.morphName}_type`, this.name).whereIn(`${def.morphName}_id`, localIds).get();
+        for (const inst of instances) {
+          inst._relations[key] = related.filter((r) => r[`${def.morphName}_id`] === inst[def.localKey]);
+        }
+      }
+    }
   }
+  // ─── Internal Helpers ──────────────────────────────────────
   static hydrate(data) {
     const instance = new this();
     for (const [key, value] of Object.entries(data)) {
-      ;
       instance[key] = value;
     }
     return instance;
@@ -4447,7 +4734,7 @@ var Model = class {
       "getData"
     ]);
     for (const key of ownKeys) {
-      if (typeof key === "string" && !classKeys.has(key) && key !== "constructor") {
+      if (typeof key === "string" && !classKeys.has(key) && key !== "constructor" && !key.startsWith("_")) {
         data[key] = instance[key];
       }
     }
@@ -4942,6 +5229,7 @@ function storage() {
 }
 
 // src/server/index.ts
+init_errors();
 var SuperApp = class {
   router;
   container;
@@ -4950,6 +5238,10 @@ var SuperApp = class {
   globalPipeline;
   started = false;
   serverPromise;
+  onErrorHandler = null;
+  onNotFoundHandler = null;
+  shutdownHandlers = [];
+  shuttingDown = false;
   constructor(options = {}) {
     this.container = options.container ?? new Container();
     this.router = new Router();
@@ -5049,6 +5341,18 @@ var SuperApp = class {
   view(_engine) {
     return this;
   }
+  onError(handler) {
+    this.onErrorHandler = handler;
+    return this;
+  }
+  notFound(handler) {
+    this.onNotFoundHandler = handler;
+    return this;
+  }
+  onShutdown(handler) {
+    this.shutdownHandlers.push(handler);
+    return this;
+  }
   getServer() {
     return this.serverInstance;
   }
@@ -5073,8 +5377,29 @@ var SuperApp = class {
   }
   listen(port, callback) {
     this.serverPromise = this.start(port).then(() => {
+      const shutdown = async (signal) => {
+        if (this.shuttingDown) return;
+        this.shuttingDown = true;
+        console.log(`
+\u26A0\uFE0F  Received ${signal}. Starting graceful shutdown...`);
+        for (const handler of this.shutdownHandlers) {
+          try {
+            await handler();
+          } catch {
+          }
+        }
+        await this.close();
+        console.log("\u2713 Server shut down gracefully");
+        process.exit(0);
+      };
+      process.on("SIGINT", () => shutdown("SIGINT"));
+      process.on("SIGTERM", () => shutdown("SIGTERM"));
+      if (process.stdin && process.stdin.isTTY) {
+        process.stdin.on("end", () => shutdown("stdin end"));
+      }
       callback?.();
     });
+    return this;
   }
   async close() {
     if (this.serverInstance !== void 0) {
@@ -5091,8 +5416,20 @@ var SuperApp = class {
   async handleRequest(req, res) {
     const resolvedRoute = this.router.resolve(req.method, req.path);
     if (resolvedRoute === null) {
+      if (this.onNotFoundHandler !== null) {
+        const ctx2 = {
+          request: req,
+          response: res,
+          params: {},
+          query: req.query,
+          container: this.container
+        };
+        await this.onNotFoundHandler(ctx2);
+        if (!res.headersSent) await res.flush();
+        return;
+      }
       res.status(HttpStatus.NOT_FOUND).json({
-        error: "Not Found",
+        error: "NOT_FOUND",
         message: `Route ${req.method} ${req.path} not found`
       });
       await res.flush();
@@ -5106,15 +5443,26 @@ var SuperApp = class {
       query: req.query,
       container: this.container
     };
-    await this.globalPipeline.run(ctx, async () => {
-      const routePipeline = new MiddlewarePipeline();
-      for (const mw of resolvedRoute.middleware) {
-        routePipeline.use(mw);
-      }
-      await routePipeline.run(ctx, async () => {
-        await resolvedRoute.handler(ctx);
+    try {
+      await this.globalPipeline.run(ctx, async () => {
+        const routePipeline = new MiddlewarePipeline();
+        for (const mw of resolvedRoute.middleware) {
+          routePipeline.use(mw);
+        }
+        await routePipeline.run(ctx, async () => {
+          await resolvedRoute.handler(ctx);
+        });
       });
-    });
+    } catch (err) {
+      if (this.onErrorHandler !== null) {
+        await this.onErrorHandler(
+          err instanceof Error ? err : new Error(String(err)),
+          ctx
+        );
+      } else {
+        throw err;
+      }
+    }
     if (!res.headersSent) {
       await res.flush();
     }
@@ -5130,25 +5478,37 @@ function createControllerInstance(controller, ctx) {
   return instance;
 }
 export {
+  BadRequestException,
   Cache,
   ColumnDefinition,
+  ConflictException,
   DatabaseConnection,
   Event,
+  ForbiddenException,
   ForeignKeyDefinition,
+  HttpException,
+  InternalServerErrorException,
   LocalDisk,
+  MethodNotAllowedException,
   Migrator,
   Model,
   MysqlDialect,
+  NotFoundException,
   Pagination,
   PostgresqlDialect,
   QueryBuilder,
   SchemaBuilder,
   Seeder,
+  ServiceUnavailableException,
   SqliteDialect,
   Storage,
   SuperApp,
   TableBlueprint,
+  TooManyRequestsException,
   URLBuilder,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  ValidationException,
   cacheResponse,
   createControllerInstance,
   createDialect,
@@ -5156,6 +5516,8 @@ export {
   createEvent,
   createStorage,
   event,
+  normalizeError,
+  registerExceptionHandler,
   registerMacro,
   responseMacros,
   speexjs,